w32 = require("w32")

-- Возвращает handle главного окна QUIK или 0 при ошибке
-- Если запущено несколько терминалов - выбирается тот QUIK, из которого запущен наш скрипт
function GetQuikMainWindowHandle()
    local hQuikWnd = 0
    while true do
        hQuikWnd = w32.FindWindowEx(0, hQuikWnd, "InfoClass", "")
        if hQuikWnd == 0 then
            break
        end
        local t,WinProcId = w32.GetWindowThreadProcessId(hQuikWnd)
        if WinProcId == w32.GetCurrentProcessId() then
            break
        end
    end

    return hQuikWnd
end

-- Тестовая функция создания пользовательского окна с таблицей
function CreateTableWindow(caption)
    local t_id = AllocTable()   
    AddColumn(t_id, 0, "1", true, QTABLE_INT_TYPE, 15)
    AddColumn(t_id, 1, "2", true, QTABLE_INT_TYPE, 15)
    local t = CreateWindow(t_id)
    SetWindowCaption(t_id, caption)
    InsertRow(t_id, -1)
    SetCell(t_id, 1, 1, "<<" .. caption .. ">>")
end

-- Основной код

hQuikWnd = GetQuikMainWindowHandle()

-- получим handle окна вкладок, далее все операции по переключению вкладок будем совершать с этим окном
hTabWnd = 0
if hQuikWnd > 0 then
    hTabWnd = w32.FindWindowEx(hQuikWnd, 0, "SysTabControl32", "")
    if hTabWnd ~= 0 and not w32.IsWindowVisible(hTabWnd) then
        -- Если окно вкладок найдено, но отображение вкладок отключено - сбросим в 0
        hTabWnd = 0
    end
end

if hTabWnd > 0 then
    -- Если вкладки в терминале отображаются
    -- Сохраним индекс текущей активной вкладки
    local prevIdx = w32.TabCtrl_GetCurFocus(hTabWnd)

    -- Определим и выведем через message() наименование активной вкладки на момент старта
    -- (индекс активной вкладки сохранён ранее, так что здесь получаем / отображаем имя просто так)
    -- w32.TabCtrl_GetItemText() вызываем только с 1 параметром, т.к. нас интересует имя активной вкладки
    local activeTabName = w32.TabCtrl_GetItemText(hTabWnd)
    if activeTabName then
        -- т.к. явно проверили, что имя вкладки получить удалось (оно не nil)
        -- просто отображаем его без tostring()
        message("Активна вкладка: " .. activeTabName)
    end

    -- Получим индекс вкладки с именем "Графики" (если такая существует)
    local idxGr = w32.TabCtrl_GetItemIndexByText(hTabWnd, "Графики")
    if idxGr >= 0 then
        -- Если вкладка "Графики" найдена
        -- переключимся на неё и создадим таблицу на ней, получив имя
        w32.TabCtrl_SetCurFocus(hTabWnd, idxGr)
        -- Получим название текущей активной вкладки (только что на нее переключились)
        local txt = w32.TabCtrl_GetItemText(hTabWnd)
        -- Используем tostring(), т.к. TabCtrl_GetItemText при ошибке возвращает nil
        CreateTableWindow("Вкладка '" .. tostring(txt) .. "'")
    end

    -- Получим общее количество вкладок
    cnt = w32.TabCtrl_GetItemCount(hTabWnd)
    for i = 0, cnt-1 do
        -- Переключаемся поочередно на каждую вкладку и создаем таблицу с именем вкладки
        w32.TabCtrl_SetCurFocus(hTabWnd, i)
        -- Получим название вкладки
        -- т.к. получаем название текущей активной вкладки (только что на нее переключились),
        -- то второй параметр можно не указывать; но здесь оставлен второй параметр для тестов
        local txt = w32.TabCtrl_GetItemText(hTabWnd, i)
        -- Используем tostring(), т.к. TabCtrl_GetItemText при ошибке возвращает nil
        CreateTableWindow(tostring(txt))
    end

    -- Переключимся назад на исходную вкладку
    w32.TabCtrl_SetCurFocus(hTabWnd, prevIdx)
else
    -- Если вкладки в терминале не отображаются
    CreateTableWindow("Вкладки отключены")
end

-- логин и пароль для терминала
QUIK_LOGIN = "7"
QUIK_PASSW = "123"

-- подключить библиотеку w32
local w32 = require("w32")

-- функция проигрывания файла
-- вызов: PlaySoundFile("имя файла")
function PlaySoundFile(file_name)
  w32.mciSendString("CLOSE QUIK_MP3") 
  w32.mciSendString("OPEN \"" .. file_name .. "\" TYPE MpegVideo ALIAS QUIK_MP3")
  w32.mciSendString("PLAY QUIK_MP3")
end

-- проиграть звуковой файл из каталога Windows XP
PlaySoundFile("C:\\WINDOWS\\Media\\Windows XP - запуск.wav")

using System;
using System.Collections.Generic;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Runtime.InteropServices;
using System.IO;
using System.IO.Pipes;
using System.Threading;
using System.ComponentModel;
using System.Timers;
using System.Linq;

namespace TestPipe
{
    /// <summary>
    /// Логика взаимодействия для MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        protected override void OnClosing(CancelEventArgs e)
        {
            if (pipe != null)
            {
                pipe.Dispose();
            }
        }

        System.Timers.Timer _Timer = new System.Timers.Timer();
        NamedPipeClientStream pipe;
        public MainWindow()
        {
            InitializeComponent();
            string pipeName = "AmiBroker2QUIK_SBER@EQBR_1_1MINUTES";
            if (System.IO.Directory.GetFiles(@"\\.\pipe\").FirstOrDefault(p => p == "\\\\.\\pipe\\" + pipeName) != null)
            {
                pipe = new NamedPipeClientStream(pipeName);
                bool cr = pipe.CanRead;
                pipe.Connect();
                _Timer.Elapsed += UpdateChart;
            }
            else 
            { 
                pipe = null;
            }
        }

        public void WriteLine(string Line)
        {
            if ((Line.Length < 3) && (Line != Environment.NewLine))
            { Line = "0" + Line; }
            Dispatcher.BeginInvoke(new Action(() =>
            {
                this.textBox1.Text = this.textBox1.Text + Line;
            }));
        }

        private byte[] ReadPipe(NamedPipeClientStream NamedPipe, int size)
        {
            int bc = 0;
            int bc2 = 0;
            byte[] outByte = new byte[size];
            try
            {
                if (size > 1024)
                {
                    do
                    {
                        bc = NamedPipe.Read(outByte, bc2, size - bc2);
                        bc2 = bc + bc2;
                    }
                    while (bc2 < size);
                }
                else
                {
                    bc = NamedPipe.Read(outByte, 0, size);
                    bc2 = bc;
                }
            }
            catch { }
            return outByte.Take(bc2).ToArray();
        }

        int i = 0;
        byte[] CandleBytes = new byte[48];
        bool IsStream = false;
        bool IsFirstRead = true;
        int BarCount = 0;
        int cs = 0;
        private void UpdateChart(object sender, ElapsedEventArgs args)
        {
            UpdateChart();
        }

        int size = 1024;
        private void UpdateChart()
        {
            if (pipe != null)
            {

                byte[] bytes;
                if (IsFirstRead)
                {
                    bytes = ReadPipe(pipe, size);
                    int _cb = 0;
                    foreach (var b in bytes)
                    {
                        if (_cb > 3)
                        {
                            if ((bytes[_cb - 3] == 7) && (bytes[_cb - 2] == 0))
                            {
                                byte[] BarCountB = bytes.Skip(_cb - 1).Take(2).ToArray();
                                BarCount = BitConverter.ToInt16(BarCountB, 0);
                                size = (BarCount + 36) * 49;
                                break;
                            }
                        }
                        _cb++;
                    }
                }
                else
                {
                    bytes = ReadPipe(pipe, size);
                    size = 1024;
                }

                int cb = 0;
                string outStr = "";
                foreach (var b in bytes)
                {
                    if (cb > 2)
                    {
                        if ((bytes[cb - 2] == 8) && (b == 0) && (!IsStream))
                        {
                            IsStream = true;
                        }
                    }
                    if (IsStream)
                    {
                        if ((i >= 48) && (IsStream))
                        {
                            i = 0;
                            byte[] CandleBytes2 = CandleBytes;
                            CandleBytes = new byte[48];
                            IsStream = false;
                            byte[] dateB = CandleBytes2.Take(8).ToArray();
                            long dDate = BitConverter.ToInt64(dateB, 0);
                            if (dDate != 0)
                            {
                                DateTime pDate = (new DateTime(1970, 1, 1, 4, 0, 0, 0)).AddSeconds(Convert.ToInt64(dDate.ToString().Substring(0, 11)) - 11644488000);
                                byte[] OpenB = CandleBytes2.Skip(8).Take(8).ToArray();
                                double Open = BitConverter.ToDouble(OpenB, 0);
                                byte[] HighB = CandleBytes2.Skip(16).Take(8).ToArray();
                                double High = BitConverter.ToDouble(HighB, 0);
                                byte[] LowB = CandleBytes2.Skip(24).Take(8).ToArray();
                                double Low = BitConverter.ToDouble(LowB, 0);
                                byte[] CloseB = CandleBytes2.Skip(32).Take(8).ToArray();
                                double Close = BitConverter.ToDouble(CloseB, 0);
                                byte[] VolumeB = CandleBytes2.Skip(40).Take(8).ToArray();
                                double Volume = BitConverter.ToDouble(VolumeB, 0);

                                outStr += cs.ToString() + "; ";
                                outStr += pDate.ToString() + "; ";
                                outStr += Open.ToString() + "; ";
                                outStr += High.ToString() + "; ";
                                outStr += Low.ToString() + "; ";
                                outStr += Close.ToString() + "; ";
                                outStr += Volume.ToString();
                                outStr += Environment.NewLine;
                                cs++;
                            }
                        }
                        else
                        {
                            CandleBytes[i] = b;
                            ++i;
                        }
                    }
                    ++cb;
                }
                if (outStr != "")
                {
                    WriteLine(outStr);
                }

                if ((!IsFirstRead)&&(_Timer.Interval != 200))
                {
                    _Timer.Interval = 200;
                    _Timer.Start();
                }

                if (IsFirstRead)
                {
                    IsFirstRead = false;
                    UpdateChart();
                }
            }
        }

        private void button2_Click(object sender, RoutedEventArgs e)
        {
            UpdateChart();
        }
    }
}