Console.mq5

//+------------------------------------------------------------------+
//|                                                      Console.mq5 |
//|                                  Copyright © 2026, EarnForex.com |
//|                                       https://www.earnforex.com/ |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2026, EarnForex.com"
#property link      "https://www.earnforex.com/software/MT5-Console/"
#property service
#property version   "1.00"
string    Version = "1.00";

#property description "MT5 Console adds a command line interface to MetaTrader 5 terminal."
#property description "Press ` (backtick) to toggle the console window."
#property description ""
#property description "WARNING: Use at your own risk. No functionality is guaranteed."

#include <Trade\Trade.mqh>

//+------------------------------------------------------------------+
//| Windows DLL Imports                                              |
//+------------------------------------------------------------------+
#import "user32.dll"
    long CreateWindowExW(uint dwExStyle,
                             string lpClassName,
                             string lpWindowName,
                             uint dwStyle,
                             int x, int y,
                             int nWidth, int nHeight,
                             long hWndParent,
                             long hMenu,
                             long hInstance,
                             long lpParam);
    
    // Alternative with ushort array for class name.
    long CreateWindowExW(uint dwExStyle,
                             const ushort &lpClassName[],
                             const ushort &lpWindowName[],
                             uint dwStyle,
                             int x, int y,
                             int nWidth, int nHeight,
                             long hWndParent,
                             long hMenu,
                             long hInstance,
                             long lpParam);
    
    bool DestroyWindow(long hWnd);
    bool ShowWindow(long hWnd, int nCmdShow);
    bool GetClientRect(long hWnd, int &lpRect[]);
    bool IsWindow(long hWnd);
    long FindWindowW(string lpClassName, string lpWindowName);
    long FindWindowExW(long hWndParent, long hWndChildAfter, string lpszClass, string lpszWindow);
    long GetParent(long hWnd);
    bool SetWindowPos(long hWnd, long hWndInsertAfter, int X, int Y, 
                          int cx, int cy, uint uFlags);
    bool MoveWindow(long hWnd, int X, int Y, int nWidth, int nHeight, bool bRepaint);
    
    short GetAsyncKeyState(int vKey);
    
    long GetDC(long hWnd);
    bool ReleaseDC(long hWnd, long hDC);
    bool FillRect(long hdc, const int &lprc[], long hbr);
    
    bool GetWindowRect(long hWnd, int &lpRect[]);
    
    int MessageBoxW(long hWnd, string lpText, string lpCaption, uint uType);
    
    long GetWindowLongW(long hWnd, int nIndex);
    bool EnableWindow(long hWnd, bool bEnable);
    bool SetForegroundWindow(long hWnd);
    long GetForegroundWindow();
    long GetWindow(long hWnd, uint uCmd);
    long SendMessageW(long hWnd, uint Msg, long wParam, long lParam);
    void keybd_event(uchar bVk, uchar bScan, uint dwFlags, uint dwExtraInfo);
    bool IsWindowVisible(long hWnd);
    bool SetWindowTextW(long hWnd, string lpString);
    
    // Message pump.
    bool PeekMessageW(uchar &lpMsg[], long hWnd, uint wMsgFilterMin, uint wMsgFilterMax, uint wRemoveMsg);
    bool TranslateMessage(const uchar &lpMsg[]);
    long DispatchMessageW(const uchar &lpMsg[]);
    bool PostMessageW(long hWnd, uint Msg, long wParam, long lParam);
    int RegisterWindowMessageW(string lpString);
    long GetDlgItem(long hDlg, int nIDDlgItem);
    
    // Overloads with long params.
    long SendMessageW(long hWnd, uint Msg, long wParam, uchar &lParam[]);
    long SendMessageW(long hWnd, uint Msg, long wParam, int &lParam[]);
    
    // Mouse and window.
    int SetCursorPos(int x, int y);
    void mouse_event(uint dwFlags, uint dx, uint dy, uint dwData, ulong dwExtraInfo);
    int GetClassNameW(long hWnd, ushort &lpClassName[], int nMaxCount);
    int GetWindowTextW(long hWnd, ushort &lpString[], int nMaxCount);
    int GetWindowTextLengthW(long hWnd);
    long SetFocus(long hWnd);
    
    // Clipboard.
    bool OpenClipboard(long hWndNewOwner);
    bool CloseClipboard();
    bool EmptyClipboard();
    long GetClipboardData(uint uFormat);
    
    // Menu functions.
    long GetMenu(long hWnd);
    long GetSubMenu(long hMenu, int nPos);
    int GetMenuItemCount(long hMenu);
    uint GetMenuItemID(long hMenu, int nPos);
    int GetMenuStringW(long hMenu, uint uIDItem, ushort &lpString[], int cchMax, uint flags);
#import

// WIN32_FIND_DATAW structure for file enumeration.
struct FILETIME
{
    uint dwLowDateTime;
    uint dwHighDateTime;
};

struct WIN32_FIND_DATAW
{
    uint     dwFileAttributes;
    FILETIME ftCreationTime;
    FILETIME ftLastAccessTime;
    FILETIME ftLastWriteTime;
    uint     nFileSizeHigh;
    uint     nFileSizeLow;
    uint     dwReserved0;
    uint     dwReserved1;
    ushort   cFileName[260];      // MAX_PATH
    ushort   cAlternateFileName[14];
};

#define FILE_ATTRIBUTE_DIRECTORY 0x10

#import "kernel32.dll"
    // File functions.
    int CreateFileW(string lpFileName, uint dwDesiredAccess, uint dwShareMode, 
                         int lpSecurityAttributes, uint dwCreationDisposition, 
                         uint dwFlagsAndAttributes, int hTemplateFile);
    bool ReadFile(int hFile, uchar &lpBuffer[], uint nNumberOfBytesToRead, 
                      uint &lpNumberOfBytesRead, int lpOverlapped);
    bool WriteFile(int hFile, const uchar &lpBuffer[], uint nNumberOfBytesToWrite,
                        uint &lpNumberOfBytesWritten, int lpOverlapped);
    bool CloseHandle(int hObject);
    uint GetFileSize(int hFile, uint &lpFileSizeHigh);
    // File search functions.
    long FindFirstFileW(string lpFileName, WIN32_FIND_DATAW &lpFindFileData);
    bool FindNextFileW(long hFindFile, WIN32_FIND_DATAW &lpFindFileData);
    bool FindClose(long hFindFile);
    // Process and module functions.
    uint GetCurrentProcessId();
    uint GetCurrentThreadId();
    void SetLastError(uint dwErrCode);
    int GetFileAttributesW(string lpFileName);
    bool CreateDirectoryW(string lpPathName, int lpSecurityAttributes);
    bool CopyFileW(string lpExistingFileName, string lpNewFileName, bool bFailIfExists);
    bool DeleteFileW(string lpFileName);
    bool RemoveDirectoryW(string lpPathName);
    bool MoveFileW(string lpExistingFileName, string lpNewFileName);
    // Clipboard support.
    long GlobalLock(long hMem);
    bool GlobalUnlock(long hMem);
    string lstrcatW(long string1, const string string2);
    bool CloseHandle(long hObject);  // Overload for long handle.
#import

#import "gdi32.dll"
    long CreateFontW(int nHeight,
                        int nWidth,
                        int nEscapement,
                        int nOrientation,
                        int fnWeight,
                        uint fdwItalic,
                        uint fdwUnderline,
                        uint fdwStrikeOut,
                        uint fdwCharSet,
                        uint fdwOutputPrecision,
                        uint fdwClipPrecision,
                        uint fdwQuality,
                        uint fdwPitchAndFamily,
                        const ushort &lpszFace[]);
    
    long CreateSolidBrush(uint colorValue);
    bool DeleteObject(long hObject);
    long SelectObject(long hdc, long h);
    long GetStockObject(int i);
    bool TextOutW(long hdc, int x, int y, const ushort &lpString[], int c);
    bool SetTextColor(long hdc, uint colorValue);
    bool SetBkColor(long hdc, uint colorValue);
    bool SetBkMode(long hdc, int mode);
    
    // Double-buffering functions.
    long CreateCompatibleDC(long hdc);
    long CreateCompatibleBitmap(long hdc, int cx, int cy);
    bool BitBlt(long hdc, int x, int y, int cx, int cy, long hdcSrc, int x1, int y1, uint rop);
    bool DeleteDC(long hdc);
#import

#import "urlmon.dll"
    int URLDownloadToFileW(long pCaller, string szURL, string szFileName, uint dwReserved, long lpfnCB);
#import

#import "shell32.dll"
    long ShellExecuteW(long hwnd, string lpOperation, string lpFile, string lpParameters, string lpDirectory, int nShowCmd);
#import

//+------------------------------------------------------------------+
//| Constants                                                        |
//+------------------------------------------------------------------+
#define WS_POPUP            0x80000000
#define WS_VISIBLE          0x10000000
#define WS_BORDER           0x00800000
#define WS_CAPTION          0x00C00000
#define WS_SYSMENU          0x00080000
#define WS_MINIMIZEBOX      0x00020000
#define WS_MAXIMIZEBOX      0x00010000

#define WS_EX_TOPMOST       0x00000008
#define WS_EX_APPWINDOW     0x00040000

#define SW_HIDE             0
#define SW_SHOWNORMAL       1
#define SW_SHOW             5

#define VK_RETURN           0x0D
#define VK_ESCAPE           0x1B
#define VK_BACK             0x08
#define VK_UP               0x26
#define VK_DOWN             0x28
#define VK_LEFT             0x25
#define VK_RIGHT            0x27
#define VK_HOME             0x24
#define VK_END              0x23
#define VK_DELETE           0x2E
#define VK_F4               0x73
#define VK_F10              0x79
#define VK_PRIOR            0x21  // Page Up.
#define VK_NEXT             0x22  // Page Down.
#define VK_OEM_3            0xC0  // Backtick.
#define VK_SHIFT            0x10
#define VK_INSERT           0x2D
#define VK_V                0x56
#define VK_SPACE            0x20
#define VK_TAB              0x09
#define VK_LWIN             0x5B  // Left Windows key.
#define VK_RWIN             0x5C  // Right Windows key.
#define VK_NUMPAD0          0x60
#define VK_NUMPAD1          0x61
#define VK_NUMPAD2          0x62
#define VK_NUMPAD3          0x63
#define VK_NUMPAD4          0x64
#define VK_NUMPAD5          0x65
#define VK_NUMPAD6          0x66
#define VK_NUMPAD7          0x67
#define VK_NUMPAD8          0x68
#define VK_NUMPAD9          0x69
#define VK_DECIMAL          0x6E
#define VK_OEM_1            0xBA  // ; :
#define VK_OEM_PLUS         0xBB  // = +
#define VK_OEM_COMMA        0xBC  // , <
#define VK_OEM_MINUS        0xBD  // - _
#define VK_OEM_PERIOD       0xBE  // . >
#define VK_OEM_2            0xBF  // / ?
#define VK_OEM_4            0xDB  // [ {
#define VK_OEM_5            0xDC  // \ |
#define VK_OEM_6            0xDD  // ] }
#define VK_OEM_7            0xDE  // ' "

#define BLACK_BRUSH         4
#define SM_CXSCREEN         0
#define SM_CYSCREEN         1

#define SWP_NOSIZE          0x0001
#define SWP_NOMOVE          0x0002
#define SWP_NOZORDER        0x0004
#define SWP_SHOWWINDOW      0x0040
#define SWP_NOACTIVATE      0x0010

#define RGB(r,g,b)          ((uint)((b)<<16|(g)<<8|(r)))
#define COLOR_BLACK         RGB(0,0,0)
#define COLOR_GREEN         RGB(0,255,0)

#define MB_OK               0x00000000
#define MB_ICONINFORMATION  0x00000040

#define PM_REMOVE           0x0001
#define PM_NOREMOVE         0x0000

#define WM_QUIT             0x0012
#define WM_CLOSE            0x0010
#define WM_COMMAND          0x0111
#define WM_KEYDOWN          0x0100
#define WM_KEYUP            0x0101

// File access constants.
#define GENERIC_READ        0x80000000
#define GENERIC_WRITE       0x40000000
#define WIN_FILE_SHARE_READ 0x00000001
#define OPEN_EXISTING       3
#define CREATE_ALWAYS       2
#define FILE_ATTRIBUTE_NORMAL 0x80
#define INVALID_HANDLE_VALUE -1

#define MF_BYPOSITION       0x0400

#define SS_BLACKRECT        0x00000004
#define WS_CLIPCHILDREN     0x02000000

#define SRCCOPY             0x00CC0020  // BitBlt raster operation.

#define GW_CHILD            5  // GetWindow command to get first child.
#define GW_HWNDNEXT         2  // GetWindow command to get next sibling.

// Tab control messages.
#define TCM_FIRST           0x1300
#define TCM_GETITEMCOUNT    (TCM_FIRST + 4)
#define TCM_GETITEMRECT     (TCM_FIRST + 10)
#define TCM_GETCURSEL       (TCM_FIRST + 11)

// ListView messages.
#define LVM_FIRST           0x1000
#define LVM_GETITEMCOUNT    (LVM_FIRST + 4)
#define LVM_GETITEMTEXTW    (LVM_FIRST + 115)
#define LVM_GETHEADER       (LVM_FIRST + 31)

// Cross-process memory constants.
#define CF_UNICODETEXT      13      // Clipboard format for Unicode text.
#define WM_MDIGETACTIVE     0x0229  // MDI message to get active child.

#define KEYEVENTF_KEYUP     0x0002  // Key up flag for keybd_event.
#define VK_CONTROL          0x11    // Ctrl key.
#define VK_MENU             0x12    // Alt key.
#define VK_E                0x45    // E key.

// MT internal message load types.
#define MT_LOAD_STANDARD_INDICATOR  13
#define MT_LOAD_EXPERT              14
#define MT_LOAD_CUSTOM_INDICATOR    15
#define MT_LOAD_SCRIPT              16

// Button message.
#define BM_CLICK            0x00F5

// TreeView messages and constants.
#define TV_FIRST            0x1100
#define TVM_EXPAND          (TV_FIRST + 2)
#define TVM_GETITEMRECT     (TV_FIRST + 4)
#define TVM_GETNEXTITEM     (TV_FIRST + 10)
#define TVM_SELECTITEM      (TV_FIRST + 11)
#define TVM_GETITEMW        (TV_FIRST + 62)

#define TVGN_ROOT           0x0000
#define TVGN_NEXT           0x0001
#define TVGN_CHILD          0x0004
#define TVGN_CARET          0x0009

#define TVE_EXPAND          0x0002

#define TVIF_TEXT           0x0001
#define TVIF_HANDLE         0x0010

// Mouse event constants.
#define MOUSEEVENTF_LEFTDOWN    0x0002
#define MOUSEEVENTF_LEFTUP      0x0004
#define MOUSEEVENTF_RIGHTDOWN   0x0008
#define MOUSEEVENTF_RIGHTUP     0x0010
#define MOUSEEVENTF_ABSOLUTE    0x8000

// WM constants for mouse.
#define WM_LBUTTONDOWN      0x0201
#define WM_LBUTTONUP        0x0202
#define MK_LBUTTON          0x0001

//+------------------------------------------------------------------+
//| Format money value with thousands separator and currency         |
//+------------------------------------------------------------------+
string FormatMoney(double amount, bool showSign = false)
{
    string currency = AccountInfoString(ACCOUNT_CURRENCY);
    bool negative = (amount < 0);
    if (negative) amount = -amount;
    
    // Format to 2 decimal places.
    string str = DoubleToString(amount, 2);
    
    // Find decimal point.
    int decPos = StringFind(str, ".");
    if (decPos < 0) decPos = StringLen(str);
    
    // Add commas to integer part.
    string intPart = StringSubstr(str, 0, decPos);
    string decPart = StringSubstr(str, decPos);
    
    string formatted = "";
    int len = StringLen(intPart);
    for (int i = 0; i < len; i++)
    {
        if (i > 0 && (len - i) % 3 == 0)
            formatted += ",";
        formatted += StringSubstr(intPart, i, 1);
    }
    
    // Build result.
    string result = "";
    if (showSign)
    {
        if (negative)
            result = "-";
        else
            result = "+";
    }
    else if (negative)
    {
        result = "-";
    }
    
    result += formatted + decPart + " " + currency;
    return result;
}

//+------------------------------------------------------------------+
//| Windows Console Class                                           |
//+------------------------------------------------------------------+
class CWindowsConsole
{
private:
    long              m_hwnd;
    long              m_hwndMT5;
    long              m_hFont;
    long              m_hBrush;
    bool              m_visible;
    string            m_lines[];
    string            m_inputText;
    int               m_cursorPos;
    string            m_commandHistory[];
    int               m_historyIndex;
    int               m_scrollOffset;
    int               m_maxVisibleLines;
    int               m_maxBufferLines;
    bool              m_needsRedraw;
    bool              m_quitRequested;
    uint              m_lastMessageTime;
    long              m_currentChartId;  // Track which chart we're attached to.
    
    // Undo tracking.
    string            m_lastUndoCommand;  // Command type that can be undone.
    string            m_lastUndoData;     // Data needed for undo (object name, indicator, etc.).
    long              m_lastUndoChartId;  // Chart ID where action was performed.
    
    // Breathing mode.
    bool              m_breathingMode;
    uint              m_breathingStart;
    int               m_breathingDuration;  // seconds
    int               m_breathingPhase;     // 0=inhale, 1=exhale
    uint              m_breathingPhaseStart;
    
    // Shutdown timer.
    bool              m_shutdownPending;
    uint              m_shutdownStart;
    int               m_shutdownDuration;   // seconds
    bool              m_shutdownWarned;     // 1-minute warning shown
    int               m_lastCountdown;      // last countdown value shown
    
public:
                            CWindowsConsole();
                          ~CWindowsConsole();
    
    bool              Create();
    void              Destroy();
    void              Toggle();
    void              Show();
    void              Hide();
    bool              IsVisible() { return m_visible; }
    bool              IsQuitRequested() { return m_quitRequested; }
    bool              IsMT5Active();  // Check if MT5 or console is the active window.
    void              UpdatePosition();  // Reposition to active chart.
    
    void              ProcessChar(string c);
    void              ProcessKey(int keyCode);
    void              Redraw();
    void              ForceRedraw();
    void              AddLine(string text);
    void              ExecuteCommand(string cmd);
    bool              ProcessMessages();  // Returns false if window was closed.
    bool              IsBreathing() { return m_breathingMode; }
    void              UpdateBreathing();  // Update breathing animation.
    bool              IsShutdownPending() { return m_shutdownPending; }
    void              UpdateShutdown();   // Update shutdown countdown.
    
private:
    void              DrawConsole();
    void              ScrollUp();
    void              ScrollDown();
    void              ScrollToBottom();
    long              FindMT5Window();
    long              GetActiveChartId();
    void              InstallFromURL(string url);
    bool              DownloadFile(string url, string localPath);
    bool              ExtractZip(string zipPath, string destPath);
    string            GetMQL5Folder(string fileType);
    string            FindDownloadLink(string html, string baseUrl);
    string            ReadZipComment(string zipPath);
    int               InstallExtractedFiles(string srcPath, string destPath);
    void              LoadHistory();
    void              SaveHistory();
    
    // Helper: finds Toolbox window and tab control (pure enumeration, no Sleep).
    bool              FindToolbox(long &hToolbox, long &hTabControl);
    // Helper: opens Toolbox via View menu if not already open.
    bool              OpenToolbox(long &hToolbox, long &hTabControl);
    // Helper: finds first visible SysListView32 child (pure enumeration, no Sleep).
    long              FindVisibleListView(long hParent);
    // Helper: simulates key press (down + up, no Sleep).
    void              PressKey(int vk);
    // Helper: simulates mouse click at screen coordinates (no Sleep).
    void              ClickAt(int x, int y);
    // Helper: switch to adjacent chart (direction: -1 = left, +1 = right).
    void              SwitchChart(int direction);
    // Helper: execute buy/sell trade (isBuy: true=buy, false=sell; isAsync: true=async mode).
    void              ExecuteTrade(bool isBuy, bool isAsync, string args);
    // Helper: set color scheme (modeIndex: 0=system, 1=light, 2=dark).
    void              SetColorScheme(int modeIndex, string modeName);
};

//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CWindowsConsole::CWindowsConsole()
{
    m_hwnd = 0;
    m_hwndMT5 = 0;
    m_hFont = 0;
    m_hBrush = 0;
    m_visible = false;
    m_inputText = "";
    m_cursorPos = 0;
    m_historyIndex = -1;
    m_scrollOffset = 0;
    m_maxVisibleLines = 20;
    m_maxBufferLines = 1000;
    m_needsRedraw = false;
    m_quitRequested = false;
    m_lastMessageTime = 0;
    m_currentChartId = 0;
    
    // Undo tracking.
    m_lastUndoCommand = "";
    m_lastUndoData = "";
    m_lastUndoChartId = 0;
    
    // Breathing mode.
    m_breathingMode = false;
    m_breathingStart = 0;
    m_breathingDuration = 30;
    m_breathingPhase = 0;
    m_breathingPhaseStart = 0;
    
    // Shutdown timer.
    m_shutdownPending = false;
    m_shutdownStart = 0;
    m_shutdownDuration = 0;
    m_shutdownWarned = false;
    m_lastCountdown = -1;
    
    ArrayResize(m_lines, 0);
    ArrayResize(m_commandHistory, 0);
}

//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CWindowsConsole::~CWindowsConsole()
{
    Destroy();
}

//+------------------------------------------------------------------+
//| Load command history from file.                                  |
//+------------------------------------------------------------------+
void CWindowsConsole::LoadHistory()
{
    int hFile = FileOpen("console_history.txt", FILE_READ|FILE_TXT|FILE_ANSI);
    if (hFile == INVALID_HANDLE)
        return;  // No history file yet.
    
    while (!FileIsEnding(hFile))
    {
        string line = FileReadString(hFile);
        StringTrimRight(line);
        StringTrimLeft(line);
        if (StringLen(line) > 0)
        {
            int size = ArraySize(m_commandHistory);
            if (size < 100)  // Max 100 commands.
            {
                ArrayResize(m_commandHistory, size + 1);
                m_commandHistory[size] = line;
            }
        }
    }
    FileClose(hFile);
}

//+------------------------------------------------------------------+
//| Save command history to file.                                    |
//+------------------------------------------------------------------+
void CWindowsConsole::SaveHistory()
{
    int hFile = FileOpen("console_history.txt", FILE_WRITE|FILE_TXT|FILE_ANSI);
    if (hFile == INVALID_HANDLE)
        return;
    
    // Keep last 100 commands.
    int total = ArraySize(m_commandHistory);
    int start = MathMax(0, total - 100);
    
    for (int i = start; i < total; i++)
    {
        FileWriteString(hFile, m_commandHistory[i] + "\n");
    }
    FileClose(hFile);
}

//+------------------------------------------------------------------+
//| Find Toolbox window and its tab control.                         |
//| Returns true if both found, false otherwise.                     |
//| Pure window enumeration - no Sleep calls.                        |
//+------------------------------------------------------------------+
bool CWindowsConsole::FindToolbox(long &hToolbox, long &hTabControl)
{
    hToolbox = 0;
    hTabControl = 0;
    
    long hChild = GetWindow(m_hwndMT5, GW_CHILD);
    while (hChild != 0)
    {
        ushort className[64];
        ArrayInitialize(className, 0);
        GetClassNameW(hChild, className, 64);
        string classStr = ShortArrayToString(className);
        
        ushort windowText[128];
        ArrayInitialize(windowText, 0);
        GetWindowTextW(hChild, windowText, 128);
        string textStr = ShortArrayToString(windowText);
        
        // Check class, text, AND visibility.
        if (StringFind(classStr, "Afx:ControlBar") >= 0 && 
             StringFind(textStr, "Toolbox") >= 0 &&
             IsWindowVisible(hChild))
        {
            hToolbox = hChild;
            
            // Find tab control inside Toolbox.
            long hToolChild = GetWindow(hToolbox, GW_CHILD);
            while (hToolChild != 0)
            {
                ushort childClass[64];
                ArrayInitialize(childClass, 0);
                GetClassNameW(hToolChild, childClass, 64);
                string childClassStr = ShortArrayToString(childClass);
                
                if (StringFind(childClassStr, "SysTabControl32") >= 0)
                {
                    hTabControl = hToolChild;
                    break;
                }
                hToolChild = GetWindow(hToolChild, GW_HWNDNEXT);
            }
            break;
        }
        hChild = GetWindow(hChild, GW_HWNDNEXT);
    }
    
    return (hToolbox != 0 && hTabControl != 0);
}

//+------------------------------------------------------------------+
//| Open Toolbox via View menu if not already visible.               |
//| Returns true if Toolbox is found/opened, fills handles.          |
//+------------------------------------------------------------------+
bool CWindowsConsole::OpenToolbox(long &hToolbox, long &hTabControl)
{
    // First check if already open.
    if (FindToolbox(hToolbox, hTabControl))
        return true;
    
    // Open via View menu.
    long hMenu = GetMenu(m_hwndMT5);
    if (hMenu == 0)
        return false;
    
    // Find View menu.
    int menuCount = GetMenuItemCount(hMenu);
    long hViewMenu = 0;
    
    for (int i = 0; i < menuCount; i++)
    {
        ushort menuText[64];
        ArrayInitialize(menuText, 0);
        GetMenuStringW(hMenu, i, menuText, 64, MF_BYPOSITION);
        string menuName = ShortArrayToString(menuText);
        
        if (StringFind(menuName, "View") >= 0 || StringFind(menuName, "iew") >= 0)
        {
            hViewMenu = GetSubMenu(hMenu, i);
            break;
        }
    }
    
    if (hViewMenu == 0)
        return false;
    
    // Find Toolbox item in View menu.
    int viewCount = GetMenuItemCount(hViewMenu);
    uint toolboxCmdId = 0;
    
    for (int i = 0; i < viewCount; i++)
    {
        ushort menuText[64];
        ArrayInitialize(menuText, 0);
        GetMenuStringW(hViewMenu, i, menuText, 64, MF_BYPOSITION);
        string menuName = ShortArrayToString(menuText);
        
        if (StringFind(menuName, "Toolbox") >= 0)
        {
            toolboxCmdId = GetMenuItemID(hViewMenu, i);
            break;
        }
    }
    
    if (toolboxCmdId == 0 || toolboxCmdId == 0xFFFFFFFF)
        return false;
    
    // Send command to toggle Toolbox.
    PostMessageW(m_hwndMT5, WM_COMMAND, (int)toolboxCmdId, 0);
    Sleep(100);
    
    // Try to find Toolbox again.
    return FindToolbox(hToolbox, hTabControl);
}

//+------------------------------------------------------------------+
//| Find first visible SysListView32 child window.                   |
//| Returns handle or 0 if not found.                                |
//| Pure window enumeration - no Sleep calls.                        |
//+------------------------------------------------------------------+
long CWindowsConsole::FindVisibleListView(long hParent)
{
    if (hParent == 0)
        return 0;
    
    long hChild = GetWindow(hParent, GW_CHILD);
    while (hChild != 0)
    {
        ushort childClass[64];
        ArrayInitialize(childClass, 0);
        GetClassNameW(hChild, childClass, 64);
        string childClassStr = ShortArrayToString(childClass);
        
        if (StringFind(childClassStr, "SysListView32") >= 0 && IsWindowVisible(hChild))
            return hChild;
        
        hChild = GetWindow(hChild, GW_HWNDNEXT);
    }
    
    return 0;
}

//+------------------------------------------------------------------+
//| Simulate a key press (down + up).                                |
//| No Sleep calls - timing handled by caller.                       |
//+------------------------------------------------------------------+
void CWindowsConsole::PressKey(int vk)
{
    keybd_event((uchar)vk, 0, 0, 0);
    keybd_event((uchar)vk, 0, KEYEVENTF_KEYUP, 0);
}

//+------------------------------------------------------------------+
//| Simulate mouse click at screen coordinates.                      |
//| No Sleep calls - timing handled by caller.                       |
//+------------------------------------------------------------------+
void CWindowsConsole::ClickAt(int x, int y)
{
    SetCursorPos(x, y);
    mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
    mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
}

//+------------------------------------------------------------------+
//| Switch to adjacent chart (direction: -1 = left, +1 = right).     |
//+------------------------------------------------------------------+
void CWindowsConsole::SwitchChart(int direction)
{
    // Build list of all chart IDs.
    long charts[];
    int count = 0;
    long chartId = ChartFirst();
    while (chartId >= 0)
    {
        ArrayResize(charts, count + 1);
        charts[count] = chartId;
        count++;
        chartId = ChartNext(chartId);
    }
    
    if (count <= 1)
    {
        AddLine("No other charts open.");
        return;
    }
    
    // Find current chart index.
    int currentIdx = -1;
    for (int i = 0; i < count; i++)
    {
        if (charts[i] == m_currentChartId)
        {
            currentIdx = i;
            break;
        }
    }
    
    if (currentIdx < 0)
        currentIdx = 0;
    
    // Calculate new index with wrap-around.
    int newIdx = (currentIdx + direction + count) % count;
    m_currentChartId = charts[newIdx];
    
    // Bring chart to front.
    ChartSetInteger(m_currentChartId, CHART_BRING_TO_TOP, true);
    
    string sym = ChartSymbol(m_currentChartId);
    ENUM_TIMEFRAMES tf = (ENUM_TIMEFRAMES)ChartPeriod(m_currentChartId);
    AddLine("Switched focus to " + sym + " " + EnumToString(tf) + ".");
}

//+------------------------------------------------------------------+
//| Execute buy or sell trade (sync or async).                       |
//+------------------------------------------------------------------+
void CWindowsConsole::ExecuteTrade(bool isBuy, bool isAsync, string args)
{
    string cmdName = (isBuy ? "buy" : "sell");
    if (isAsync) cmdName = "a" + cmdName;
    
    StringTrimLeft(args);
    StringTrimRight(args);
    
    if (StringLen(args) == 0)
    {
        AddLine("Usage: " + cmdName + " [symbol] <lots> [sl=<price>] [tp=<price>]");
        AddLine("Example: " + cmdName + " 0.1" + (isBuy ? " sl=1.0850 tp=1.0950" : " sl=1.0950 tp=1.0850"));
        AddLine("         " + cmdName + " eurusd 0.1");
        return;
    }
    
    // Parse arguments.
    string parts[];
    StringSplit(args, ' ', parts);
    
    string symbol = "";
    double lots = 0;
    double sl = 0;
    double tp = 0;
    
    for (int i = 0; i < ArraySize(parts); i++)
    {
        string part = parts[i];
        StringTrimLeft(part);
        StringTrimRight(part);
        if (StringLen(part) == 0) continue;
        
        if (StringFind(part, "sl=") == 0)
            sl = StringToDouble(StringSubstr(part, 3));
        else if (StringFind(part, "tp=") == 0)
            tp = StringToDouble(StringSubstr(part, 3));
        else
        {
            double val = StringToDouble(part);
            if (val > 0 && lots == 0)
                lots = val;
            else if (symbol == "" && lots == 0)
            {
                symbol = part;
                StringToUpper(symbol);
            }
        }
    }
    
    // Default to chart symbol if not specified.
    if (symbol == "")
    {
        if (m_currentChartId <= 0)
        {
            AddLine("No active chart - specify symbol.");
            AddLine("Example: " + cmdName + " eurusd 0.1");
            return;
        }
        symbol = ChartSymbol(m_currentChartId);
    }
    
    // Validate symbol exists.
    if (!SymbolInfoInteger(symbol, SYMBOL_EXIST))
    {
        AddLine("Symbol not found: " + symbol);
        return;
    }
    
    // Add to Market Watch if not already there.
    if (!SymbolInfoInteger(symbol, SYMBOL_SELECT))
    {
        if (SymbolSelect(symbol, true))
            AddLine("Added " + symbol + " to Market Watch.");
        else
        {
            AddLine("Failed to add " + symbol + " to Market Watch.");
            return;
        }
    }
    
    if (lots <= 0)
    {
        AddLine("Invalid lot size.");
        return;
    }
    
    if (!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED))
    {
        AddLine("Autotrading is disabled!");
        if (!isAsync) AddLine("Use 'auto' command to enable it.");
        return;
    }
    
    if (!isAsync && SymbolInfoInteger(symbol, SYMBOL_TRADE_MODE) == SYMBOL_TRADE_MODE_DISABLED)
    {
        AddLine("Trading not allowed for: " + symbol);
        return;
    }
    
    // Normalize lot size.
    double minLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN);
    double maxLot = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MAX);
    double lotStep = SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP);
    
    lots = MathMax(minLot, MathMin(maxLot, lots));
    lots = NormalizeDouble(MathFloor(lots / lotStep) * lotStep, 2);
    
    double price = SymbolInfoDouble(symbol, isBuy ? SYMBOL_ASK : SYMBOL_BID);
    int digits = (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS);
    
    // Normalize SL/TP.
    if (sl != 0) sl = NormalizeDouble(sl, digits);
    if (tp != 0) tp = NormalizeDouble(tp, digits);
    
    string orderType = (isBuy ? "BUY" : "SELL");
    if (isAsync) orderType = "Async " + orderType;
    else orderType = "Sending " + orderType;
    
    string orderInfo = orderType + " " + DoubleToString(lots, 2) + " " + symbol + 
                             " @ " + DoubleToString(price, digits);
    if (sl != 0 && !isAsync) orderInfo += " SL=" + DoubleToString(sl, digits);
    if (tp != 0 && !isAsync) orderInfo += " TP=" + DoubleToString(tp, digits);
    AddLine(orderInfo);
    
    // Execute trade.
    CTrade trade;
    trade.SetExpertMagicNumber(123456);
    trade.SetDeviationInPoints(10);
    if (isAsync) trade.SetAsyncMode(true);
    
    string comment = "Console " + (isAsync ? "async " : "") + (isBuy ? "buy" : "sell");
    bool success = isBuy ? trade.Buy(lots, symbol, price, sl, tp, comment)
                                : trade.Sell(lots, symbol, price, sl, tp, comment);
    
    if (success)
    {
        if (isAsync)
        {
            MqlTradeResult result;
            trade.Result(result);
            AddLine("Request sent! ReqID: " + IntegerToString(result.request_id));
        }
        else
        {
            AddLine("SUCCESS! Order #" + IntegerToString(trade.ResultOrder()));
            AddLine("Deal #" + IntegerToString(trade.ResultDeal()) + 
                      " @ " + DoubleToString(trade.ResultPrice(), digits));
        }
    }
    else
    {
        if (isAsync)
            AddLine("FAILED to send request");
        else
        {
            AddLine("FAILED! Retcode: " + IntegerToString(trade.ResultRetcode()));
            AddLine("Comment: " + trade.ResultComment());
        }
    }
}

//+------------------------------------------------------------------+
//| Set MT5 color scheme (0=system, 1=light, 2=dark).                |
//+------------------------------------------------------------------+
void CWindowsConsole::SetColorScheme(int modeIndex, string modeName)
{
    long hMenuBar = GetMenu(m_hwndMT5);
    if (hMenuBar == 0)
    {
        AddLine("Menu bar not found.");
        return;
    }
    
    // Find View menu.
    int menuBarCount = GetMenuItemCount(hMenuBar);
    long hViewMenu = 0;
    ushort menuText[64];
    
    for (int m = 0; m < menuBarCount; m++)
    {
        ArrayInitialize(menuText, 0);
        GetMenuStringW(hMenuBar, m, menuText, 64, MF_BYPOSITION);
        string menuName = ShortArrayToString(menuText);
        StringReplace(menuName, "&", "");
        if (menuName == "View")
        {
            hViewMenu = GetSubMenu(hMenuBar, m);
            break;
        }
    }
    
    if (hViewMenu == 0)
    {
        AddLine("View menu not found.");
        return;
    }
    
    // Find Color Scheme submenu.
    int viewCount = GetMenuItemCount(hViewMenu);
    
    for (int i = 0; i < viewCount; i++)
    {
        ArrayInitialize(menuText, 0);
        GetMenuStringW(hViewMenu, i, menuText, 64, MF_BYPOSITION);
        string itemName = ShortArrayToString(menuText);
        StringReplace(itemName, "&", "");
        
        if (StringFind(itemName, "Color") >= 0 || StringFind(itemName, "Scheme") >= 0)
        {
            long hColorMenu = GetSubMenu(hViewMenu, i);
            if (hColorMenu != 0)
            {
                int colorCount = GetMenuItemCount(hColorMenu);
                if (colorCount >= 3)
                {
                    uint cmdId = GetMenuItemID(hColorMenu, modeIndex);
                    if (cmdId != 0 && cmdId != 0xFFFFFFFF)
                    {
                        PostMessageW(m_hwndMT5, WM_COMMAND, (int)cmdId, 0);
                        AddLine("Switched to " + modeName + " mode.");
                        return;
                    }
                }
            }
        }
    }
    
    AddLine("Color Scheme menu not found in View menu.");
}

//+------------------------------------------------------------------+
//| Find MT5 Window.                                                 |
//+------------------------------------------------------------------+
long CWindowsConsole::FindMT5Window()
{
    long hwnd = FindWindowW("MetaQuotes::MetaTrader::5.00", NULL);
    if (hwnd != 0) 
    {
        Print("Found MT5 window by class name.");
        return hwnd;
    }
    
    hwnd = FindWindowW(NULL, "MetaTrader 5");
    return hwnd;
}

//+------------------------------------------------------------------+
//| Check if MT5 or console is the active window.                    |
//+------------------------------------------------------------------+
bool CWindowsConsole::IsMT5Active()
{
    long hwndForeground = GetForegroundWindow();
    
    if (hwndForeground == 0)
        return false;
    
    // Check if it's the console window.
    if (hwndForeground == m_hwnd)
        return true;
    
    // Check if it's the MT5 main window.
    if (hwndForeground == m_hwndMT5)
        return true;
    
    // Check if it's a child of MT5 (charts, toolbars, etc.).
    long parent = hwndForeground;
    while (parent != 0)
    {
        parent = GetParent(parent);
        if (parent == m_hwndMT5)
            return true;
    }
    
    return false;
}

//+------------------------------------------------------------------+
//| Get the currently active chart ID.                               |
//+------------------------------------------------------------------+
long CWindowsConsole::GetActiveChartId()
{
    // If console is foreground, keep current chart.
    long hwndForeground = GetForegroundWindow();
    if (hwndForeground == m_hwnd)
        return m_currentChartId;
    
    // Find the MDIClient (contains all chart windows).
    long hwndMDI = FindWindowExW(m_hwndMT5, 0, "MDIClient", NULL);
    if (hwndMDI == 0)
        return m_currentChartId > 0 ? m_currentChartId : ChartFirst();
    
    // Use WM_MDIGETACTIVE to get the active MDI child window.
    long hwndActiveChild = SendMessageW(hwndMDI, WM_MDIGETACTIVE, 0, 0);
    if (hwndActiveChild == 0)
        return m_currentChartId > 0 ? m_currentChartId : ChartFirst();
    
    // Find which chart ID has this MDI child as its parent.
    long chartId = ChartFirst();
    while (chartId >= 0)
    {
        long chartHwnd = ChartGetInteger(chartId, CHART_WINDOW_HANDLE);
        long chartParent = GetParent(chartHwnd);
        
        // The MDI active child is the parent frame of the chart window.
        if (chartParent == hwndActiveChild)
            return chartId;
        
        chartId = ChartNext(chartId);
    }
    
    // No match found - keep current or fallback to first.
    return m_currentChartId > 0 ? m_currentChartId : ChartFirst();
}

//+------------------------------------------------------------------+
//| Download a file from URL.                                        |
//+------------------------------------------------------------------+
bool CWindowsConsole::DownloadFile(string url, string localPath)
{
    int result = URLDownloadToFileW(0, url, localPath, 0, 0);
    return (result == 0);  // S_OK = 0
}

//+------------------------------------------------------------------+
//| Extract ZIP file using PowerShell.                               |
//+------------------------------------------------------------------+
bool CWindowsConsole::ExtractZip(string zipPath, string destPath)
{
    // Use PowerShell to extract ZIP
    string psCommand = "powershell -Command \"Expand-Archive -Path '" + zipPath + 
                             "' -DestinationPath '" + destPath + "' -Force\"";
    
    // Execute via ShellExecute.
    long result = ShellExecuteW(0, "open", "cmd.exe", "/C " + psCommand, NULL, 0);
    return (result > 32);  // Values > 32 indicate success.
}

//+------------------------------------------------------------------+
//| Get MQL5 folder based on file type.                              |
//+------------------------------------------------------------------+
string CWindowsConsole::GetMQL5Folder(string fileType)
{
    string dataPath = TerminalInfoString(TERMINAL_DATA_PATH);
    StringReplace(dataPath, "\\", "\\\\");
    
    if (fileType == "ea" || fileType == "expert")
        return dataPath + "\\\\MQL5\\\\Experts";
    else if (fileType == "indicator" || fileType == "ind")
        return dataPath + "\\\\MQL5\\\\Indicators";
    else if (fileType == "script" || fileType == "scr")
        return dataPath + "\\\\MQL5\\\\Scripts";
    else if (fileType == "include" || fileType == "inc")
        return dataPath + "\\\\MQL5\\\\Include";
    else
        return dataPath + "\\\\MQL5\\\\Files";
}

//+------------------------------------------------------------------+
//| Find download link in HTML page.                                 |
//+------------------------------------------------------------------+
string CWindowsConsole::FindDownloadLink(string html, string baseUrl)
{
    // Look for MT5 download links in earnforex.com style pages.
    // Pattern: look for href containing .zip or .mq5 with MT5 nearby.
    
    string result = "";
    
    // First try to find direct .zip link for MT5
    int pos = 0;
    while (pos < StringLen(html))
    {
        int hrefPos = StringFind(html, "href=\"", pos);
        if (hrefPos < 0) break;
        
        int urlStart = hrefPos + 6;
        int urlEnd = StringFind(html, "\"", urlStart);
        if (urlEnd < 0) break;
        
        string linkUrl = StringSubstr(html, urlStart, urlEnd - urlStart);
        
        // Check if it's a download link.
        string linkLower = linkUrl;
        StringToLower(linkLower);
        
        // Look for MT5 zip/mq5/ex5 files.
        if ((StringFind(linkLower, ".zip") >= 0 || 
             StringFind(linkLower, ".mq5") >= 0 || 
             StringFind(linkLower, ".ex5") >= 0) &&
            (StringFind(linkLower, "mt5") >= 0 || StringFind(linkLower, "-5") >= 0 ||
             StringFind(linkLower, "_5") >= 0 || StringFind(linkLower, "5.") >= 0))
        {
            result = linkUrl;
            break;
        }
        
        pos = urlEnd;
    }
    
    // If not found, look for any .zip link.
    if (result == "")
    {
        pos = 0;
        while (pos < StringLen(html))
        {
            int hrefPos = StringFind(html, "href=\"", pos);
            if (hrefPos < 0) break;
            
            int urlStart = hrefPos + 6;
            int urlEnd = StringFind(html, "\"", urlStart);
            if (urlEnd < 0) break;
            
            string linkUrl = StringSubstr(html, urlStart, urlEnd - urlStart);
            string linkLower = linkUrl;
            StringToLower(linkLower);
            
            if (StringFind(linkLower, ".zip") >= 0)
            {
                result = linkUrl;
                break;
            }
            
            pos = urlEnd;
        }
    }
    
    // Make absolute URL if needed.
    if (result != "" && StringFind(result, "http") != 0)
    {
        // Get base domain from baseUrl.
        int domainEnd = StringFind(baseUrl, "/", 8);  // After "https://"
        if (domainEnd < 0) domainEnd = StringLen(baseUrl);
        string domain = StringSubstr(baseUrl, 0, domainEnd);
        
        if (StringGetCharacter(result, 0) == '/')
            result = domain + result;
        else
            result = domain + "/" + result;
    }
    
    return result;
}

//+------------------------------------------------------------------+
//| Read ZIP file comment.                                           |
//+------------------------------------------------------------------+
string CWindowsConsole::ReadZipComment(string zipPath)
{
    // ZIP comment is at the end of the file in End of Central Directory record.
    // EOCD signature: 0x06054b50
    // Comment length is at offset 20 from signature, comment follows at offset 22
    
    int fh = FileOpen(StringSubstr(zipPath, StringFind(zipPath, "\\MQL5\\Files\\") + 12), FILE_READ|FILE_BIN|FILE_SHARE_READ);
    if (fh == INVALID_HANDLE)
        return "";
    
    ulong fileSize = FileSize(fh);
    if (fileSize < 22)
    {
        FileClose(fh);
        return "";
    }
    
    // Search for EOCD signature from end of file (max comment is 65535 bytes).
    ulong searchStart = fileSize > 65557 ? fileSize - 65557 : 0;
    FileSeek(fh, (long)searchStart, SEEK_SET);
    
    uchar buffer[];
    int readSize = (int)(fileSize - searchStart);
    ArrayResize(buffer, readSize);
    FileReadArray(fh, buffer);
    FileClose(fh);
    
    // Find EOCD signature (0x50, 0x4b, 0x05, 0x06).
    int eocdPos = -1;
    for (int i = readSize - 22; i >= 0; i--)
    {
        if (buffer[i] == 0x50 && buffer[i+1] == 0x4b && 
            buffer[i+2] == 0x05 && buffer[i+3] == 0x06)
        {
            eocdPos = i;
            break;
        }
    }
    
    if (eocdPos < 0)
        return "";
    
    // Get comment length (2 bytes at offset 20).
    int commentLen = buffer[eocdPos + 20] + (buffer[eocdPos + 21] << 8);
    if (commentLen == 0 || eocdPos + 22 + commentLen > readSize)
        return "";
    
    // Extract comment.
    string comment = "";
    for (int i = 0; i < commentLen && i < 200; i++)  // Limit to 200 chars.
    {
        uchar c = buffer[eocdPos + 22 + i];
        if (c >= 32 && c < 127)
            comment += CharToString(c);
        else if (c == 10 || c == 13)
            comment += " ";  // Replace newlines with space.
    }
    
    StringTrimLeft(comment);
    StringTrimRight(comment);
    return comment;
}

//+------------------------------------------------------------------+
//| Install extracted files to destination folder.                   |
//+------------------------------------------------------------------+
int CWindowsConsole::InstallExtractedFiles(string srcPath, string destPath)
{
    int installed = 0;
    
    // Use PowerShell to find and copy .ex5 and .mq5 files.
    string dataPath = TerminalInfoString(TERMINAL_DATA_PATH);
    string listFile = dataPath + "\\MQL5\\Files\\temp_install\\filelist.txt";
    
    // Find all .ex5 and .mq5 files.
    string psCmd = "/C powershell -Command \"Get-ChildItem -Path '" + srcPath + 
                        "' -Recurse -Include *.ex5,*.mq5 | ForEach-Object { $_.FullName } | Out-File -FilePath '" + 
                        listFile + "' -Encoding ASCII\"";
    ShellExecuteW(0, "open", "cmd.exe", psCmd, "", SW_HIDE);
    Sleep(1000);
    
    // Read the file list.
    int fh = FileOpen("temp_install\\filelist.txt", FILE_READ|FILE_TXT|FILE_ANSI);
    if (fh == INVALID_HANDLE)
        return 0;
    
    while (!FileIsEnding(fh))
    {
        string filePath = FileReadString(fh);
        StringTrimLeft(filePath);
        StringTrimRight(filePath);
        
        if (StringLen(filePath) < 5)
            continue;
        
        // Extract filename.
        string fileName = "";
        for (int i = StringLen(filePath) - 1; i >= 0; i--)
        {
            if (StringGetCharacter(filePath, i) == '\\')
            {
                fileName = StringSubstr(filePath, i + 1);
                break;
            }
        }
        
        if (StringLen(fileName) == 0)
            continue;
        
        // Copy to destination.
        string destFile = destPath + "\\" + fileName;
        if (CopyFileW(filePath, destFile, false))
        {
            AddLine("  Installed: " + fileName);
            installed++;
        }
    }
    FileClose(fh);
    
    return installed;
}

//+------------------------------------------------------------------+
//| Install MQL5 program from URL.                                   |
//+------------------------------------------------------------------+
void CWindowsConsole::InstallFromURL(string url)
{
    AddLine("Installing from: " + url);
    ForceRedraw();
    
    // Detect type from URL
    string urlLower = url;
    StringToLower(urlLower);
    
    string installType = "expert";  // Default.
    if (StringFind(urlLower, "/indicators/") >= 0 || 
        StringFind(urlLower, "metatrader-indicators") >= 0 ||
        StringFind(urlLower, "mt5-indicators") >= 0)
        installType = "indicator";
    else if (StringFind(urlLower, "/scripts/") >= 0 || 
              StringFind(urlLower, "metatrader-scripts") >= 0 ||
              StringFind(urlLower, "mt5-scripts") >= 0)
        installType = "script";
    else if (StringFind(urlLower, "/expert-advisors/") >= 0 || 
              StringFind(urlLower, "/experts/") >= 0 ||
              StringFind(urlLower, "metatrader-expert-advisors") >= 0 ||
              StringFind(urlLower, "mt5-experts") >= 0)
        installType = "expert";
    
    // Determine data path for temp files.
    string dataPath = TerminalInfoString(TERMINAL_DATA_PATH);
    string tempPath = dataPath + "\\MQL5\\Files\\temp_install";
    string tempFile = tempPath + "\\download";
    
    // Create temp directory.
    CreateDirectoryW(tempPath, 0);
    
    // Check if it's a direct file download or a webpage.
    bool isDirectFile = (StringFind(urlLower, ".zip") >= 0 ||
                                StringFind(urlLower, ".mq5") >= 0 ||
                                StringFind(urlLower, ".ex5") >= 0 ||
                                StringFind(urlLower, ".mqh") >= 0);
    
    string downloadUrl = url;
    string fileName = "";
    
    if (!isDirectFile)
    {
        // Need to fetch the page and find download link.
        AddLine("Fetching page...");
        ForceRedraw();
        
        // Download the HTML page first.
        string htmlFile = tempPath + "\\page.html";
        if (!DownloadFile(url, htmlFile))
        {
            AddLine("ERROR: Failed to fetch page");
            AddLine("Make sure URL is in allowed list:");
            AddLine("Tools > Options > Expert Advisors > Allow WebRequest");
            return;
        }
        
        // Read the HTML content.
        int fileHandle = FileOpen("temp_install\\page.html", FILE_READ|FILE_TXT|FILE_ANSI);
        if (fileHandle == INVALID_HANDLE)
        {
            AddLine("ERROR: Failed to read page");
            return;
        }
        
        string html = "";
        while (!FileIsEnding(fileHandle))
        {
            html += FileReadString(fileHandle) + "\n";
        }
        FileClose(fileHandle);
        
        // Find download link.
        AddLine("Looking for MT5 download link...");
        ForceRedraw();
        downloadUrl = FindDownloadLink(html, url);
        
        if (downloadUrl == "")
        {
            AddLine("ERROR: No download link found");
            AddLine("Try using a direct file URL instead");
            return;
        }
        
        AddLine("Found: " + downloadUrl);
        ForceRedraw();
        
        // Re-check type from download URL (may be more accurate).
        string dlUrlLower = downloadUrl;
        StringToLower(dlUrlLower);
        if (StringFind(dlUrlLower, "mt5-indicators") >= 0 || StringFind(dlUrlLower, "/indicators/") >= 0)
            installType = "indicator";
        else if (StringFind(dlUrlLower, "mt5-scripts") >= 0 || StringFind(dlUrlLower, "/scripts/") >= 0)
            installType = "script";
        else if (StringFind(dlUrlLower, "mt5-experts") >= 0 || StringFind(dlUrlLower, "/experts/") >= 0)
            installType = "expert";
    }
    
    // Extract filename from URL.
    int lastSlash = -1;
    for (int i = StringLen(downloadUrl) - 1; i >= 0; i--)
    {
        if (StringGetCharacter(downloadUrl, i) == '/')
        {
            lastSlash = i;
            break;
        }
    }
    if (lastSlash >= 0)
        fileName = StringSubstr(downloadUrl, lastSlash + 1);
    else
        fileName = "download.zip";
    
    // Remove URL parameters from filename.
    int paramPos = StringFind(fileName, "?");
    if (paramPos > 0)
        fileName = StringSubstr(fileName, 0, paramPos);
    
    string localFile = tempPath + "\\" + fileName;
    
    // Download the file.
    AddLine("Downloading: " + fileName);
    ForceRedraw();
    if (!DownloadFile(downloadUrl, localFile))
    {
        AddLine("ERROR: Download failed");
        AddLine("Check if URL is in allowed list");
        return;
    }
    AddLine("Download complete!");
    ForceRedraw();
    
    // Determine destination folder based on type.
    string destFolder = dataPath + "\\MQL5\\";
    string typeLabel = "";
    if (installType == "indicator")
    {
        destFolder += "Indicators";
        typeLabel = "Indicator";
    }
    else if (installType == "script")
    {
        destFolder += "Scripts";
        typeLabel = "Script";
    }
    else
    {
        destFolder += "Experts";
        typeLabel = "Expert Advisor";
    }
    
    AddLine("Detected type: " + typeLabel);
    
    // Check file type and handle accordingly.
    string fileNameLower = fileName;
    StringToLower(fileNameLower);
    
    if (StringFind(fileNameLower, ".zip") >= 0)
    {
        // Read ZIP comment for version info.
        AddLine("Reading archive info...");
        ForceRedraw();
        
        string zipComment = ReadZipComment(localFile);
        if (StringLen(zipComment) > 0)
        {
            AddLine("Archive info: " + zipComment);
        }
        
        // Extract to temp folder first to analyze structure.
        string extractPath = tempPath + "\\extracted";
        
        // Clean up previous extraction.
        string cleanCmd = "/C rmdir /S /Q \"" + extractPath + "\" 2>nul";
        ShellExecuteW(0, "open", "cmd.exe", cleanCmd, "", SW_HIDE);
        Sleep(500);
        CreateDirectoryW(extractPath, 0);
        
        AddLine("Extracting archive...");
        ForceRedraw();
        
        if (!ExtractZip(localFile, extractPath))
        {
            AddLine("ERROR: Extraction failed");
            return;
        }
        
        // Wait for extraction to complete.
        Sleep(3000);
        
        // Check if archive contains MQL5 folder structure.
        string mql5Path = dataPath + "\\MQL5";
        bool hasStructure = false;
        string mql5Folders[] = {"Experts", "Indicators", "Scripts", "Include", "Files", "Libraries"};
        
        // First check if archive contains "MQL5" folder directly.
        string mql5InArchive = extractPath + "\\MQL5";
        int mql5Attr = GetFileAttributesW(mql5InArchive);
        if (mql5Attr != -1 && (mql5Attr & 0x10) != 0)
        {
            // Archive has MQL5 folder - copy its subfolders.
            for (int i = 0; i < ArraySize(mql5Folders); i++)
            {
                string srcPath = mql5InArchive + "\\" + mql5Folders[i];
                int attr = GetFileAttributesW(srcPath);
                if (attr != -1 && (attr & 0x10) != 0)
                {
                    hasStructure = true;
                    string dstPath = mql5Path + "\\" + mql5Folders[i];
                    string copyCmd = "/C xcopy \"" + srcPath + "\" \"" + dstPath + "\" /E /I /Y";
                    ShellExecuteW(0, "open", "cmd.exe", copyCmd, "", SW_HIDE);
                    AddLine("  Installed: " + mql5Folders[i] + " folder");
                }
            }
        }
        
        // Check for MQL5 subfolders directly in extracted content.
        if (!hasStructure)
        {
            for (int i = 0; i < ArraySize(mql5Folders); i++)
            {
                string checkPath = extractPath + "\\" + mql5Folders[i];
                int attr = GetFileAttributesW(checkPath);
                if (attr != -1 && (attr & FILE_ATTRIBUTE_DIRECTORY) != 0)
                {
                    hasStructure = true;
                    // Copy this folder's contents to MQL5
                    string srcFolder = checkPath;
                    string dstFolder = mql5Path + "\\" + mql5Folders[i];
                    string copyCmd = "/C xcopy \"" + srcFolder + "\" \"" + dstFolder + "\" /E /I /Y";
                    ShellExecuteW(0, "open", "cmd.exe", copyCmd, "", SW_HIDE);
                    AddLine("  Installed: " + mql5Folders[i] + " folder");
                }
            }
        }
        
        // Also check one level deeper (in case there's a subfolder like "ProgramName/Experts").
        if (!hasStructure)
        {
            // Find first subfolder in extracted path.
            WIN32_FIND_DATAW findData;
            long hFind = FindFirstFileW(extractPath + "\\*", findData);
            if (hFind != -1)
            {
                do
                {
                    string subName = ShortArrayToString(findData.cFileName);
                    if (subName != "." && subName != ".." && (findData.dwFileAttributes & 0x10) != 0)
                    {
                        // Check if this subfolder contains MQL5 folders.
                        for (int i = 0; i < ArraySize(mql5Folders); i++)
                        {
                            string subCheckPath = extractPath + "\\" + subName + "\\" + mql5Folders[i];
                            int attr = GetFileAttributesW(subCheckPath);
                            if (attr != -1 && (attr & 0x10) != 0)
                            {
                                hasStructure = true;
                                string srcFolder = subCheckPath;
                                string dstFolder = mql5Path + "\\" + mql5Folders[i];
                                string copyCmd = "/C xcopy \"" + srcFolder + "\" \"" + dstFolder + "\" /E /I /Y";
                                ShellExecuteW(0, "open", "cmd.exe", copyCmd, "", SW_HIDE);
                                AddLine("  Installed: " + mql5Folders[i] + " folder");
                            }
                        }
                    }
                }
                while (FindNextFileW(hFind, findData));
                FindClose(hFind);
            }
        }
        
        if (!hasStructure)
        {
            // No MQL5 structure found - copy everything to detected type folder.
            AddLine("Installing to: " + destFolder);
            string copyCmd = "/C xcopy \"" + extractPath + "\" \"" + destFolder + "\" /E /I /Y";
            ShellExecuteW(0, "open", "cmd.exe", copyCmd, "", SW_HIDE);
        }
        
        Sleep(1000);
        AddLine("");
        AddLine("Installation complete!");
        if (hasStructure)
            AddLine("Location: " + mql5Path);
        else
            AddLine("Location: " + destFolder);
        AddLine("");
        AddLine("Refresh Navigator to see it if necessary.");
    }
    else // Direct MQ5/EX5/MQH file (not .zip).
    {
        if (StringFind(fileNameLower, ".mqh") >= 0)
            destFolder = dataPath + "\\MQL5\\Include";
        
        string destFile = destFolder + "\\" + fileName;
        
        AddLine("Installing to: " + destFolder);
        ForceRedraw();
        
        if (CopyFileW(localFile, destFile, false))
        {
            AddLine("Installation complete!");
            AddLine("");
            AddLine("File installed: " + fileName);
            AddLine("Location: " + destFolder);
            AddLine("");
            AddLine("Refresh Navigator to see it if necessary.");
        }
        else
        {
            AddLine("ERROR: Failed to copy file");
            AddLine("File saved at: " + localFile);
        }
    }
    
    // Cleanup temp download file (keep extracted files for user).
    DeleteFileW(localFile);
}

//+------------------------------------------------------------------+
//| Update position to follow active chart.                          |
//+------------------------------------------------------------------+
void CWindowsConsole::UpdatePosition()
{
    if (m_hwnd == 0 || !m_visible) return;
    
    // Always check the actual MDI active child, even if console has focus.
    long hwndMDI = FindWindowExW(m_hwndMT5, 0, "MDIClient", NULL);
    if (hwndMDI == 0) return;
    
    long hwndActiveChild = SendMessageW(hwndMDI, WM_MDIGETACTIVE, 0, 0);
    if (hwndActiveChild == 0) return;
    
    // Find which chart ID has this MDI child as its parent.
    long activeChart = -1;
    long chartId = ChartFirst();
    while (chartId >= 0)
    {
        long chartHwnd = ChartGetInteger(chartId, CHART_WINDOW_HANDLE);
        long chartParent = GetParent(chartHwnd);
        
        if (chartParent == hwndActiveChild)
        {
            activeChart = chartId;
            break;
        }
        
        chartId = ChartNext(chartId);
    }
    
    // Only reposition if active chart changed.
    if (activeChart >= 0 && activeChart != m_currentChartId)
    {
        m_currentChartId = activeChart;
        
        long chartHwnd = ChartGetInteger(activeChart, CHART_WINDOW_HANDLE);
        if (chartHwnd != 0)
        {
            int chartRect[4];
            if (GetWindowRect(chartHwnd, chartRect))
            {
                int x = chartRect[0] + 5;
                int y = chartRect[1] + 5;
                MoveWindow(m_hwnd, x, y, 816, 432, false);
                
                // Bring console back to foreground after moving.
                SetForegroundWindow(m_hwnd);
            }
        }
    }
}

//+------------------------------------------------------------------+
//| Create console.                                                  |
//+------------------------------------------------------------------+
bool CWindowsConsole::Create()
{
    Print("=== Creating Console Window ===");
    
    m_hwndMT5 = FindMT5Window();
    
    int x = 100, y = 100;
    int width = 816, height = 432;
    
    if (m_hwndMT5 != 0)
    {
        Print("MT5 window found: ", m_hwndMT5);
        
        // Try to position to first chart if available.
        long firstChart = ChartFirst();
        if (firstChart >= 0)
        {
            m_currentChartId = firstChart;
            long chartHwnd = ChartGetInteger(firstChart, CHART_WINDOW_HANDLE);
            if (chartHwnd != 0)
            {
                int chartRect[4];
                if (GetWindowRect(chartHwnd, chartRect))
                {
                    x = chartRect[0] + 5;
                    y = chartRect[1] + 5;
                }
            }
        }
        else
        {
            // Fallback to MDIClient if no charts.
            long hwndChartArea = FindWindowExW(m_hwndMT5, 0, "MDIClient", NULL);
            if (hwndChartArea != 0)
            {
                int chartRect[4];
                if (GetWindowRect(hwndChartArea, chartRect))
                {
                    x = chartRect[0] + 5;
                    y = chartRect[1] + 5;
                }
            }
            else
            {
                // Final fallback to center of MT5
                int rect[4];
                if (GetWindowRect(m_hwndMT5, rect))
                {
                    x = rect[0] + (rect[2] - rect[0] - width) / 2;
                    y = rect[1] + (rect[3] - rect[1] - height) / 2;
                }
            }
        }
    }
    
    Print("Creating window...");
    
    // Use ushort arrays for class name (more reliable marshaling in Build 5571+).
    ushort className[];
    ushort windowName[];
    StringToShortArray("Static", className);
    StringToShortArray("MT5 Console", windowName);
    
    m_hwnd = CreateWindowExW(
        WS_EX_APPWINDOW,                    // Show in taskbar
        className,                          // Static class
        windowName,                         // Window title
        WS_POPUP | WS_VISIBLE | WS_BORDER | SS_BLACKRECT | WS_CLIPCHILDREN,  // Popup with thin border, no caption
        x, y, width, height,
        0,                                  // No parent
        0,                                  // No menu
        0,                                  // No instance
        0                                   // No param
    );
    
    if (m_hwnd == 0)
    {
        Print("ERROR: Failed to create window. Error: ", GetLastError());
        return false;
    }
    
    Print("Window created successfully: ", m_hwnd);
    
    // Set window title for taskbar.
    SetWindowTextW(m_hwnd, "MT5 Console");
    
    // Create font.
    ushort fontName[];
    StringToShortArray("Consolas", fontName);
    
    m_hFont = CreateFontW(16, 0, 0, 0, 400, 0, 0, 0, 1, 0, 0, 0, 49, fontName);
    
    if (m_hFont == 0)
    {
        Print("WARNING: Failed to create font");
    }
    
    // Create brush.
    m_hBrush = CreateSolidBrush(COLOR_BLACK);
    if (m_hBrush == 0)
    {
        m_hBrush = GetStockObject(BLACK_BRUSH);
    }
    
    // Calculate max visible lines.
    m_maxVisibleLines = (height - 60) / 18;
    
    // Initialize with welcome message.
    AddLine("================================");
    AddLine("  MT5 Console ver. " + Version);
    AddLine("  Press ` to toggle.");
    AddLine("  Type 'help' for commands.");
    AddLine("  Use PgUp/PgDn to scroll.");
    AddLine("-====- www.earnforex.com -=====-");
    AddLine("");
    
    // Initially hide.
    ShowWindow(m_hwnd, SW_HIDE);
    m_visible = false;
    
    // Load command history from file.
    LoadHistory();
    
    Print("Console initialization complete");
    return true;
}

//+------------------------------------------------------------------+
//| Draw console content - Double-buffered to avoid flickering.      |
//+------------------------------------------------------------------+
void CWindowsConsole::DrawConsole()
{
    if (m_hwnd == 0) return;
    
    long hdc = GetDC(m_hwnd);
    if (hdc == 0) return;
    
    int rect[4];
    GetClientRect(m_hwnd, rect);
    int width = rect[2] - rect[0];
    int height = rect[3] - rect[1];
    
    // Create memory DC and bitmap for double-buffering.
    long hdcMem = CreateCompatibleDC(hdc);
    long hBitmap = CreateCompatibleBitmap(hdc, width, height);
    long hOldBitmap = SelectObject(hdcMem, hBitmap);
    
    // Draw everything to memory DC first.
    FillRect(hdcMem, rect, m_hBrush);
    
    if (m_hFont != 0)
        SelectObject(hdcMem, m_hFont);
        
    SetTextColor(hdcMem, COLOR_GREEN);
    SetBkMode(hdcMem, 1); // TRANSPARENT
    SetBkColor(hdcMem, COLOR_BLACK);
    
    int y = 10;
    int lineHeight = 18;
    
    // Draw visible lines with scrolling.
    int totalLines = ArraySize(m_lines);
    int startLine = m_scrollOffset;
    int endLine = MathMin(startLine + m_maxVisibleLines, totalLines);
    
    for (int i = startLine; i < endLine; i++)
    {
        ushort text[];
        StringToShortArray(m_lines[i], text);
        if (ArraySize(text) > 0)
        {
            TextOutW(hdcMem, 10, y, text, ArraySize(text)-1);
            y += lineHeight;
        }
    }
    
    // Draw input line.
    string inputLine = "MT5> " + m_inputText;
    ushort inputText[];
    StringToShortArray(inputLine, inputText);
    if (ArraySize(inputText) > 0)
    {
        TextOutW(hdcMem, 10, y, inputText, ArraySize(inputText)-1);
    }
    
    // Draw blinking underscore cursor at correct position.
    // Consolas at height 16 has approximately 8 pixel character width.
    if ((GetTickCount() / 500) % 2 == 0)
    {
        int charWidth = 8;  // Approximate width for Consolas 16
        int cursorX = 10 + (5 + m_cursorPos) * charWidth;  // 5 = length of "MT5> "
        
        ushort cursorChar[];
        StringToShortArray("_", cursorChar);
        TextOutW(hdcMem, cursorX, y, cursorChar, 1);
    }
    
    // Draw scroll indicator.
    if (totalLines > m_maxVisibleLines)
    {
        string scrollInfo = StringFormat("[%d-%d/%d]", 
                                                  startLine+1, endLine, totalLines);
        ushort scrollText[];
        StringToShortArray(scrollInfo, scrollText);
        TextOutW(hdcMem, 700, 10, scrollText, ArraySize(scrollText) - 1);
    }
    
    // Copy from memory DC to screen DC in one operation.
    BitBlt(hdc, 0, 0, width, height, hdcMem, 0, 0, SRCCOPY);
    
    // Cleanup.
    SelectObject(hdcMem, hOldBitmap);
    DeleteObject(hBitmap);
    DeleteDC(hdcMem);
    
    ReleaseDC(m_hwnd, hdc);
}

//+------------------------------------------------------------------+
//| Process Windows messages.                                        |
//+------------------------------------------------------------------+
bool CWindowsConsole::ProcessMessages()
{
    if (m_hwnd == 0) return true;
    
    uchar msg[48];
    
    // Process messages but don't invalidate.
    int processedCount = 0;
    while (PeekMessageW(msg, m_hwnd, 0, 0, PM_REMOVE) && processedCount < 10)
    {
        TranslateMessage(msg);
        DispatchMessageW(msg);
        processedCount++;
    }
    
    return true;
}

//+------------------------------------------------------------------+
//| Redraw console window.                                           |
//+------------------------------------------------------------------+
void CWindowsConsole::Redraw()
{
    if (!m_visible || !m_needsRedraw || m_hwnd == 0) return;
    
    // Draw directly without invalidating.
    DrawConsole();
    m_needsRedraw = false;
}

//+------------------------------------------------------------------+
//| Force redraw.                                                    |
//+------------------------------------------------------------------+
void CWindowsConsole::ForceRedraw()
{
    if (m_hwnd != 0 && m_visible)
    {
        m_needsRedraw = true;
        DrawConsole();  // Draw directly.
    }
}

//+------------------------------------------------------------------+
//| Show console.                                                    |
//+------------------------------------------------------------------+
void CWindowsConsole::Show()
{
    if (m_hwnd != 0)
    {
        // Position to active chart.
        long activeChart = GetActiveChartId();
        if (activeChart >= 0)
        {
            m_currentChartId = activeChart;
            long chartHwnd = ChartGetInteger(activeChart, CHART_WINDOW_HANDLE);
            if (chartHwnd != 0)
            {
                int chartRect[4];
                if (GetWindowRect(chartHwnd, chartRect))
                {
                    int x = chartRect[0] + 5;
                    int y = chartRect[1] + 5;
                    MoveWindow(m_hwnd, x, y, 816, 432, false);
                }
            }
        }
        else if (m_hwndMT5 != 0)
        {
            // Fallback to MDIClient if no charts.
            long hwndChartArea = FindWindowExW(m_hwndMT5, 0, "MDIClient", NULL);
            if (hwndChartArea != 0)
            {
                int chartRect[4];
                if (GetWindowRect(hwndChartArea, chartRect))
                {
                    int x = chartRect[0] + 5;
                    int y = chartRect[1] + 5;
                    MoveWindow(m_hwnd, x, y, 816, 432, false);
                }
            }
        }
        
        ShowWindow(m_hwnd, SW_SHOW);
        SetForegroundWindow(m_hwnd);
        m_visible = true;
        m_needsRedraw = true;
        ScrollToBottom();
        
        // Draw immediately when shown.
        DrawConsole();
    }
}

//+------------------------------------------------------------------+
//| Destroy console window.                                          |
//+------------------------------------------------------------------+
void CWindowsConsole::Destroy()
{
    if (m_hwnd != 0)
    {
        DestroyWindow(m_hwnd);
        m_hwnd = 0;
    }
    
    if (m_hFont != 0)
    {
        DeleteObject(m_hFont);
        m_hFont = 0;
    }
    
    if (m_hBrush != 0 && m_hBrush != GetStockObject(BLACK_BRUSH))
    {
        DeleteObject(m_hBrush);
        m_hBrush = 0;
    }
}

//+------------------------------------------------------------------+
//| Toggle console visibility.                                       |
//+------------------------------------------------------------------+
void CWindowsConsole::Toggle()
{
    if (m_visible) Hide();
    else Show();
}

//+------------------------------------------------------------------+
//| Hide console.                                                    |
//+------------------------------------------------------------------+
void CWindowsConsole::Hide()
{
    if (m_hwnd != 0)
    {
        ShowWindow(m_hwnd, SW_HIDE);
        m_visible = false;
        Print("Console hidden");
    }
}

//+------------------------------------------------------------------+
//| Add output line.                                                 |
//+------------------------------------------------------------------+
void CWindowsConsole::AddLine(string text)
{
    // Wrap long lines (approx 85 chars fits in window).
    int maxChars = 85;
    
    while (StringLen(text) > maxChars)
    {
        // Find last space before maxChars for word wrap.
        int wrapPos = maxChars;
        for (int i = maxChars; i > maxChars/2; i--)
        {
            if (StringGetCharacter(text, i) == ' ')
            {
                wrapPos = i;
                break;
            }
        }
        
        string line = StringSubstr(text, 0, wrapPos);
        text = StringSubstr(text, wrapPos);
        StringTrimLeft(text);
        
        // Add the wrapped line.
        int size = ArraySize(m_lines);
        ArrayResize(m_lines, size + 1);
        m_lines[size] = line;
        
        if (size >= m_maxBufferLines)
            ArrayRemove(m_lines, 0, 1);
        
        // Log to Experts tab (skip empty lines and breathing mode).
        if (StringLen(line) > 0 && !m_breathingMode)
            Print(line);
    }
    
    // Add remaining text.
    int size = ArraySize(m_lines);
    ArrayResize(m_lines, size + 1);
    m_lines[size] = text;
    
    // Limit buffer size.
    if (size >= m_maxBufferLines)
    {
        ArrayRemove(m_lines, 0, 1);
    }
    
    // Log to Experts tab (skip empty lines and breathing mode).
    if (StringLen(text) > 0 && !m_breathingMode)
    {
        Print(text);
    }
    
    ScrollToBottom();
    m_needsRedraw = true;
}

//+------------------------------------------------------------------+
//| Scroll functions.                                                |
//+------------------------------------------------------------------+
void CWindowsConsole::ScrollUp()
{
    if (m_scrollOffset > 0)
    {
        m_scrollOffset--;
        m_needsRedraw = true;
    }
}

void CWindowsConsole::ScrollDown()
{
    int totalLines = ArraySize(m_lines);
    int maxOffset = totalLines - m_maxVisibleLines;
    if (maxOffset < 0) maxOffset = 0;
    
    if (m_scrollOffset < maxOffset)
    {
        m_scrollOffset++;
        m_needsRedraw = true;
    }
}

void CWindowsConsole::ScrollToBottom()
{
    int totalLines = ArraySize(m_lines);
    m_scrollOffset = totalLines - m_maxVisibleLines;
    if (m_scrollOffset < 0) m_scrollOffset = 0;
    m_needsRedraw = true;
}

//+------------------------------------------------------------------+
//| Process character input.                                         |
//+------------------------------------------------------------------+
void CWindowsConsole::ProcessChar(string c)
{
    // Insert character at cursor position.
    if (m_cursorPos >= StringLen(m_inputText))
    {
        m_inputText += c;
    }
    else
    {
        m_inputText = StringSubstr(m_inputText, 0, m_cursorPos) + c + 
                          StringSubstr(m_inputText, m_cursorPos);
    }
    m_cursorPos++;
    m_needsRedraw = true;
}

//+------------------------------------------------------------------+
//| Process special keys.                                            |
//+------------------------------------------------------------------+
void CWindowsConsole::ProcessKey(int keyCode)
{
    // Handle breathing mode - only ESC works.
    if (m_breathingMode)
    {
        if (keyCode == VK_ESCAPE)
        {
            // End breathing mode early.
            m_breathingMode = false;
            EnableWindow(m_hwndMT5, true);
            ShowWindow(m_hwndMT5, 9);  // SW_RESTORE
            SetForegroundWindow(m_hwndMT5);
            
            ArrayResize(m_lines, 0);
            m_scrollOffset = 0;
            AddLine("");
            AddLine("  Breathing exercise stopped.");
            AddLine("  Platform unlocked.");
            AddLine("");
            ForceRedraw();
        }
        return;  // Ignore all other keys during breathing.
    }
    
    switch (keyCode)
    {
        case VK_RETURN:
            if (StringLen(m_inputText) > 0)
            {
                AddLine("MT5> " + m_inputText);
                
                int size = ArraySize(m_commandHistory);
                ArrayResize(m_commandHistory, size + 1);
                m_commandHistory[size] = m_inputText;
                m_historyIndex = -1;
                SaveHistory();
                
                ExecuteCommand(m_inputText);
                m_inputText = "";
                m_cursorPos = 0;
                m_needsRedraw = true;
            }
            break;
            
        case VK_BACK:
            if (m_cursorPos > 0)
            {
                m_inputText = StringSubstr(m_inputText, 0, m_cursorPos - 1) + 
                                  StringSubstr(m_inputText, m_cursorPos);
                m_cursorPos--;
                m_needsRedraw = true;
            }
            break;
            
        case VK_DELETE:
            if (m_cursorPos < StringLen(m_inputText))
            {
                m_inputText = StringSubstr(m_inputText, 0, m_cursorPos) + 
                                  StringSubstr(m_inputText, m_cursorPos + 1);
                m_needsRedraw = true;
            }
            break;
            
        case VK_ESCAPE:
            m_inputText = "";
            m_cursorPos = 0;
            m_needsRedraw = true;
            break;
            
        case VK_LEFT:
            if (m_cursorPos > 0)
            {
                // Check if Ctrl is pressed for word movement.
                if ((GetAsyncKeyState(VK_CONTROL) & 0x8000) != 0)
                {
                    // Move to start of previous word.
                    int pos = m_cursorPos - 1;
                    // Skip spaces.
                    while (pos > 0 && StringGetCharacter(m_inputText, pos) == ' ')
                        pos--;
                    // Skip word characters.
                    while (pos > 0 && StringGetCharacter(m_inputText, pos - 1) != ' ')
                        pos--;
                    m_cursorPos = pos;
                }
                else
                {
                    m_cursorPos--;
                }
                m_needsRedraw = true;
            }
            break;
            
        case VK_RIGHT:
            if (m_cursorPos < StringLen(m_inputText))
            {
                // Check if Ctrl is pressed for word movement.
                if ((GetAsyncKeyState(VK_CONTROL) & 0x8000) != 0)
                {
                    // Move to end of next word.
                    int len = StringLen(m_inputText);
                    int pos = m_cursorPos;
                    // Skip current word characters.
                    while (pos < len && StringGetCharacter(m_inputText, pos) != ' ')
                        pos++;
                    // Skip spaces.
                    while (pos < len && StringGetCharacter(m_inputText, pos) == ' ')
                        pos++;
                    m_cursorPos = pos;
                }
                else
                {
                    m_cursorPos++;
                }
                m_needsRedraw = true;
            }
            break;
            
        case VK_HOME:
            if (m_cursorPos != 0)
            {
                m_cursorPos = 0;
                m_needsRedraw = true;
            }
            break;
            
        case VK_END:
            if (m_cursorPos != StringLen(m_inputText))
            {
                m_cursorPos = StringLen(m_inputText);
                m_needsRedraw = true;
            }
            break;
            
        case VK_UP:
            if (ArraySize(m_commandHistory) > 0)
            {
                if (m_historyIndex == -1)
                    m_historyIndex = ArraySize(m_commandHistory) - 1;
                else if (m_historyIndex > 0)
                    m_historyIndex--;
                m_inputText = m_commandHistory[m_historyIndex];
                m_cursorPos = StringLen(m_inputText);
                m_needsRedraw = true;
            }
            break;
            
        case VK_DOWN:
            if (m_historyIndex >= 0)
            {
                if (m_historyIndex < ArraySize(m_commandHistory) - 1)
                {
                    m_historyIndex++;
                    m_inputText = m_commandHistory[m_historyIndex];
                }
                else
                {
                    m_historyIndex = -1;
                    m_inputText = "";
                }
                m_cursorPos = StringLen(m_inputText);
                m_needsRedraw = true;
            }
            break;
            
        case VK_PRIOR:  // Page Up.
            ScrollUp();
            break;
            
        case VK_NEXT:   // Page Down.
            ScrollDown();
            break;
    }
}

//+------------------------------------------------------------------+
//| Parse timeframe string to ENUM_TIMEFRAMES.                       |
//+------------------------------------------------------------------+
ENUM_TIMEFRAMES ParseTimeframe(string tf)
{
    StringToUpper(tf);
    StringTrimLeft(tf);
    StringTrimRight(tf);
    
    if (tf == "M1" || tf == "1")    return PERIOD_M1;
    if (tf == "M2" || tf == "2")    return PERIOD_M2;
    if (tf == "M3" || tf == "3")    return PERIOD_M3;
    if (tf == "M4" || tf == "4")    return PERIOD_M4;
    if (tf == "M5" || tf == "5")    return PERIOD_M5;
    if (tf == "M6" || tf == "6")    return PERIOD_M6;
    if (tf == "M10" || tf == "10")  return PERIOD_M10;
    if (tf == "M12" || tf == "12")  return PERIOD_M12;
    if (tf == "M15" || tf == "15")  return PERIOD_M15;
    if (tf == "M20" || tf == "20")  return PERIOD_M20;
    if (tf == "M30" || tf == "30")  return PERIOD_M30;
    if (tf == "H1" || tf == "60")   return PERIOD_H1;
    if (tf == "H2")                 return PERIOD_H2;
    if (tf == "H3")                 return PERIOD_H3;
    if (tf == "H4" || tf == "240")  return PERIOD_H4;
    if (tf == "H6")                 return PERIOD_H6;
    if (tf == "H8")                 return PERIOD_H8;
    if (tf == "H12")                return PERIOD_H12;
    if (tf == "D1" || tf == "D" || tf == "1440") return PERIOD_D1;
    if (tf == "W1" || tf == "W")    return PERIOD_W1;
    if (tf == "MN1" || tf == "MN" || tf == "MONTHLY") return PERIOD_MN1;
    
    return PERIOD_CURRENT;  // Invalid.
}

//+------------------------------------------------------------------+
//| Resolve abbreviated command to full command.                     |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Check for common typos and return corrected command.             |
//| Returns empty string if no typo match found.                     |
//+------------------------------------------------------------------+
string CheckTypo(string cmdWord)
{
    string cmdLower = cmdWord;
    StringToLower(cmdLower);
    
    // Typo -> Correct command mapping.
    // Format: typo, correct, typo, correct, ...
    string typos[] = {
        // help
        "elp", "help",
        "ehlp", "help",
        "hlep", "help",
        "hepl", "help",
        "hep", "help",
        "hlp", "help",
        // info
        "ifno", "info",
        "nfo", "info",
        "inof", "info",
        "nifo", "info",
        // clear
        "cler", "clear",
        "claer", "clear",
        "cealr", "clear",
        "clera", "clear",
        "clrea", "clear",
        // exit/quit
        "exti", "exit",
        "eixt", "exit",
        "exot", "exit",
        "quti", "quit",
        "qiut", "quit",
        // account
        "acount", "account",
        "accoutn", "account",
        "acconut", "account",
        "accont", "account",
        // balance
        "balacne", "balance",
        "blaance", "balance",
        "balanec", "balance",
        "balnace", "balance",
        "balane", "balance",
        // history
        "hitsory", "history",
        "histroy", "history",
        "hsitory", "history",
        "hisotry", "history",
        "histor", "history",
        // positions
        "positoins", "positions",
        "positinos", "positions",
        "posiitons", "positions",
        "positons", "positions",
        "poisitions", "positions",
        "psotions", "positions",
        "postiions", "positions",
        // close
        "clsoe", "close",
        "colse", "close",
        "closee", "close",
        "cloe", "close",
        "clseo", "close",
        // buy
        "byu", "buy",
        "uby", "buy",
        "byy", "buy",
        // sell
        "seel", "sell",
        "slel", "sell",
        "sel", "sell",
        "seell", "sell",
        // chart
        "caht", "chart",
        "chrat", "chart",
        "cahrt", "chart",
        "chrta", "chart",
        "char", "chart",
        // orders
        "ordres", "orders",
        "oredrs", "orders",
        "odres", "orders",
        "ordes", "orders",
        // pending
        "pneding", "pending",
        "pendign", "pending",
        "penidng", "pending",
        "pening", "pending",
        // alerts
        "aelrts", "alerts",
        "alrets", "alerts",
        "laerts", "alerts",
        "alrts", "alerts",
        "aleerts", "alerts",
        // version
        "vesion", "version",
        "vresion", "version",
        "verison", "version",
        "verion", "version",
        // symbols
        "sybmols", "symbols",
        "symobls", "symbols",
        "symobles", "symbols",
        "symbls", "symbols",
        // symbol
        "sybmol", "symbol",
        "symobl", "symbol",
        "symbl", "symbol",
        // market
        "marekts", "market",
        "marekt", "market",
        "makret", "market",
        "mrket", "market",
        // equity
        "equtiy", "equity",
        "eqiuty", "equity",
        "equiy", "equity",
        "eqeuity", "equity",
        // margin
        "margni", "margin",
        "marign", "margin",
        "magrni", "margin",
        // stats
        "sttas", "stats",
        "staats", "stats",
        "stas", "stats",
        "stast", "stats",
        // template
        "tempalte", "template",
        "tmeplate", "template",
        "templat", "template",
        "templaet", "template",
        // compile
        "compiel", "compile",
        "comiple", "compile",
        "complie", "compile",
        "comile", "compile",
        // screenshot
        "screesnhot", "screenshot",
        "screenhsot", "screenshot",
        "screnshot", "screenshot",
        "screensho", "screenshot",
        // timeframe
        "timefrmae", "timeframe",
        "timefarme", "timeframe",
        "timframe", "timeframe",
        "tmieframe", "timeframe",
        // indicators
        "indicatros", "indicators",
        "indciators", "indicators",
        "indicaotrs", "indicators",
        "idnicators", "indicators",
        // attach
        "attahc", "attach",
        "atach", "attach",
        "attch", "attach",
        "atttach", "attach",
        // remove
        "remvoe", "remove",
        "reomve", "remove",
        "remov", "remove",
        "rmove", "remove",
        // hedge
        "hdege", "hedge",
        "hege", "hedge",
        "hedeg", "hedge",
        // double
        "doubel", "double",
        "doble", "double",
        "doulbe", "double",
        "doubble", "double",
        // flip
        "flpi", "flip",
        "fli", "flip",
        "filp", "flip",
        // panic
        "pnaic", "panic",
        "panc", "panic",
        "panci", "panic",
        // server
        "sever", "server",
        "servr", "server",
        "servre", "server",
        // swap/swaps
        "swa", "swap",
        "sawp", "swap",
        "swpa", "swap",
        "sawps", "swaps",
        "swpas", "swaps",
        // credit
        "creidt", "credit",
        "credti", "credit",
        "crdit", "credit",
        // range
        "rnage", "range",
        "raneg", "range",
        "ragne", "range",
        // specification/spec
        "sepc", "spec",
        "spce", "spec",
        "sepcs", "spec",
        "specfication", "specification",
        "specificaiton", "specification",
        // darkmode/lightmode
        "drakmode", "darkmode",
        "darkmoe", "darkmode",
        "darkmdoe", "darkmode",
        "ligthmode", "lightmode",
        "lightmdoe", "lightmode",
        "ligtmode", "lightmode",
        // datafolder
        "datafloder", "datafolder",
        "datfolder", "datafolder",
        "datafodler", "datafolder",
        // watch
        "wtach", "watch",
        "wathc", "watch",
        "wacth", "watch",
        // load/unload
        "laod", "load",
        "lod", "load",
        "laoad", "load",
        "unlod", "unload",
        "unlaod", "unload",
        "uload", "unload",
        // run
        "rnu", "run",
        "urun", "run",
        // line
        "lien", "line",
        "lne", "line",
        // left/right
        "lfet", "left",
        "letf", "left",
        "rihgt", "right",
        "rigth", "right",
        "rigt", "right"
    };
    
    int count = ArraySize(typos);
    for (int i = 0; i < count; i += 2)
    {
        if (cmdLower == typos[i])
            return typos[i + 1];
    }
    
    return "";  // No typo match.
}

string ResolveCommand(string cmdWord)
{
    // List of all commands in alphabetical order.
    // When multiple commands match a prefix, the first alphabetically wins.
    string commands[] = {
        "abuy",
        "account",
        "aclose",
        "add",
        "alerts",
        "alerts-add",
        "alerts-del",
        "alerts-disable",
        "alerts-enable",
        "algo",
        "asell",
        "att",
        "attach",
        "auto",
        "balance",
        "breathe",
        "buy",
        "calcmode",
        "chart",
        "chartcolors",
        "charts-close-all",
        "clear",
        "cls",
        "clearcache",
        "clip",
        "close",
        "cmdhist",
        "comment",
        "compile",
        "contract",
        "credit",
        "darkmode",
        "datafolder",
        "debug",
        "declutter",
        "df",
        "dm",
        "double",
        "equity",
        "exit",
        "flip",
        "gvar",
        "gvar-del",
        "gvar-set",
        "hedge",
        "help",
        "hide",
        "history",
        "ide",
        "ind",
        "indicators",
        "info",
        "install",
        "left",
        "lightmode",
        "line",
        "list",
        "lm",
        "load",
        "ls",
        "margin",
        "market",
        "maxvol",
        "metaeditor",
        "minvol",
        "orders",
        "panic",
        "pending",
        "pos",
        "positions",
        "quit",
        "range",
        "reclutter",
        "remove",
        "right",
        "run",
        "screenshot",
        "scroll",
        "sell",
        "server",
        "shift",
        "show",
        "shutdown",
        "sm",
        "snap",
        "spec",
        "specification",
        "stats",
        "streak",
        "swap",
        "swaps",
        "symbol",
        "symbols",
        "sysmode",
        "systemmode",
        "template",
        "template-save",
        "tf",
        "ticksize",
        "tickvalue",
        "time",
        "timeframe",
        "undo",
        "unload",
        "version",
        "volmax",
        "volmin",
        "volstep",
        "watch",
        "watch-clear",
        "where"
    };
    
    string cmdLower = cmdWord;
    StringToLower(cmdLower);
    
    int cmdLen = StringLen(cmdLower);
    if (cmdLen == 0) return "";
    
    // Find first command that starts with the given prefix.
    for (int i = 0; i < ArraySize(commands); i++)
    {
        if (StringLen(commands[i]) >= cmdLen)
        {
            if (StringSubstr(commands[i], 0, cmdLen) == cmdLower)
                return commands[i];
        }
    }
    
    // No match found, return original.
    return cmdWord;
}

//+------------------------------------------------------------------+
//| Execute command.                                                 |
//+------------------------------------------------------------------+
void CWindowsConsole::ExecuteCommand(string cmd)
{
    StringTrimLeft(cmd);
    StringTrimRight(cmd);
    
    // Extract first word for command resolution.
    string firstWord = cmd;
    string restOfCmd = "";
    int spacePos = StringFind(cmd, " ");
    if (spacePos > 0)
    {
        firstWord = StringSubstr(cmd, 0, spacePos);
        restOfCmd = StringSubstr(cmd, spacePos);
    }
    
    // Check for typos first.
    string typoCorrection = CheckTypo(firstWord);
    if (typoCorrection != "")
    {
        AddLine("Huh? " + firstWord + "? You probably meant " + typoCorrection + "...");
        firstWord = typoCorrection;
    }
    
    // Resolve abbreviated command.
    string resolvedCmd = ResolveCommand(firstWord);
    
    // Rebuild full command with resolved first word.
    string command = resolvedCmd + restOfCmd;
    StringToLower(command);
    StringTrimLeft(command);
    StringTrimRight(command);
    
    // Keep original case version for display purposes.
    cmd = resolvedCmd + restOfCmd;
    
    // Clear undo tracking for each new command (except undo itself).
    // Only undoable commands will set these values.
    if (command != "undo")
    {
        m_lastUndoCommand = "";
        m_lastUndoData = "";
        m_lastUndoChartId = 0;
    }
    
    if (command == "help" || command == "?")
    {
        AddLine("Available commands:");
        AddLine("  abuy      - Async buy (non-blocking)");
        AddLine("  account   - Account information");
        AddLine("  aclose    - Async close (non-blocking)");
        AddLine("  add <ind> - Add indicator (no dialog)");
        AddLine("  alerts    - List alerts from file");
        AddLine("  alerts-add SYM COND VAL - Create alert");
        AddLine("  alerts-enable/disable/del <n> - Modify alert");
        AddLine("  asell     - Async sell (non-blocking)");
        AddLine("  attach <ind> - Attach indicator with dialog");
        AddLine("  auto/algo - Toggle autotrading (auto on/off)");
        AddLine("  balance   - Show account balance");
        AddLine("  breathe [sec] - Breathing exercise (locks platform)");
        AddLine("  buy       - Buy lots: buy [symbol] <lots> [sl=X tp=X]");
        AddLine("  calcmode/volmin/volmax/volstep [sym]");
        AddLine("  chart <s> - Open chart for symbol <s> [timeframe]");
        AddLine("  chartcolors <scheme> - green/bw/yellow/color");
        AddLine("  charts-close-all - Close all charts");
        AddLine("  clear     - Clear screen");
        AddLine("  clearcache - Clear history/ticks cache");
        AddLine("  clip      - Show clipboard contents");
        AddLine("  close     - Close positions (see 'close' for help)");
        AddLine("  cmdhist   - Command history");
        AddLine("  comment [text] - Get/set chart comment");
        AddLine("  compile <file> [opts] - Compile MQL5 file");
        AddLine("  credit    - Show account credit");
        AddLine("  darkmode/lightmode/systemmode - Change MT5 theme");
        AddLine("  datafolder - Open MT5 data folder (df)");
        AddLine("  declutter - Hide all chart objects");
        AddLine("  double    - Double positions: double [all|symbol]");
        AddLine("  equity    - Show account equity");
        AddLine("  exit      - Hide console");
        AddLine("  flip      - Flip positions: flip [all|symbol]");
        AddLine("  gvar      - List global variables");
        AddLine("  gvar-del <n> - Delete global variable");
        AddLine("  gvar-set <n> <v> - Set global variable");
        AddLine("  hedge     - Hedge positions: hedge <all|symbol>");
        AddLine("  help      - Show this help");
        AddLine("  hide/show history|trade|volume|grid|quick");
        AddLine("  history [period]        - Closed positions history");
        AddLine("  history deals [period]  - Deal history");
        AddLine("  history orders [period] - Order history");
        AddLine("  ide/metaeditor [file] - Launch MetaEditor");
        AddLine("  indicators - List chart indicators");
        AddLine("  info      - Current chart information");
        AddLine("  install <url> - Install MQL5 from URL");
        AddLine("  left/right - Switch to left/right chart");
        AddLine("  line <price> - Add horizontal line");
        AddLine("  load <ea> - Attach EA to current chart");
        AddLine("  ls/list [type] - List files (ind/ea/scripts)");
        AddLine("  margin    - Show free margin");
        AddLine("  panic     - Remove EAs, close all, delete pending");
        AddLine("  pending   - List pending orders");
        AddLine("  pos       - List open positions");
        AddLine("  quit      - Stop service");
        AddLine("  range <period> - Show price range (high/low)");
        AddLine("  reclutter - Show all chart objects");
        AddLine("  remove <name|all> - Remove indicator(s)");
        AddLine("  run <s>   - Run script by name");
        AddLine("  screenshot [WxH] - Screenshot chart (snap)");
        AddLine("  scroll    - Toggle chart auto-scroll");
        AddLine("  shift     - Toggle chart shift");
        AddLine("  sell      - Sell lots: sell [symbol] <lots> [sl=X tp=X]");
        AddLine("  server    - Show server name");
        AddLine("  shutdown [time] - Close MT5: shutdown 5m, shutdown 1h");
        AddLine("  spec [sym] - Full symbol specification");
        AddLine("  stats [period] [symbol] - Trading statistics");
        AddLine("  stats byweekday [symbol]- Stats by day of week");
        AddLine("  streak    - Show longest win/loss streaks");
        AddLine("    periods: today,yesterday,week,month,prevweek,prevmonth,all");
        AddLine("  swaps     - Show swap rates for symbol");
        AddLine("  symbol <s> - Change current chart's symbol");
        AddLine("  symbols   - List Market Watch symbols");
        AddLine("  template <name> - Load template on current chart");
        AddLine("  template-save <n> - Save current chart as template");
        AddLine("  tf <tf>   - Change current chart timeframe");
        AddLine("  ticksize/tickvalue/contract [sym]");
        AddLine("  time      - Show current time");
        AddLine("  undo      - Undo last action (line, add, chart, tf, auto, symbol)");
        AddLine("  unload    - Remove EA from current chart");
        AddLine("  version   - Show version info");
        AddLine("  watch <symbol> - Add symbol to Market Watch");
        AddLine("  watch-clear - Remove all from Market Watch");
        AddLine("  where     - Show data and program paths");
        AddLine("");
        AddLine("Navigation:");
        AddLine("  PgUp/PgDn - Scroll up/down");
        AddLine("  Up/Down   - Command history");
        AddLine("  Home/End  - Cursor to start/end");
        AddLine("  Left/Right - Move cursor");
        AddLine("  Ctrl+V    - Paste from clipboard");
        AddLine("");
        AddLine("Tip: Commands can be abbreviated (b=buy, s=sell, etc.)");
    }
    else if (command == "clear" || command == "cls")
    {
        ArrayResize(m_lines, 0);
        m_scrollOffset = 0;
    }
    else if (command == "time")
    {
        string days[] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
        
        MqlDateTime serverTime, localTime;
        TimeToStruct(TimeCurrent(), serverTime);
        TimeToStruct(TimeLocal(), localTime);
        
        AddLine("Server: " + TimeToString(TimeCurrent(), TIME_DATE | TIME_SECONDS) + " (" + days[serverTime.day_of_week] + ")");
        AddLine("Local:  " + TimeToString(TimeLocal(), TIME_DATE | TIME_SECONDS) + " (" + days[localTime.day_of_week] + ")");
    }
    else if (command == "server")
    {
        AddLine("Server: " + AccountInfoString(ACCOUNT_SERVER));
    }
    else if (command == "info")
    {
        AddLine("=== Current Chart ===");
        if (m_currentChartId > 0)
        {
            string sym = ChartSymbol(m_currentChartId);
            ENUM_TIMEFRAMES tf = (ENUM_TIMEFRAMES)ChartPeriod(m_currentChartId);
            string tfStr = EnumToString(tf);
            StringReplace(tfStr, "PERIOD_", "");
            
            AddLine("Symbol: " + sym);
            AddLine("Timeframe: " + tfStr);
            AddLine("Bid: " + DoubleToString(SymbolInfoDouble(sym, SYMBOL_BID), (int)SymbolInfoInteger(sym, SYMBOL_DIGITS)));
            AddLine("Ask: " + DoubleToString(SymbolInfoDouble(sym, SYMBOL_ASK), (int)SymbolInfoInteger(sym, SYMBOL_DIGITS)));
            AddLine("Spread: " + IntegerToString(SymbolInfoInteger(sym, SYMBOL_SPREAD)));
        }
        else
        {
            AddLine("No active chart.");
        }
    }
    else if (command == "comment" || StringFind(command, "comment ") == 0)
    {
        // Get or set chart comment.
        long chartId = m_currentChartId > 0 ? m_currentChartId : ChartFirst();
        
        if (command == "comment")
        {
            // Get current comment.
            string currentComment = ChartGetString(chartId, CHART_COMMENT);
            if (StringLen(currentComment) == 0)
                AddLine("Comment: (empty)");
            else
            {
                // Replace actual newlines with \n for display.
                string displayComment = currentComment;
                StringReplace(displayComment, "\n", "\\n");
                AddLine("Comment: " + displayComment);
            }
        }
        else
        {
            // Set comment.
            string newComment = StringSubstr(cmd, 8);  // "comment " is 8 chars
            StringTrimLeft(newComment);
            
            // Handle clearing comment.
            if (newComment == "\"\"" || newComment == "''" || newComment == "clear" || newComment == "none")
                newComment = "";
            
            // Convert \n to actual newline.
            StringReplace(newComment, "\\n", "\n");
            
            ChartSetString(chartId, CHART_COMMENT, newComment);
            ChartRedraw(chartId);
            
            if (StringLen(newComment) == 0)
                AddLine("Comment cleared.");
            else
                AddLine("Comment set.");
        }
    }
    else if (command == "system")
    {
        AddLine("=== System ===");
        AddLine("PID: " + IntegerToString(GetCurrentProcessId()));
        AddLine("TID: " + IntegerToString(GetCurrentThreadId()));
        AddLine("Build: " + IntegerToString(TerminalInfoInteger(TERMINAL_BUILD)));
        AddLine("Path: " + TerminalInfoString(TERMINAL_DATA_PATH));
    }
    else if (command == "account")
    {
        AddLine("Account: " + IntegerToString(AccountInfoInteger(ACCOUNT_LOGIN)));
        AddLine("Balance: " + FormatMoney(AccountInfoDouble(ACCOUNT_BALANCE)));
    }
    else if (command == "symbol" || StringFind(command, "symbol ") == 0)
    {
        // Change current chart's symbol.
        string newSymbol = "";
        if (StringFind(command, "symbol ") == 0)
            newSymbol = StringSubstr(cmd, 7);
        
        StringTrimLeft(newSymbol);
        StringTrimRight(newSymbol);
        StringToUpper(newSymbol);
        
        if (StringLen(newSymbol) == 0)
        {
            AddLine("Usage: symbol <symbol>");
            AddLine("Example: symbol EURUSD");
            AddLine("Changes the current chart's symbol.");
        }
        else
        {
            // Validate symbol exists.
            bool isCustom = false;
            if (!SymbolExist(newSymbol, isCustom))
            {
                // Try to find partial match in Market Watch.
                bool found = false;
                int total = SymbolsTotal(true);
                for (int i = 0; i < total; i++)
                {
                    string symName = SymbolName(i, true);
                    string symUpper = symName;
                    StringToUpper(symUpper);
                    if (StringFind(symUpper, newSymbol) >= 0)
                    {
                        newSymbol = symName;
                        found = true;
                        break;
                    }
                }
                
                if (!found)
                {
                    AddLine("Symbol not found: " + newSymbol);
                    AddLine("Use 'symbols' to see available symbols.");
                    return;
                }
            }
            
            // Add to Market Watch if not already there.
            if (!SymbolInfoInteger(newSymbol, SYMBOL_SELECT))
            {
                if (!SymbolSelect(newSymbol, true))
                {
                    AddLine("Failed to add " + newSymbol + " to Market Watch.");
                    return;
                }
                AddLine("Added " + newSymbol + " to Market Watch.");
            }
            
            // Get current chart.
            long chartId = ChartFirst();
            if (m_currentChartId > 0)
                chartId = m_currentChartId;
            
            if (chartId <= 0)
            {
                AddLine("No active chart.");
                return;
            }
            
            // Get current symbol for undo.
            string oldSymbol = ChartSymbol(chartId);

            // Change symbol.
            if (ChartSetSymbolPeriod(chartId, newSymbol, ChartPeriod(chartId)))
            {
                AddLine("Changed " + oldSymbol + " -> " + newSymbol);
                
                // Set undo.
                m_lastUndoCommand = "symbol";
                m_lastUndoData = oldSymbol;
                m_lastUndoChartId = chartId;
            }
            else
            {
                AddLine("Failed to change symbol.");
                int err = GetLastError();
                if (err != 0)
                    AddLine("Error: " + IntegerToString(err));
            }
        }
    }
    else if (command == "symbols")
    {
        int total = SymbolsTotal(true);
        AddLine("Market Watch Symbols: " + IntegerToString(total));
        AddLine("----------------------------------------");
        for (int i = 0; i < total; i++)
        {
            string symName = SymbolName(i, true);
            string symDesc = SymbolInfoString(symName, SYMBOL_DESCRIPTION);
            
            // Pad symbol name for alignment.
            string line = "  " + symName;
            while (StringLen(line) < 15)
                line += " ";
            
            line += " - " + symDesc;
            AddLine(line);
        }
        AddLine("----------------------------------------");
    }
    else if (command == "datafolder" || command == "df")
    {
        // Open MT5 data folder in Explorer.
        string dataPath = TerminalInfoString(TERMINAL_DATA_PATH);
        AddLine("Opening: " + dataPath);
        ShellExecuteW(0, "explore", dataPath, "", "", SW_SHOWNORMAL);
    }
    else if (command == "where")
    {
        // Output paths to data folder and program folder.
        string dataPath = TerminalInfoString(TERMINAL_DATA_PATH);
        string termPath = TerminalInfoString(TERMINAL_PATH);
        AddLine("Data:    " + dataPath);
        AddLine("Program: " + termPath);
    }
    else if (command == "clearcache")
    {
        // Delete contents of history and ticks subfolders in bases\<ServerName>\
        string dataPath = TerminalInfoString(TERMINAL_DATA_PATH);
        string server = AccountInfoString(ACCOUNT_SERVER);
        
        if (StringLen(server) == 0)
        {
            AddLine("No server connected");
        }
        else
        {
            string basePath = dataPath + "\\bases\\" + server + "\\";
            string historyPath = basePath + "history";
            string ticksPath = basePath + "ticks";
            
            int historyDeleted = DeleteFolderContents(historyPath);
            int ticksDeleted = DeleteFolderContents(ticksPath);
            
            AddLine("Cache cleared for " + server);
            AddLine("  History: " + IntegerToString(historyDeleted) + " items deleted");
            AddLine("  Ticks: " + IntegerToString(ticksDeleted) + " items deleted");
        }
    }
    else if (command == "ls" || command == "list" || StringFind(command, "ls ") == 0 || StringFind(command, "list ") == 0)
    {
        // List files in Linux style with columns.
        string arg = "";
        if (StringFind(command, "list ") == 0)
        {
            arg = StringSubstr(command, 5);
        }
        else if (StringFind(command, "ls ") == 0)
        {
            arg = StringSubstr(command, 3);
        }
        StringTrimLeft(arg);
        StringTrimRight(arg);
        StringToLower(arg);
        
        string dataPath = TerminalInfoString(TERMINAL_DATA_PATH);
        
        if (StringLen(arg) == 0)
        {
            // No argument - list all three folders.
            string folders[] = {"Experts", "Indicators", "Scripts"};
            for (int f = 0; f < 3; f++)
            {
                string folder = dataPath + "\\MQL5\\" + folders[f];
                string names[];
                CollectEX5Names(folder, names);
                
                AddLine(folders[f] + ":");
                if (ArraySize(names) == 0)
                    AddLine("  (empty)");
                else
                {
                    string lines[];
                    FormatInColumns(names, "  ", lines);
                    for (int ln = 0; ln < ArraySize(lines); ln++)
                        AddLine(lines[ln]);
                }
                AddLine("");
            }
        }
        else
        {
            string folder = "";
            string typeLabel = "";
            
            if (arg == "ind" || arg == "indicators" || arg == "indicator")
            {
                folder = dataPath + "\\MQL5\\Indicators";
                typeLabel = "Indicators";
            }
            else if (arg == "ea" || arg == "experts" || arg == "expert")
            {
                folder = dataPath + "\\MQL5\\Experts";
                typeLabel = "Experts";
            }
            else if (arg == "scripts" || arg == "script")
            {
                folder = dataPath + "\\MQL5\\Scripts";
                typeLabel = "Scripts";
            }
            else
            {
                AddLine("Unknown type: " + arg);
                AddLine("Use: ind, ea, or scripts");
                return;
            }
            
            string names[];
            CollectEX5Names(folder, names);
            
            AddLine(typeLabel + ":");
            if (ArraySize(names) == 0)
                AddLine("  (empty)");
            else
            {
                string lines[];
                FormatInColumns(names, "  ", lines);
                for (int ln = 0; ln < ArraySize(lines); ln++)
                    AddLine(lines[ln]);
            }
        }
    }
    else if (command == "alerts")
    {
        // Read alerts from alerts.dat file using Windows API (bypasses MQL5 sandbox).
        string dataPath = TerminalInfoString(TERMINAL_DATA_PATH);
        string alertsFile = dataPath + "\\bases\\alerts.dat";
        
        // Open file using Windows API
        int hFile = CreateFileW(alertsFile, GENERIC_READ, WIN_FILE_SHARE_READ, 0, 
                                        OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
        if (hFile == INVALID_HANDLE_VALUE)
        {
            AddLine("Cannot open alerts.dat.");
            AddLine("Path: " + alertsFile);
            return;
        }
        
        // Get file size.
        uint fileSizeHigh = 0;
        uint fileSize = GetFileSize(hFile, fileSizeHigh);
        if (fileSize < 0x1B0)  // Minimum header size (432 bytes).
        {
            AddLine("Invalid alerts.dat file (too small).");
            CloseHandle(hFile);
            return;
        }
        
        // Read entire file into buffer.
        uchar fileData[];
        ArrayResize(fileData, (int)fileSize);
        uint bytesRead = 0;
        if (!ReadFile(hFile, fileData, fileSize, bytesRead, 0) || bytesRead != fileSize)
        {
            AddLine("Failed to read alerts.dat.");
            CloseHandle(hFile);
            return;
        }
        CloseHandle(hFile);
        
        // Parse header - version at offset 0
        uint version = fileData[0] | (fileData[1] << 8) | (fileData[2] << 16) | (fileData[3] << 24);
        if (version != 500)
        {
            AddLine("Unknown alerts.dat version: " + IntegerToString(version));
            return;
        }
        
        // Read alert count at offset 0x1AC
        uint alertCount = fileData[0x1AC] | (fileData[0x1AD] << 8) | 
                                (fileData[0x1AE] << 16) | (fileData[0x1AF] << 24);
        
        if (alertCount == 0)
        {
            AddLine("No alerts defined.");
            return;
        }
        
        AddLine("Platform Alerts (" + IntegerToString(alertCount) + "):");
        AddLine("");
        
        // Record constants.
        int headerSize = 0x1B0;  // 432 bytes
        int recordSize = 1205;   // bytes per alert
        
        // Condition names.
        string condNames[] = {"Bid <", "Bid >", "Ask <", "Ask >", "Last <", "Last >", "Vol <", "Vol >"};
        
        for (uint i = 0; i < alertCount && i < 50; i++)
        {
            int offset = headerSize + (int)i * recordSize;
            
            // Read condition code at +84 (not +0 which is the index).
            uint condCode = fileData[offset + 84] | (fileData[offset + 85] << 8) | 
                                 (fileData[offset + 86] << 16) | (fileData[offset + 87] << 24);
            string condition = (condCode < 8) ? condNames[condCode] : "?";
            
            // Read symbol at +4 (64 bytes = 32 wchars UTF-16LE)
            ushort symChars[];
            ArrayResize(symChars, 32);
            for (int c = 0; c < 32; c++)
                symChars[c] = (ushort)(fileData[offset + 4 + c*2] | (fileData[offset + 5 + c*2] << 8));
            string symbol = ShortArrayToString(symChars);
            
            // Read price at +68 (8 bytes double).
            uchar priceBytes[];
            ArrayResize(priceBytes, 8);
            for (int b = 0; b < 8; b++)
                priceBytes[b] = fileData[offset + 68 + b];
            
            // Convert bytes to double using union-like approach.
            union DoubleUnion { double d; uchar bytes[8]; };
            DoubleUnion du;
            du.d = 0.0;  // Initialize to avoid warning.
            for (int b = 0; b < 8; b++) du.bytes[b] = priceBytes[b];
            double price = du.d;
            
            // Read enabled flag at +1120
            uint enabled = fileData[offset + 1120] | (fileData[offset + 1121] << 8) | 
                                (fileData[offset + 1122] << 16) | (fileData[offset + 1123] << 24);
            
            // Read timeout flag at +88
            uint timeout = fileData[offset + 88] | (fileData[offset + 89] << 8) | 
                                (fileData[offset + 90] << 16) | (fileData[offset + 91] << 24);
            
            // Read action type at +92
            uint actionType = fileData[offset + 92] | (fileData[offset + 93] << 8) | 
                                    (fileData[offset + 94] << 16) | (fileData[offset + 95] << 24);
            
            // Read action content at +96 (first 32 chars for display).
            ushort actionChars[];
            ArrayResize(actionChars, 32);
            for (int c = 0; c < 32; c++)
                actionChars[c] = (ushort)(fileData[offset + 96 + c*2] | (fileData[offset + 97 + c*2] << 8));
            string action = ShortArrayToString(actionChars);
            
            // Read max iterations at +1133 (misaligned!)
            uint maxIter = fileData[offset + 1133] | (fileData[offset + 1134] << 8) | 
                                (fileData[offset + 1135] << 16) | (fileData[offset + 1136] << 24);
            
            // Read expiration at +1141
            uint expiration = fileData[offset + 1141] | (fileData[offset + 1142] << 8) | 
                                    (fileData[offset + 1143] << 16) | (fileData[offset + 1144] << 24);
            
            // Format output.
            string prefix = (enabled == 0) ? "[OFF] " : "";
            string line = IntegerToString(i + 1) + ". " + prefix + symbol + " " + condition + " " + 
                              DoubleToString(price, 5);
            
            // Add action info.
            string actionTypes[] = {"Sound", "File", "Mail", "Push"};
            if (actionType < 4)
            {
                if (actionType == 0)  // Sound.
                    line += " (" + action + ")";
                else if (actionType == 2)  // Mail.
                    line += " (Mail: " + action + ")";
                else
                    line += " (" + actionTypes[actionType] + ")";
            }
            
            // Add iterations.
            if (maxIter > 0)
                line += " x" + IntegerToString(maxIter);
            
            // Add timeout.
            if (timeout > 0)
                line += " T";
            
            // Add expiration.
            if (expiration > 0)
            {
                datetime expTime = (datetime)expiration;
                line += " exp:" + TimeToString(expTime, TIME_DATE);
            }
            
            AddLine(line);
        }
        
        if (alertCount > 50)
            AddLine("... and " + IntegerToString(alertCount - 50) + " more alerts.");
        
        AddLine("");
        AddLine("Use 'alerts-enable/disable/del <n>' to modify.");
    }
    else if (command == "alerts-add" || StringFind(command, "alerts-add ") == 0)
    {
        // Add a new alert: alerts-add SYMBOL CONDITION VALUE
        // Example: alerts-add EURUSD bid< 1.05
        // Conditions: bid<, bid>, ask<, ask>, last<, last>, vol<, vol>
        
        string args = StringSubstr(cmd, 11);
        StringTrimLeft(args);
        
        // Parse arguments.
        string parts[];
        int numParts = StringSplit(args, ' ', parts);
        
        if (numParts < 3)
        {
            AddLine("Usage: alerts-add SYMBOL COND VALUE");
            AddLine("  COND: bid<, bid>, ask<, ask>, last<, last>, vol<, vol>");
            AddLine("  Example: alerts-add EURUSD bid< 1.05");
            return;
        }
        
        string symbol = parts[0];
        string condStr = parts[1];
        StringToLower(condStr);
        double value = StringToDouble(parts[2]);
        
        // Validate and prepare symbol.
        StringToUpper(symbol);
        
        // Check if symbol exists.
        bool isCustom = false;
        if (!SymbolExist(symbol, isCustom))
        {
            AddLine("Symbol not found: " + symbol + ".");
            return;
        }
        
        // Check if symbol is in Market Watch, add if not.
        if (!SymbolInfoInteger(symbol, SYMBOL_SELECT))
        {
            if (SymbolSelect(symbol, true))
                AddLine("Added " + symbol + " to Market Watch.");
            else
            {
                AddLine("Failed to add " + symbol + " to Market Watch.");
                return;
            }
        }
        
        // Validate condition.
        int condIndex = -1;
        string conditions[] = {"bid<", "bid>", "ask<", "ask>", "last<", "last>", "vol<", "vol>"};
        for (int c = 0; c < 8; c++)
        {
            if (condStr == conditions[c])
            {
                condIndex = c;
                break;
            }
        }
        
        if (condIndex < 0)
        {
            AddLine("Invalid condition: " + condStr + ".");
            AddLine("Valid: bid<, bid>, ask<, ask>, last<, last>, vol<, vol>");
            return;
        }
        
        AddLine("Adding alert: " + symbol + " " + condStr + " " + DoubleToString(value, 5));
        
        // Find or open Toolbox and switch to Alerts tab.
        long hToolbox = 0;
        long hTabControl = 0;
        if (!OpenToolbox(hToolbox, hTabControl))
        {
            AddLine("Toolbox not found.");
            return;
        }
        
        // Switch to Alerts tab (index 6).
        int rect[4];
        ArrayInitialize(rect, 0);
        if (SendMessageW(hTabControl, TCM_GETITEMRECT, 6, rect) != 0)
        {
            int centerX = (rect[0] + rect[2]) / 2;
            int centerY = (rect[1] + rect[3]) / 2;
            int lParam = (centerY << 16) | (centerX & 0xFFFF);
            
            SendMessageW(hTabControl, WM_LBUTTONDOWN, MK_LBUTTON, lParam);
            SendMessageW(hTabControl, WM_LBUTTONUP, 0, lParam);
            Sleep(50);
        }
        
        // Find the visible ListView (retry if not found immediately).
        long hAlertsList = FindVisibleListView(hToolbox);
        if (hAlertsList == 0)
        {
            Sleep(100);
            hAlertsList = FindVisibleListView(hToolbox);
        }
        if (hAlertsList == 0)
        {
            AddLine("Alerts ListView not found.");
            return;
        }
        
        // Get ListView position.
        int listRect[4];
        GetWindowRect(hAlertsList, listRect);
        int clickX = listRect[0] + 50;
        int clickY = listRect[1] + 40;
        
        SetForegroundWindow(m_hwndMT5);
        Sleep(30);
        
        // Click to focus ListView.
        ClickAt(clickX, clickY);
        Sleep(30);
        
        // Insert to open dialog.
        keybd_event(VK_INSERT, 0, 0, 0);
        Sleep(10);
        keybd_event(VK_INSERT, 0, KEYEVENTF_KEYUP, 0);
        
        // Wait for dialog to open (retry up to 500ms).
        long hDialog = 0;
        for (int retry = 0; retry < 10; retry++)
        {
            Sleep(50);
            hDialog = GetForegroundWindow();
            if (hDialog != 0 && hDialog != m_hwndMT5 && hDialog != m_hwnd)
                break;
            hDialog = 0;
        }
        
        if (hDialog == 0)
        {
            AddLine("Create dialog not found.");
            SetForegroundWindow(m_hwnd);
            return;
        }
        
        // Fill dialog.
        SetForegroundWindow(hDialog);
        Sleep(30);
        
        // Tab to Symbol (2x).
        keybd_event(VK_TAB, 0, 0, 0);
        Sleep(5);
        keybd_event(VK_TAB, 0, KEYEVENTF_KEYUP, 0);
        Sleep(15);
        keybd_event(VK_TAB, 0, 0, 0);
        Sleep(5);
        keybd_event(VK_TAB, 0, KEYEVENTF_KEYUP, 0);
        Sleep(15);
        
        // Ctrl+A to select all.
        keybd_event(VK_CONTROL, 0, 0, 0);
        keybd_event('A', 0, 0, 0);
        Sleep(5);
        keybd_event('A', 0, KEYEVENTF_KEYUP, 0);
        keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
        Sleep(15);
        
        // Type symbol.
        for (int i = 0; i < StringLen(symbol); i++)
        {
            ushort ch = StringGetCharacter(symbol, i);
            keybd_event((uchar)ch, 0, 0, 0);
            Sleep(5);
            keybd_event((uchar)ch, 0, KEYEVENTF_KEYUP, 0);
            Sleep(10);
        }
        Sleep(80);  // Wait for autocomplete dropdown.
        
        // Down + Enter to select from autocomplete.
        keybd_event(VK_DOWN, 0, 0, 0);
        Sleep(5);
        keybd_event(VK_DOWN, 0, KEYEVENTF_KEYUP, 0);
        Sleep(30);
        keybd_event(VK_RETURN, 0, 0, 0);
        Sleep(5);
        keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);
        Sleep(50);
        
        // Tab to Condition.
        keybd_event(VK_TAB, 0, 0, 0);
        Sleep(5);
        keybd_event(VK_TAB, 0, KEYEVENTF_KEYUP, 0);
        Sleep(20);
        
        // Select condition with Down arrows.
        for (int d = 0; d < condIndex; d++)
        {
            keybd_event(VK_DOWN, 0, 0, 0);
            Sleep(5);
            keybd_event(VK_DOWN, 0, KEYEVENTF_KEYUP, 0);
            Sleep(15);
        }
        
        // Tab to Value.
        keybd_event(VK_TAB, 0, 0, 0);
        Sleep(5);
        keybd_event(VK_TAB, 0, KEYEVENTF_KEYUP, 0);
        Sleep(20);
        
        // Ctrl+A to select all.
        keybd_event(VK_CONTROL, 0, 0, 0);
        keybd_event('A', 0, 0, 0);
        Sleep(5);
        keybd_event('A', 0, KEYEVENTF_KEYUP, 0);
        keybd_event(VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
        Sleep(15);
        
        // Type value.
        string valueStr = DoubleToString(value, 5);
        for (int i = 0; i < StringLen(valueStr); i++)
        {
            ushort ch = StringGetCharacter(valueStr, i);
            if (ch == '.')
            {
                keybd_event(VK_OEM_PERIOD, 0, 0, 0);
                Sleep(5);
                keybd_event(VK_OEM_PERIOD, 0, KEYEVENTF_KEYUP, 0);
            }
            else if (ch >= '0' && ch <= '9')
            {
                keybd_event((uchar)ch, 0, 0, 0);
                Sleep(5);
                keybd_event((uchar)ch, 0, KEYEVENTF_KEYUP, 0);
            }
            Sleep(10);
        }
        Sleep(30);
        
        // Enter to save and close dialog.
        keybd_event(VK_RETURN, 0, 0, 0);
        Sleep(10);
        keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);
        Sleep(100);
        
        AddLine("Alert created.");
        SetForegroundWindow(m_hwnd);
    }
    else if (command == "alerts-enable" || StringFind(command, "alerts-enable ") == 0 || command == "alerts-disable" || StringFind(command, "alerts-disable ") == 0 ||
              command == "alerts-del" || StringFind(command, "alerts-del ") == 0)
    {
        // Modify alerts via ListView using mouse clicks.
        bool isEnable = (command == "alerts-enable" || StringFind(command, "alerts-enable ") == 0);
        bool isDisable = (command == "alerts-disable" || StringFind(command, "alerts-disable ") == 0);
        bool isDelete = (command == "alerts-del" || StringFind(command, "alerts-del ") == 0);
        
        // Parse index.
        int cmdLen = isEnable ? 14 : (isDisable ? 15 : 11);
        string indexStr = StringSubstr(cmd, cmdLen);
        StringTrimLeft(indexStr);
        int alertIndex = (int)StringToInteger(indexStr);
        
        if (alertIndex <= 0)
        {
            if (isEnable)
                AddLine("Usage: alerts-enable <index>");
            else if (isDisable)
                AddLine("Usage: alerts-disable <index>");
            else
                AddLine("Usage: alerts-del <index>");
            AddLine("Use 'alerts' to list alerts first.");
            return;
        }
        
        // For enable/disable, check current state from alerts.dat.
        if (isEnable || isDisable)
        {
            string dataPath = TerminalInfoString(TERMINAL_DATA_PATH);
            string alertsFile = dataPath + "\\bases\\alerts.dat";
            
            int hFile = CreateFileW(alertsFile, GENERIC_READ, WIN_FILE_SHARE_READ, 0, 
                                            OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
            if (hFile != INVALID_HANDLE_VALUE)
            {
                uint fileSizeHigh = 0;
                uint fileSize = GetFileSize(hFile, fileSizeHigh);
                
                if (fileSize >= 0x1B0)
                {
                    uchar fileData[];
                    ArrayResize(fileData, (int)fileSize);
                    uint bytesRead = 0;
                    
                    if (ReadFile(hFile, fileData, fileSize, bytesRead, 0) && bytesRead == fileSize)
                    {
                        // Get alert count.
                        uint alertCount = fileData[0x1AC]        | (fileData[0x1AD] << 8) | 
                                              (fileData[0x1AE] << 16) | (fileData[0x1AF] << 24);
                        
                        if (alertIndex > (int)alertCount)
                        {
                            AddLine("Invalid index. Only " + IntegerToString(alertCount) + " alerts exist.");
                            CloseHandle(hFile);
                            return;
                        }
                        
                        // Read enabled flag at offset +1120 in record.
                        int headerSize = 0x1B0;
                        int recordSize = 1205;
                        int offset = headerSize + (alertIndex - 1) * recordSize;
                        
                        uint enabled = fileData[offset + 1120] | (fileData[offset + 1121] << 8) | 
                                            (fileData[offset + 1122] << 16) | (fileData[offset + 1123] << 24);
                        
                        bool isCurrentlyEnabled = (enabled != 0);
                        
                        if (isEnable && isCurrentlyEnabled)
                        {
                            AddLine("Alert " + IntegerToString(alertIndex) + " is already enabled.");
                            CloseHandle(hFile);
                            return;
                        }
                        else if (isDisable && !isCurrentlyEnabled)
                        {
                            AddLine("Alert " + IntegerToString(alertIndex) + " is already disabled.");
                            CloseHandle(hFile);
                            return;
                        }
                    }
                }
                CloseHandle(hFile);
            }
        }
        
        // Find or open Toolbox and switch to Alerts tab.
        long hToolbox = 0;
        long hTabControl = 0;
        if (!OpenToolbox(hToolbox, hTabControl))
        {
            AddLine("Toolbox not found.");
            return;
        }
        
        // Switch to Alerts tab (index 6).
        int rect[4];
        ArrayInitialize(rect, 0);
        if (SendMessageW(hTabControl, TCM_GETITEMRECT, 6, rect) != 0)
        {
            int centerX = (rect[0] + rect[2]) / 2;
            int centerY = (rect[1] + rect[3]) / 2;
            int lParam = (centerY << 16) | (centerX & 0xFFFF);
            
            SendMessageW(hTabControl, WM_LBUTTONDOWN, MK_LBUTTON, lParam);
            SendMessageW(hTabControl, WM_LBUTTONUP, 0, lParam);
            Sleep(50);
        }
        
        // Find the visible ListView (retry if not found immediately).
        long hAlertsList = FindVisibleListView(hToolbox);
        if (hAlertsList == 0)
        {
            Sleep(100);
            hAlertsList = FindVisibleListView(hToolbox);
        }
        if (hAlertsList == 0)
        {
            AddLine("Alerts ListView not found.");
            return;
        }
        
        int itemCount = (int)SendMessageW(hAlertsList, LVM_GETITEMCOUNT, 0, 0);
        if (itemCount == 0)
        {
            AddLine("No alerts in list.");
            return;
        }
        
        if (alertIndex > itemCount)
        {
            AddLine("Invalid index. Only " + IntegerToString(itemCount) + " alerts exist.");
            return;
        }
        
        // Get ListView screen position - click to focus, then use keyboard to select item.
        int listRect[4];
        ArrayInitialize(listRect, 0);
        GetWindowRect(hAlertsList, listRect);
        
        // Click in the middle of the ListView to focus it.
        int clickX = listRect[0] + 50;
        int clickY = listRect[1] + 40;
        
        SetForegroundWindow(m_hwndMT5);
        Sleep(30);
        ClickAt(clickX, clickY);
        Sleep(30);
        
        // Use keyboard to navigate to the correct item.
        // Press Home to go to first item.
        keybd_event(VK_HOME, 0, 0, 0);
        Sleep(5);
        keybd_event(VK_HOME, 0, KEYEVENTF_KEYUP, 0);
        Sleep(20);
        
        // Press Down arrow (alertIndex - 1) times to get to desired item.
        for (int i = 0; i < alertIndex - 1; i++)
        {
            keybd_event(VK_DOWN, 0, 0, 0);
            Sleep(5);
            keybd_event(VK_DOWN, 0, KEYEVENTF_KEYUP, 0);
            Sleep(10);
        }
        
        if (isDelete)
        {
            AddLine("Deleting alert " + IntegerToString(alertIndex) + "...");
            keybd_event(VK_DELETE, 0, 0, 0);
            Sleep(10);
            keybd_event(VK_DELETE, 0, KEYEVENTF_KEYUP, 0);
            Sleep(30);
            keybd_event(VK_RETURN, 0, 0, 0);
            Sleep(10);
            keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);
            Sleep(30);
            AddLine("Done.");
            SetForegroundWindow(m_hwnd);
        }
        else
        {
            AddLine((isEnable ? "Enabling" : "Disabling") + " alert " + IntegerToString(alertIndex) + "...");
            
            // Press Enter to open edit dialog (instead of double-click).
            keybd_event(VK_RETURN, 0, 0, 0);
            Sleep(10);
            keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);
            Sleep(100);  // Wait for dialog.
            
            long hDialog = GetForegroundWindow();
            if (hDialog != 0 && hDialog != m_hwndMT5)
            {
                // Alt+E to focus Enable checkbox.
                keybd_event(VK_MENU, 0, 0, 0);
                keybd_event('E', 0, 0, 0);
                Sleep(10);
                keybd_event('E', 0, KEYEVENTF_KEYUP, 0);
                keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0);
                Sleep(20);
                
                // Space to toggle.
                keybd_event(VK_SPACE, 0, 0, 0);
                Sleep(10);
                keybd_event(VK_SPACE, 0, KEYEVENTF_KEYUP, 0);
                Sleep(30);
                
                // Enter to save.
                keybd_event(VK_RETURN, 0, 0, 0);
                Sleep(10);
                keybd_event(VK_RETURN, 0, KEYEVENTF_KEYUP, 0);
                Sleep(100);
                
                AddLine("Done.");
            }
            else
            {
                AddLine("Dialog not found.");
            }
            SetForegroundWindow(m_hwnd);
        }
    }
    else if (command == "gvar")
    {
        // List all global (terminal) variables.
        int total = GlobalVariablesTotal();
        if (total == 0)
        {
            AddLine("No global variables.");
        }
        else
        {
            AddLine("Global variables (" + IntegerToString(total) + "):");
            for (int i = 0; i < total; i++)
            {
                string name = GlobalVariableName(i);
                double value = GlobalVariableGet(name);
                AddLine("  " + name + " = " + DoubleToString(value, 8));
            }
        }
    }
    else if (command == "gvar-set" || StringFind(command, "gvar-set ") == 0)
    {
        // Set a global variable: gvar-set <name> <value>
        string args = StringSubstr(cmd, 9);
        StringTrimLeft(args);
        StringTrimRight(args);
        
        int spacePos = StringFind(args, " ");
        if (spacePos <= 0)
        {
            AddLine("Usage: gvar-set <name> <value>");
            AddLine("Example: gvar-set MyVar 123.45");
        }
        else
        {
            string varName = StringSubstr(args, 0, spacePos);
            string varValue = StringSubstr(args, spacePos + 1);
            StringTrimLeft(varValue);
            
            double value = StringToDouble(varValue);
            datetime time = GlobalVariableSet(varName, value);
            if (time > 0)
                AddLine(varName + " = " + DoubleToString(value, 8));
            else
                AddLine("Failed to set " + varName);
        }
    }
    else if (command == "gvar-del" || StringFind(command, "gvar-del ") == 0)
    {
        // Delete a global variable: gvar-del <name>
        string varName = StringSubstr(cmd, 9);
        StringTrimLeft(varName);
        StringTrimRight(varName);
        
        if (StringLen(varName) == 0)
        {
            AddLine("Usage: gvar-del <name>");
        }
        else
        {
            if (GlobalVariableCheck(varName))
            {
                if (GlobalVariableDel(varName))
                    AddLine("Deleted: " + varName);
                else
                    AddLine("Failed to delete " + varName);
            }
            else
            {
                AddLine("Variable not found: " + varName);
            }
        }
    }
    else if (command == "metaeditor" || command == "ide" || StringFind(command, "metaeditor ") == 0 || StringFind(command, "ide ") == 0)
    {
        // Launch MetaEditor, optionally opening a specific file.
        string fileArg = "";
        if (StringFind(command, "metaeditor ") == 0)
            fileArg = StringSubstr(cmd, 11);
        else if (StringFind(command, "ide ") == 0)
            fileArg = StringSubstr(cmd, 4);
        StringTrimLeft(fileArg);
        StringTrimRight(fileArg);
        
        if (StringLen(fileArg) == 0)
        {
            // Just launch MetaEditor via F4
            AddLine("Launching MetaEditor...");
            PostMessageW(m_hwndMT5, WM_KEYDOWN, VK_F4, 0);
            Sleep(50);
            PostMessageW(m_hwndMT5, WM_KEYUP, VK_F4, 0);
        }
        else
        {
            // Open specific file in MetaEditor.
            string dataPath = TerminalInfoString(TERMINAL_DATA_PATH);
            string termPath = TerminalInfoString(TERMINAL_PATH);
            string metaEditorPath = termPath + "\\MetaEditor64.exe";
            
            // Build full path if relative.
            string filePath = fileArg;
            
            // Check if it's a relative path (no drive letter or leading backslash).
            if (StringFind(filePath, ":") < 0 && StringGetCharacter(filePath, 0) != '\\')
            {
                // Try to find the file in MQL5 subfolders.
                string searchPaths[];
                ArrayResize(searchPaths, 6);
                searchPaths[0] = dataPath + "\\MQL5\\Experts\\" + filePath;
                searchPaths[1] = dataPath + "\\MQL5\\Indicators\\" + filePath;
                searchPaths[2] = dataPath + "\\MQL5\\Scripts\\" + filePath;
                searchPaths[3] = dataPath + "\\MQL5\\Include\\" + filePath;
                searchPaths[4] = dataPath + "\\MQL5\\Services\\" + filePath;
                searchPaths[5] = dataPath + "\\MQL5\\" + filePath;
                
                bool found = false;
                for (int p = 0; p < ArraySize(searchPaths); p++)
                {
                    string testPath = searchPaths[p];
                    // Add .mq5 extension if not present.
                    if (StringFind(testPath, ".mq") < 0 && StringFind(testPath, ".mqh") < 0)
                        testPath += ".mq5";
                    
                    // Check if file exists using Windows API
                    int attrs = GetFileAttributesW(testPath);
                    if (attrs != -1 && (attrs & FILE_ATTRIBUTE_DIRECTORY) == 0)
                    {
                        filePath = testPath;
                        found = true;
                        break;
                    }
                }
                
                if (!found)
                {
                    // Try with .mq5 extension added to original.
                    if (StringFind(fileArg, ".mq") < 0)
                        filePath = dataPath + "\\MQL5\\" + fileArg + ".mq5";
                    else
                        filePath = dataPath + "\\MQL5\\" + fileArg;
                }
            }
            
            AddLine("Opening: " + filePath);
            ShellExecuteW(0, "open", metaEditorPath, "\"" + filePath + "\"", "", SW_SHOWNORMAL);
        }
    }
    else if (command == "add" || StringFind(command, "add ") == 0)
    {
        // Add indicator silently (no dialog) using ChartIndicatorAdd.
        string indArg = "";
        if (StringLen(cmd) > 4)
        {
            indArg = StringSubstr(cmd, 4);
            StringTrimLeft(indArg);
            StringTrimRight(indArg);
        }
        StringToLower(indArg);
        
        if (StringLen(indArg) == 0)
        {
            AddLine("Usage: add <indicator>");
            AddLine("Adds indicator with default parameters (no dialog).");
            AddLine("Examples:");
            AddLine("  add ma      - EMA(14)");
            AddLine("  add sma     - SMA(14)");
            AddLine("  add rsi     - RSI(14)");
            AddLine("  add macd    - MACD(12,26,9)");
            AddLine("  add bb      - Bollinger Bands(20,2)");
            AddLine("  add stoch   - Stochastic(5,3,3)");
            AddLine("  add sar     - Parabolic SAR");
            AddLine("  add ich     - Ichimoku");
            AddLine("");
            AddLine("Use 'attach' to open parameter dialog.");
        }
        else
        {
            string sym = ChartSymbol(m_currentChartId);
            ENUM_TIMEFRAMES tf = (ENUM_TIMEFRAMES)ChartPeriod(m_currentChartId);
            int handle = INVALID_HANDLE;
            string indName = "";
            bool needsSubwindow = false;
            
            if (indArg == "ma" || indArg == "ema")
            {
                handle = iMA(sym, tf, 14, 0, MODE_EMA, PRICE_CLOSE);
                indName = "EMA(14)";
            }
            else if (indArg == "sma")
            {
                handle = iMA(sym, tf, 14, 0, MODE_SMA, PRICE_CLOSE);
                indName = "SMA(14)";
            }
            else if (indArg == "rsi")
            {
                handle = iRSI(sym, tf, 14, PRICE_CLOSE);
                indName = "RSI(14)";
                needsSubwindow = true;
            }
            else if (indArg == "macd")
            {
                handle = iMACD(sym, tf, 12, 26, 9, PRICE_CLOSE);
                indName = "MACD(12,26,9)";
                needsSubwindow = true;
            }
            else if (indArg == "bb" || indArg == "bollinger" || indArg == "bands")
            {
                handle = iBands(sym, tf, 20, 0, 2.0, PRICE_CLOSE);
                indName = "Bollinger Bands(20,2)";
            }
            else if (indArg == "stoch" || indArg == "stochastic")
            {
                handle = iStochastic(sym, tf, 5, 3, 3, MODE_SMA, STO_LOWHIGH);
                indName = "Stochastic(5,3,3)";
                needsSubwindow = true;
            }
            else if (indArg == "cci")
            {
                handle = iCCI(sym, tf, 14, PRICE_TYPICAL);
                indName = "CCI(14)";
                needsSubwindow = true;
            }
            else if (indArg == "atr")
            {
                handle = iATR(sym, tf, 14);
                indName = "ATR(14)";
                needsSubwindow = true;
            }
            else if (indArg == "adx")
            {
                handle = iADX(sym, tf, 14);
                indName = "ADX(14)";
                needsSubwindow = true;
            }
            else if (indArg == "sar" || indArg == "psar" || indArg == "parabolic")
            {
                handle = iSAR(sym, tf, 0.02, 0.2);
                indName = "Parabolic SAR";
            }
            else if (indArg == "ich" || indArg == "ichimoku")
            {
                handle = iIchimoku(sym, tf, 9, 26, 52);
                indName = "Ichimoku";
            }
            else if (indArg == "vol" || indArg == "volumes" || indArg == "volume")
            {
                handle = iVolumes(sym, tf, VOLUME_TICK);
                indName = "Volumes";
                needsSubwindow = true;
            }
            else if (indArg == "momentum" || indArg == "mom")
            {
                handle = iMomentum(sym, tf, 14, PRICE_CLOSE);
                indName = "Momentum(14)";
                needsSubwindow = true;
            }
            else if (indArg == "obv")
            {
                handle = iOBV(sym, tf, VOLUME_TICK);
                indName = "OBV";
                needsSubwindow = true;
            }
            else if (indArg == "mfi")
            {
                handle = iMFI(sym, tf, 14, VOLUME_TICK);
                indName = "MFI(14)";
                needsSubwindow = true;
            }
            else if (indArg == "env" || indArg == "envelopes")
            {
                handle = iEnvelopes(sym, tf, 14, 0, MODE_SMA, PRICE_CLOSE, 0.1);
                indName = "Envelopes(14)";
            }
            else if (indArg == "wpr" || indArg == "williams")
            {
                handle = iWPR(sym, tf, 14);
                indName = "Williams %R(14)";
                needsSubwindow = true;
            }
            else if (indArg == "demarker" || indArg == "dem")
            {
                handle = iDeMarker(sym, tf, 14);
                indName = "DeMarker(14)";
                needsSubwindow = true;
            }
            else if (indArg == "force" || indArg == "fi")
            {
                handle = iForce(sym, tf, 13, MODE_SMA, VOLUME_TICK);
                indName = "Force Index(13)";
                needsSubwindow = true;
            }
            else if (indArg == "bears" || indArg == "bearpower")
            {
                handle = iBearsPower(sym, tf, 13);
                indName = "Bears Power(13)";
                needsSubwindow = true;
            }
            else if (indArg == "bulls" || indArg == "bullpower")
            {
                handle = iBullsPower(sym, tf, 13);
                indName = "Bulls Power(13)";
                needsSubwindow = true;
            }
            else if (indArg == "ao" || indArg == "awesome")
            {
                handle = iAO(sym, tf);
                indName = "Awesome Oscillator";
                needsSubwindow = true;
            }
            else if (indArg == "ac" || indArg == "accelerator")
            {
                handle = iAC(sym, tf);
                indName = "Accelerator Oscillator";
                needsSubwindow = true;
            }
            else if (indArg == "gator")
            {
                handle = iGator(sym, tf, 13, 8, 8, 5, 5, 3, MODE_SMMA, PRICE_MEDIAN);
                indName = "Gator Oscillator";
                needsSubwindow = true;
            }
            else if (indArg == "alligator")
            {
                handle = iAlligator(sym, tf, 13, 8, 8, 5, 5, 3, MODE_SMMA, PRICE_MEDIAN);
                indName = "Alligator";
            }
            else if (indArg == "fractals")
            {
                handle = iFractals(sym, tf);
                indName = "Fractals";
            }
            else if (indArg == "std" || indArg == "stddev")
            {
                handle = iStdDev(sym, tf, 20, 0, MODE_SMA, PRICE_CLOSE);
                indName = "StdDev(20)";
                needsSubwindow = true;
            }
            else
            {
                AddLine("Unknown indicator: " + indArg);
                AddLine("Use 'add' for list of available indicators.");
                return;
            }
            
            if (handle == INVALID_HANDLE)
            {
                AddLine("Failed to create " + indName + " indicator.");
                return;
            }
            
            // Determine window number.
            int windowNum = 0;
            if (needsSubwindow)
            {
                // Get the number of existing subwindows and add to a new one.
                windowNum = (int)ChartGetInteger(m_currentChartId, CHART_WINDOWS_TOTAL);
            }
            
            // Add to chart.
            if (ChartIndicatorAdd(m_currentChartId, windowNum, handle))
            {
                AddLine("Added " + indName + ".");
                ChartRedraw(m_currentChartId);
                
                // Save undo info - get the actual indicator short name from chart.
                string actualName = ChartIndicatorName(m_currentChartId, windowNum, 
                                              ChartIndicatorsTotal(m_currentChartId, windowNum) - 1);
                m_lastUndoCommand = "add";
                m_lastUndoData = actualName + "|" + IntegerToString(windowNum);
                m_lastUndoChartId = m_currentChartId;
            }
            else
            {
                AddLine("Failed to add " + indName + " (error " + IntegerToString(GetLastError()) + ").");
                IndicatorRelease(handle);
            }
        }
    }
    else if (command == "attach" || command == "att" || StringFind(command, "attach ") == 0 || StringFind(command, "att ") == 0)
    {
        // Attach indicator via Insert menu (opens a confirmation dialog).
        string indArg = "";
        if (StringFind(command, "attach ") == 0)
            indArg = StringSubstr(cmd, 7);
        else if (StringFind(command, "att ") == 0)
            indArg = StringSubstr(cmd, 4);
        
        StringTrimLeft(indArg);
        StringTrimRight(indArg);
        StringToLower(indArg);
        
        if (StringLen(indArg) == 0)
        {
            AddLine("Usage: attach <indicator>");
            AddLine("Opens indicator dialog for configuration.");
            AddLine("Examples:");
            AddLine("  attach ma     - Moving Average");
            AddLine("  attach rsi    - RSI");
            AddLine("  attach macd   - MACD");
            AddLine("  attach bb     - Bollinger Bands");
            AddLine("  attach stoch  - Stochastic Oscillator");
            AddLine("  attach sar    - Parabolic SAR");
            AddLine("  attach MyInd  - Custom indicator by name");
            AddLine("");
            AddLine("Use 'add' for quick add without dialog.");
        }
        else
        {
            // Map shorthand to menu indicator name and category.
            string indName = "";
            string category = "";  // "Trend", "Oscillators", "Volumes", "Bill Williams"
            
            if (indArg == "ma" || indArg == "ema" || indArg == "sma" || indArg == "movingaverage")
            {
                indName = "Moving Average";
                category = "Trend";
            }
            else if (indArg == "rsi")
            {
                indName = "Relative Strength Index";
                category = "Oscillators";
            }
            else if (indArg == "macd")
            {
                indName = "MACD";
                category = "Oscillators";
            }
            else if (indArg == "bb" || indArg == "bollinger" || indArg == "bands")
            {
                indName = "Bollinger Bands";
                category = "Trend";
            }
            else if (indArg == "stoch" || indArg == "stochastic")
            {
                indName = "Stochastic Oscillator";
                category = "Oscillators";
            }
            else if (indArg == "cci")
            {
                indName = "Commodity Channel Index";
                category = "Oscillators";
            }
            else if (indArg == "atr")
            {
                indName = "Average True Range";
                category = "Oscillators";
            }
            else if (indArg == "adx")
            {
                indName = "Average Directional Movement Index";
                category = "Trend";
            }
            else if (indArg == "sar" || indArg == "psar" || indArg == "parabolic")
            {
                indName = "Parabolic SAR";
                category = "Trend";
            }
            else if (indArg == "ich" || indArg == "ichimoku")
            {
                indName = "Ichimoku Kinko Hyo";
                category = "Trend";
            }
            else if (indArg == "vol" || indArg == "volumes" || indArg == "volume")
            {
                indName = "Volumes";
                category = "Volumes";
            }
            else if (indArg == "momentum" || indArg == "mom")
            {
                indName = "Momentum";
                category = "Oscillators";
            }
            else if (indArg == "obv")
            {
                indName = "On Balance Volume";
                category = "Volumes";
            }
            else if (indArg == "mfi")
            {
                indName = "Money Flow Index";
                category = "Volumes";
            }
            else if (indArg == "env" || indArg == "envelopes")
            {
                indName = "Envelopes";
                category = "Trend";
            }
            else if (indArg == "wpr" || indArg == "williams")
            {
                indName = "Williams' Percent Range";
                category = "Oscillators";
            }
            else if (indArg == "demarker" || indArg == "dem")
            {
                indName = "DeMarker";
                category = "Oscillators";
            }
            else if (indArg == "force" || indArg == "fi")
            {
                indName = "Force Index";
                category = "Oscillators";
            }
            else if (indArg == "bears" || indArg == "bearpower")
            {
                indName = "Bears Power";
                category = "Oscillators";
            }
            else if (indArg == "bulls" || indArg == "bullpower")
            {
                indName = "Bulls Power";
                category = "Oscillators";
            }
            else if (indArg == "ao" || indArg == "awesome")
            {
                indName = "Awesome Oscillator";
                category = "Bill Williams";
            }
            else if (indArg == "ac" || indArg == "accelerator")
            {
                indName = "Accelerator Oscillator";
                category = "Bill Williams";
            }
            else if (indArg == "gator")
            {
                indName = "Gator Oscillator";
                category = "Bill Williams";
            }
            else if (indArg == "alligator")
            {
                indName = "Alligator";
                category = "Bill Williams";
            }
            else if (indArg == "fractals")
            {
                indName = "Fractals";
                category = "Bill Williams";
            }
            else if (indArg == "std" || indArg == "stddev")
            {
                indName = "Standard Deviation";
                category = "Trend";
            }
            else
            {
                // Not a standard indicator - try to find as custom indicator.
                AddLine("Attaching custom: " + indArg + "...");
                
                string attachResult;
                if (AttachCustomIndicator(m_hwndMT5, indArg, attachResult))
                {
                    AddLine("Indicator dialog opened.");
                }
                else
                {
                    AddLine("Failed: " + attachResult);
                    AddLine("Use 'attach' for list of built-in indicators.");
                }
                return;
            }
            
            AddLine("Opening " + indName + "...");
            
            // Get main menu bar.
            long hMenu = GetMenu(m_hwndMT5);
            if (hMenu == 0)
            {
                AddLine("Failed to get menu bar.");
                return;
            }
            
            // Find Insert menu (search by name).
            int menuCount = GetMenuItemCount(hMenu);
            long hInsertMenu = 0;
            
            for (int i = 0; i < menuCount; i++)
            {
                ushort menuText[64];
                ArrayInitialize(menuText, 0);
                GetMenuStringW(hMenu, i, menuText, 64, MF_BYPOSITION);
                string menuName = ShortArrayToString(menuText);
                
                // Look for Insert menu (may have & for accelerator).
                if (StringFind(menuName, "Insert") >= 0 || StringFind(menuName, "nsert") >= 0)
                {
                    hInsertMenu = GetSubMenu(hMenu, i);
                    break;
                }
            }
            
            if (hInsertMenu == 0)
            {
                AddLine("Insert menu not found");
                return;
            }
            
            // Find Indicators submenu in Insert menu.
            long hIndicatorsMenu = 0;
            int insertCount = GetMenuItemCount(hInsertMenu);
            
            for (int i = 0; i < insertCount; i++)
            {
                ushort menuText[64];
                ArrayInitialize(menuText, 0);
                GetMenuStringW(hInsertMenu, i, menuText, 64, MF_BYPOSITION);
                string menuName = ShortArrayToString(menuText);
                
                if (StringFind(menuName, "Indicator") >= 0)
                {
                    hIndicatorsMenu = GetSubMenu(hInsertMenu, i);
                    break;
                }
            }
            
            if (hIndicatorsMenu == 0)
            {
                AddLine("Indicators submenu not found");
                return;
            }
            
            // Find category submenu (Trend, Oscillators, Volumes, Bill Williams).
            long hCategoryMenu = 0;
            int indCount = GetMenuItemCount(hIndicatorsMenu);
            
            for (int i = 0; i < indCount; i++)
            {
                ushort menuText[64];
                ArrayInitialize(menuText, 0);
                GetMenuStringW(hIndicatorsMenu, i, menuText, 64, MF_BYPOSITION);
                string menuName = ShortArrayToString(menuText);
                
                if (StringFind(menuName, category) >= 0)
                {
                    hCategoryMenu = GetSubMenu(hIndicatorsMenu, i);
                    break;
                }
            }
            
            if (hCategoryMenu == 0)
            {
                AddLine("Category '" + category + "' not found");
                return;
            }
            
            // Find the indicator in category menu.
            uint cmdId = 0;
            int catCount = GetMenuItemCount(hCategoryMenu);
            
            for (int i = 0; i < catCount; i++)
            {
                ushort menuText[128];
                ArrayInitialize(menuText, 0);
                GetMenuStringW(hCategoryMenu, i, menuText, 128, MF_BYPOSITION);
                string menuName = ShortArrayToString(menuText);
                
                // Match by finding the indicator name in menu item.
                if (StringFind(menuName, indName) >= 0)
                {
                    cmdId = GetMenuItemID(hCategoryMenu, i);
                    break;
                }
            }
            
            if (cmdId == 0 || cmdId == 0xFFFFFFFF)
            {
                AddLine("Indicator '" + indName + "' not found in menu.");
                return;
            }
            
            // Send command to open indicator dialog.
            PostMessageW(m_hwndMT5, WM_COMMAND, (int)cmdId, 0);
            AddLine("Dialog opened for " + indName + ".");
        }
    }
    else if (command == "remove" || StringFind(command, "remove ") == 0)
    {
        // Remove indicator(s) from chart.
        string indArg = "";
        if (StringFind(command, "remove ") == 0)
        {
            indArg = StringSubstr(cmd, 7);
            StringTrimLeft(indArg);
            StringTrimRight(indArg);
        }
        
        if (StringLen(indArg) == 0)
        {
            AddLine("Usage: remove <name|all>");
            AddLine("Removes indicator(s) from current chart.");
            AddLine("Examples:");
            AddLine("  remove all     - Remove all indicators");
            AddLine("  remove ma      - Remove Moving Average");
            AddLine("  remove bb      - Remove Bollinger Bands");
            AddLine("  remove rsi     - Remove RSI");
            AddLine("  remove psar    - Remove Parabolic SAR");
        }
        else
        {
            string argLower = indArg;
            StringToLower(argLower);
            
            // Translate nicknames to MT5 indicator short names.
            // Multiple patterns can be specified, separated by |
            string searchPatterns[];
            int patternCount = 0;
            
            if (argLower == "ma" || argLower == "ema" || argLower == "sma" || argLower == "movingaverage")
            {
                ArrayResize(searchPatterns, 2);
                searchPatterns[0] = "ma";      // Short name.
                searchPatterns[1] = "moving";  // Part of full name.
                patternCount = 2;
            }
            else if (argLower == "bb" || argLower == "bollinger" || argLower == "bands")
            {
                ArrayResize(searchPatterns, 2);
                searchPatterns[0] = "bands";
                searchPatterns[1] = "bollinger";
                patternCount = 2;
            }
            else if (argLower == "psar" || argLower == "sar" || argLower == "parabolic")
            {
                ArrayResize(searchPatterns, 2);
                searchPatterns[0] = "sar";
                searchPatterns[1] = "parabolic";
                patternCount = 2;
            }
            else if (argLower == "stoch" || argLower == "stochastic")
            {
                ArrayResize(searchPatterns, 1);
                searchPatterns[0] = "stoch";
                patternCount = 1;
            }
            else if (argLower == "ich" || argLower == "ichimoku")
            {
                ArrayResize(searchPatterns, 1);
                searchPatterns[0] = "ichimoku";
                patternCount = 1;
            }
            else if (argLower == "vol" || argLower == "volumes" || argLower == "volume")
            {
                ArrayResize(searchPatterns, 1);
                searchPatterns[0] = "volume";
                patternCount = 1;
            }
            else if (argLower == "mom" || argLower == "momentum")
            {
                ArrayResize(searchPatterns, 1);
                searchPatterns[0] = "momentum";
                patternCount = 1;
            }
            else if (argLower == "env" || argLower == "envelopes")
            {
                ArrayResize(searchPatterns, 1);
                searchPatterns[0] = "envelope";
                patternCount = 1;
            }
            else if (argLower == "wpr" || argLower == "williams")
            {
                ArrayResize(searchPatterns, 2);
                searchPatterns[0] = "wpr";
                searchPatterns[1] = "williams";
                patternCount = 2;
            }
            else if (argLower == "dem" || argLower == "demarker")
            {
                ArrayResize(searchPatterns, 1);
                searchPatterns[0] = "demarker";
                patternCount = 1;
            }
            else if (argLower == "fi" || argLower == "force")
            {
                ArrayResize(searchPatterns, 1);
                searchPatterns[0] = "force";
                patternCount = 1;
            }
            else if (argLower == "ao" || argLower == "awesome")
            {
                ArrayResize(searchPatterns, 2);
                searchPatterns[0] = "ao";
                searchPatterns[1] = "awesome";
                patternCount = 2;
            }
            else if (argLower == "ac" || argLower == "accelerator")
            {
                ArrayResize(searchPatterns, 2);
                searchPatterns[0] = "ac";
                searchPatterns[1] = "accelerator";
                patternCount = 2;
            }
            else if (argLower == "std" || argLower == "stddev")
            {
                ArrayResize(searchPatterns, 2);
                searchPatterns[0] = "stddev";
                searchPatterns[1] = "deviation";
                patternCount = 2;
            }
            else if (argLower == "bears" || argLower == "bearpower")
            {
                ArrayResize(searchPatterns, 1);
                searchPatterns[0] = "bears";
                patternCount = 1;
            }
            else if (argLower == "bulls" || argLower == "bullpower")
            {
                ArrayResize(searchPatterns, 1);
                searchPatterns[0] = "bulls";
                patternCount = 1;
            }
            else if (argLower == "atr")
            {
                ArrayResize(searchPatterns, 1);
                searchPatterns[0] = "atr";
                patternCount = 1;
            }
            else if (argLower == "adx")
            {
                ArrayResize(searchPatterns, 1);
                searchPatterns[0] = "adx";
                patternCount = 1;
            }
            else if (argLower == "cci")
            {
                ArrayResize(searchPatterns, 1);
                searchPatterns[0] = "cci";
                patternCount = 1;
            }
            else if (argLower == "rsi")
            {
                ArrayResize(searchPatterns, 1);
                searchPatterns[0] = "rsi";
                patternCount = 1;
            }
            else if (argLower == "macd")
            {
                ArrayResize(searchPatterns, 1);
                searchPatterns[0] = "macd";
                patternCount = 1;
            }
            else if (argLower == "obv")
            {
                ArrayResize(searchPatterns, 1);
                searchPatterns[0] = "obv";
                patternCount = 1;
            }
            else if (argLower == "mfi")
            {
                ArrayResize(searchPatterns, 1);
                searchPatterns[0] = "mfi";
                patternCount = 1;
            }
            else if (argLower == "gator")
            {
                ArrayResize(searchPatterns, 1);
                searchPatterns[0] = "gator";
                patternCount = 1;
            }
            else if (argLower == "alligator")
            {
                ArrayResize(searchPatterns, 1);
                searchPatterns[0] = "alligator";
                patternCount = 1;
            }
            else if (argLower == "fractals")
            {
                ArrayResize(searchPatterns, 1);
                searchPatterns[0] = "fractals";
                patternCount = 1;
            }
            else
            {
                // Use the argument as-is for direct matching.
                ArrayResize(searchPatterns, 1);
                searchPatterns[0] = argLower;
                patternCount = 1;
            }
            
            int totalWindows = (int)ChartGetInteger(m_currentChartId, CHART_WINDOWS_TOTAL);
            int removedCount = 0;
            
            if (argLower == "all")
            {
                // Remove all indicators from all windows.
                AddLine("Removing all indicators...");
                
                // Go through windows in reverse order (subwindows disappear when empty).
                for (int w = totalWindows - 1; w >= 0; w--)
                {
                    int indCount = ChartIndicatorsTotal(m_currentChartId, w);
                    
                    // Remove in reverse order.
                    for (int i = indCount - 1; i >= 0; i--)
                    {
                        string indName = ChartIndicatorName(m_currentChartId, w, i);
                        if (ChartIndicatorDelete(m_currentChartId, w, indName))
                        {
                            AddLine("  Removed: " + indName + ".");
                            removedCount++;
                        }
                    }
                }
            }
            else
            {
                // Remove indicators matching any of the patterns.
                AddLine("Removing indicators matching '" + indArg + "'...");
                
                // Go through windows in reverse order.
                for (int w = totalWindows - 1; w >= 0; w--)
                {
                    int indCount = ChartIndicatorsTotal(m_currentChartId, w);
                    
                    // Remove in reverse order.
                    for (int i = indCount - 1; i >= 0; i--)
                    {
                        string indName = ChartIndicatorName(m_currentChartId, w, i);
                        string indNameLower = indName;
                        StringToLower(indNameLower);
                        
                        // Check if indicator name contains any of the search patterns.
                        bool matches = false;
                        for (int p = 0; p < patternCount; p++)
                        {
                            if (StringFind(indNameLower, searchPatterns[p]) >= 0)
                            {
                                matches = true;
                                break;
                            }
                        }
                        
                        if (matches)
                        {
                            if (ChartIndicatorDelete(m_currentChartId, w, indName))
                            {
                                AddLine("  Removed: " + indName + ".");
                                removedCount++;
                            }
                        }
                    }
                }
            }
            
            if (removedCount == 0)
            {
                AddLine("No indicators found" + (argLower != "all" ? " matching '" + indArg + "'" : ""));
            }
            else
            {
                AddLine("Removed " + IntegerToString(removedCount) + " indicator" + (removedCount > 1 ? "s" : "") + ".");
                ChartRedraw(m_currentChartId);
            }
        }
    }
    else if (command == "indicators" || command == "ind")
    {
        // List all indicators on current chart.
        if (m_currentChartId <= 0)
        {
            AddLine("No active chart.");
            return;
        }
        
        int totalWindows = (int)ChartGetInteger(m_currentChartId, CHART_WINDOWS_TOTAL);
        int totalIndicators = 0;
        
        string sym = ChartSymbol(m_currentChartId);
        ENUM_TIMEFRAMES tf = (ENUM_TIMEFRAMES)ChartPeriod(m_currentChartId);
        AddLine("Indicators on " + sym + " " + EnumToString(tf) + ":");
        AddLine("");
        
        for (int w = 0; w < totalWindows; w++)
        {
            int indCount = ChartIndicatorsTotal(m_currentChartId, w);
            
            if (indCount > 0)
            {
                string windowName = (w == 0) ? "Main window" : "Subwindow " + IntegerToString(w);
                AddLine("[" + windowName + "]");
                
                for (int i = 0; i < indCount; i++)
                {
                    string indName = ChartIndicatorName(m_currentChartId, w, i);
                    AddLine("  " + IntegerToString(i + 1) + ". " + indName);
                    totalIndicators++;
                }
            }
        }
        
        if (totalIndicators == 0)
        {
            AddLine("  (none)");
        }
        else
        {
            AddLine("");
            AddLine("Total: " + IntegerToString(totalIndicators) + " indicator" + (totalIndicators > 1 ? "s" : "") + ".");
        }
    }
    else if (command == "screenshot" || StringFind(command, "screenshot ") == 0 || 
              command == "snap" || StringFind(command, "snap ") == 0)
    {
        // Take screenshot of current chart.
        if (m_currentChartId <= 0)
        {
            AddLine("No active chart.");
            return;
        }
        
        // Default dimensions (0 means use chart size).
        int width = 0;
        int height = 0;
        
        // Parse arguments.
        string args = "";
        if (StringFind(command, "screenshot ") == 0)
            args = StringSubstr(cmd, 11);
        else if (StringFind(command, "snap ") == 0)
            args = StringSubstr(cmd, 5);
        
        StringTrimLeft(args);
        StringTrimRight(args);
        
        if (StringLen(args) > 0)
        {
            // Check for WxH format (e.g., 1200x600)
            int xPos = StringFind(args, "x");
            if (xPos > 0)
            {
                width = (int)StringToInteger(StringSubstr(args, 0, xPos));
                height = (int)StringToInteger(StringSubstr(args, xPos + 1));
            }
            else
            {
                // Check for "W H" format (e.g., 1200 600)
                int spacePos = StringFind(args, " ");
                if (spacePos > 0)
                {
                    width = (int)StringToInteger(StringSubstr(args, 0, spacePos));
                    height = (int)StringToInteger(StringSubstr(args, spacePos + 1));
                }
                else
                {
                    // Single number - use as width, calculate height (16:9 ratio).
                    width = (int)StringToInteger(args);
                    if (width > 0)
                        height = (int)(width * 9 / 16);
                }
            }
        }
        
        // If dimensions not specified, use chart dimensions.
        if (width <= 0 || height <= 0)
        {
            width = (int)ChartGetInteger(m_currentChartId, CHART_WIDTH_IN_PIXELS);
            height = (int)ChartGetInteger(m_currentChartId, CHART_HEIGHT_IN_PIXELS);
        }
        
        // Generate filename with timestamp.
        string sym = ChartSymbol(m_currentChartId);
        ENUM_TIMEFRAMES tf = (ENUM_TIMEFRAMES)ChartPeriod(m_currentChartId);
        string tfStr = EnumToString(tf);
        StringReplace(tfStr, "PERIOD_", "");
        
        datetime now = TimeCurrent();
        string timestamp = TimeToString(now, TIME_DATE | TIME_SECONDS);
        StringReplace(timestamp, ".", "");
        StringReplace(timestamp, ":", "");
        StringReplace(timestamp, " ", "_");
        
        string filename = sym + "_" + tfStr + "_" + timestamp + ".png";
        
        // Take screenshot.
        if (ChartScreenShot(m_currentChartId, filename, width, height, ALIGN_RIGHT))
        {
            AddLine("Screenshot saved: " + filename);
            AddLine("Size: " + IntegerToString(width) + "x" + IntegerToString(height));
            AddLine("Location: MQL5\\Files\\");
        }
        else
        {
            AddLine("Failed to take screenshot (error " + IntegerToString(GetLastError()) + ").");
        }
    }
    else if (command == "line" || StringFind(command, "line ") == 0)
    {
        // Add horizontal line at specified price.
        if (m_currentChartId <= 0)
        {
            AddLine("No active chart.");
            return;
        }
        
        string args = "";
        if (StringFind(command, "line ") == 0)
        {
            args = StringSubstr(cmd, 5);
            StringTrimLeft(args);
            StringTrimRight(args);
        }
        
        if (StringLen(args) == 0)
        {
            AddLine("Usage: line <price> [color]");
            AddLine("Examples:");
            AddLine("  line 1.2345       - Add line at price");
            AddLine("  line 1.2345 red   - Add red line");
            AddLine("  line bid          - Add line at current bid");
            AddLine("  line ask 0xFF8800 - Add orange line at ask");
            AddLine("Colors: red, green, blue, yellow, white, gray, orange,");
            AddLine("        cyan, magenta, gold, purple, or hex (0xRRGGBB)");
        }
        else
        {
            // Parse price and optional color.
            string priceStr = args;
            string colorStr = "";
            
            int spacePos = StringFind(args, " ");
            if (spacePos > 0)
            {
                priceStr = StringSubstr(args, 0, spacePos);
                colorStr = StringSubstr(args, spacePos + 1);
                StringTrimLeft(colorStr);
            }
            
            // Get price value.
            double price = 0;
            StringToLower(priceStr);
            
            string sym = ChartSymbol(m_currentChartId);
            
            if (priceStr == "bid")
                price = SymbolInfoDouble(sym, SYMBOL_BID);
            else if (priceStr == "ask")
                price = SymbolInfoDouble(sym, SYMBOL_ASK);
            else
                price = StringToDouble(priceStr);
            
            if (price <= 0)
            {
                AddLine("Invalid price: " + priceStr);
                return;
            }
            
            // Determine color using smart color parser.
            color lineColor = CustomStringToColor(colorStr, clrRed);
            
            // Generate unique object name.
            string objName = "HLine_" + TimeToString(TimeCurrent(), TIME_DATE | TIME_SECONDS);
            StringReplace(objName, ".", "");
            StringReplace(objName, ":", "");
            StringReplace(objName, " ", "_");
            objName += "_" + IntegerToString(MathRand() % 1000);
            
            // Create horizontal line.
            if (ObjectCreate(m_currentChartId, objName, OBJ_HLINE, 0, 0, price))
            {
                // Set line properties.
                ObjectSetInteger(m_currentChartId, objName, OBJPROP_COLOR, lineColor);
                ObjectSetInteger(m_currentChartId, objName, OBJPROP_STYLE, STYLE_SOLID);
                ObjectSetInteger(m_currentChartId, objName, OBJPROP_WIDTH, 1);
                ObjectSetInteger(m_currentChartId, objName, OBJPROP_BACK, false);
                ObjectSetInteger(m_currentChartId, objName, OBJPROP_SELECTABLE, true);
                ObjectSetInteger(m_currentChartId, objName, OBJPROP_SELECTED, true);
                
                // Format price display.
                int digits = (int)SymbolInfoInteger(sym, SYMBOL_DIGITS);
                
                AddLine("Line added at " + DoubleToString(price, digits));
                ChartRedraw(m_currentChartId);
                
                // Save undo info.
                m_lastUndoCommand = "line";
                m_lastUndoData = objName;
                m_lastUndoChartId = m_currentChartId;
            }
            else
            {
                AddLine("Failed to create line (error " + IntegerToString(GetLastError()) + ").");
            }
        }
    }
    else if (command == "swaps" || command == "swap")
    {
        // Show swap rates for current symbol.
        string sym = "";
        if (m_currentChartId > 0)
            sym = ChartSymbol(m_currentChartId);
        else
            sym = Symbol();
        
        double swapLong = SymbolInfoDouble(sym, SYMBOL_SWAP_LONG);
        double swapShort = SymbolInfoDouble(sym, SYMBOL_SWAP_SHORT);
        ENUM_SYMBOL_SWAP_MODE swapMode = (ENUM_SYMBOL_SWAP_MODE)SymbolInfoInteger(sym, SYMBOL_SWAP_MODE);
        
        // Get swap type description.
        string swapUnit = "";
        int decimals = 2;
        
        switch (swapMode)
        {
            case SYMBOL_SWAP_MODE_DISABLED:
                AddLine("Swaps disabled for " + sym);
                return;
            case SYMBOL_SWAP_MODE_POINTS:
                swapUnit = " points";
                decimals = 2;
                break;
            case SYMBOL_SWAP_MODE_CURRENCY_SYMBOL:
                swapUnit = " " + SymbolInfoString(sym, SYMBOL_CURRENCY_BASE);
                decimals = 2;
                break;
            case SYMBOL_SWAP_MODE_CURRENCY_MARGIN:
                swapUnit = " " + SymbolInfoString(sym, SYMBOL_CURRENCY_MARGIN);
                decimals = 2;
                break;
            case SYMBOL_SWAP_MODE_CURRENCY_DEPOSIT:
                swapUnit = " " + AccountInfoString(ACCOUNT_CURRENCY);
                decimals = 2;
                break;
            case SYMBOL_SWAP_MODE_INTEREST_CURRENT:
            case SYMBOL_SWAP_MODE_INTEREST_OPEN:
                swapUnit = "%";
                decimals = 3;
                break;
            case SYMBOL_SWAP_MODE_REOPEN_CURRENT:
            case SYMBOL_SWAP_MODE_REOPEN_BID:
                swapUnit = " (reopen)";
                decimals = 2;
                break;
            default:
                swapUnit = "";
                break;
        }
        
        // Format swap values with +/- sign.
        string longStr = (swapLong >= 0 ? "+" : "") + DoubleToString(swapLong, decimals) + swapUnit;
        string shortStr = (swapShort >= 0 ? "+" : "") + DoubleToString(swapShort, decimals) + swapUnit;
        
        AddLine("Swaps for " + sym + ":");
        AddLine("  Long:  " + longStr);
        AddLine("  Short: " + shortStr);
        
        // Show swap rollover day.
        ENUM_DAY_OF_WEEK swap3Day = (ENUM_DAY_OF_WEEK)SymbolInfoInteger(sym, SYMBOL_SWAP_ROLLOVER3DAYS);
        string dayName = "";
        switch (swap3Day)
        {
            case SUNDAY:    dayName = "Sunday"; break;
            case MONDAY:    dayName = "Monday"; break;
            case TUESDAY:   dayName = "Tuesday"; break;
            case WEDNESDAY: dayName = "Wednesday"; break;
            case THURSDAY:  dayName = "Thursday"; break;
            case FRIDAY:    dayName = "Friday"; break;
            case SATURDAY:  dayName = "Saturday"; break;
        }
        AddLine("  Triple swap: " + dayName);
    }
    else if (command == "ticksize" || StringFind(command, "ticksize ") == 0)
    {
        string sym = "";
        if (StringFind(command, "ticksize ") == 0)
        {
            sym = StringSubstr(cmd, 9);
            StringTrimLeft(sym);
            StringTrimRight(sym);
            StringToUpper(sym);
        }
        if (StringLen(sym) == 0)
        {
            if (m_currentChartId > 0)
                sym = ChartSymbol(m_currentChartId);
            else
                sym = Symbol();
        }
        double tickSize = SymbolInfoDouble(sym, SYMBOL_TRADE_TICK_SIZE);
        int digits = (int)SymbolInfoInteger(sym, SYMBOL_DIGITS);
        AddLine(sym + " tick size: " + DoubleToString(tickSize, digits));
    }
    else if (command == "tickvalue" || StringFind(command, "tickvalue ") == 0)
    {
        string sym = "";
        if (StringFind(command, "tickvalue ") == 0)
        {
            sym = StringSubstr(cmd, 10);
            StringTrimLeft(sym);
            StringTrimRight(sym);
            StringToUpper(sym);
        }
        if (StringLen(sym) == 0)
        {
            if (m_currentChartId > 0)
                sym = ChartSymbol(m_currentChartId);
            else
                sym = Symbol();
        }
        double tickValue = SymbolInfoDouble(sym, SYMBOL_TRADE_TICK_VALUE);
        string currency = AccountInfoString(ACCOUNT_CURRENCY);
        AddLine(sym + " tick value: " + DoubleToString(tickValue, 4) + " " + currency);
    }
    else if (command == "contract" || StringFind(command, "contract ") == 0)
    {
        string sym = "";
        if (StringFind(command, "contract ") == 0)
        {
            sym = StringSubstr(cmd, 9);
            StringTrimLeft(sym);
            StringTrimRight(sym);
            StringToUpper(sym);
        }
        if (StringLen(sym) == 0)
        {
            if (m_currentChartId > 0)
                sym = ChartSymbol(m_currentChartId);
            else
                sym = Symbol();
        }
        double contractSize = SymbolInfoDouble(sym, SYMBOL_TRADE_CONTRACT_SIZE);
        AddLine(sym + " contract size: " + DoubleToString(contractSize, 2));
    }
    else if (command == "calcmode" || StringFind(command, "calcmode ") == 0)
    {
        string sym = "";
        if (StringFind(command, "calcmode ") == 0)
        {
            sym = StringSubstr(cmd, 9);
            StringTrimLeft(sym);
            StringTrimRight(sym);
            StringToUpper(sym);
        }
        if (StringLen(sym) == 0)
        {
            if (m_currentChartId > 0)
                sym = ChartSymbol(m_currentChartId);
            else
                sym = Symbol();
        }
        ENUM_SYMBOL_CALC_MODE calcMode = (ENUM_SYMBOL_CALC_MODE)SymbolInfoInteger(sym, SYMBOL_TRADE_CALC_MODE);
        string modeName = "";
        switch (calcMode)
        {
            case SYMBOL_CALC_MODE_FOREX:         modeName = "Forex"; break;
            case SYMBOL_CALC_MODE_FOREX_NO_LEVERAGE: modeName = "Forex No Leverage"; break;
            case SYMBOL_CALC_MODE_FUTURES:       modeName = "Futures"; break;
            case SYMBOL_CALC_MODE_CFD:           modeName = "CFD"; break;
            case SYMBOL_CALC_MODE_CFDINDEX:      modeName = "CFD Index"; break;
            case SYMBOL_CALC_MODE_CFDLEVERAGE:   modeName = "CFD Leverage"; break;
            case SYMBOL_CALC_MODE_EXCH_STOCKS:   modeName = "Exchange Stocks"; break;
            case SYMBOL_CALC_MODE_EXCH_FUTURES:  modeName = "Exchange Futures"; break;
            case SYMBOL_CALC_MODE_EXCH_FUTURES_FORTS: modeName = "Exchange FORTS Futures"; break;
            case SYMBOL_CALC_MODE_EXCH_BONDS:    modeName = "Exchange Bonds"; break;
            case SYMBOL_CALC_MODE_EXCH_STOCKS_MOEX: modeName = "Exchange MOEX Stocks"; break;
            case SYMBOL_CALC_MODE_EXCH_BONDS_MOEX: modeName = "Exchange MOEX Bonds"; break;
            case SYMBOL_CALC_MODE_SERV_COLLATERAL: modeName = "Collateral"; break;
            default: modeName = "Unknown (" + IntegerToString((int)calcMode) + ")"; break;
        }
        AddLine(sym + " calc mode: " + modeName);
    }
    else if (command == "volmin" || command == "minvol" || 
              StringFind(command, "volmin ") == 0 || StringFind(command, "minvol ") == 0)
    {
        string sym = "";
        if (StringFind(command, "volmin ") == 0)
        {
            sym = StringSubstr(cmd, 7);
            StringTrimLeft(sym);
            StringTrimRight(sym);
            StringToUpper(sym);
        }
        else if (StringFind(command, "minvol ") == 0)
        {
            sym = StringSubstr(cmd, 7);
            StringTrimLeft(sym);
            StringTrimRight(sym);
            StringToUpper(sym);
        }
        if (StringLen(sym) == 0)
        {
            if (m_currentChartId > 0)
                sym = ChartSymbol(m_currentChartId);
            else
                sym = Symbol();
        }
        double volMin = SymbolInfoDouble(sym, SYMBOL_VOLUME_MIN);
        AddLine(sym + " min volume: " + DoubleToString(volMin, 2));
    }
    else if (command == "volmax" || command == "maxvol" ||
              StringFind(command, "volmax ") == 0 || StringFind(command, "maxvol ") == 0)
    {
        string sym = "";
        if (StringFind(command, "volmax ") == 0)
        {
            sym = StringSubstr(cmd, 7);
            StringTrimLeft(sym);
            StringTrimRight(sym);
            StringToUpper(sym);
        }
        else if (StringFind(command, "maxvol ") == 0)
        {
            sym = StringSubstr(cmd, 7);
            StringTrimLeft(sym);
            StringTrimRight(sym);
            StringToUpper(sym);
        }
        if (StringLen(sym) == 0)
        {
            if (m_currentChartId > 0)
                sym = ChartSymbol(m_currentChartId);
            else
                sym = Symbol();
        }
        double volMax = SymbolInfoDouble(sym, SYMBOL_VOLUME_MAX);
        AddLine(sym + " max volume: " + DoubleToString(volMax, 2));
    }
    else if (command == "volstep" || StringFind(command, "volstep ") == 0)
    {
        string sym = "";
        if (StringFind(command, "volstep ") == 0)
        {
            sym = StringSubstr(cmd, 8);
            StringTrimLeft(sym);
            StringTrimRight(sym);
            StringToUpper(sym);
        }
        if (StringLen(sym) == 0)
        {
            if (m_currentChartId > 0)
                sym = ChartSymbol(m_currentChartId);
            else
                sym = Symbol();
        }
        double volStep = SymbolInfoDouble(sym, SYMBOL_VOLUME_STEP);
        AddLine(sym + " volume step: " + DoubleToString(volStep, 2));
    }
    else if (command == "specification" || StringFind(command, "specification ") == 0 ||
              command == "spec" || StringFind(command, "spec ") == 0)
    {
        string sym = "";
        if (StringFind(command, "specification ") == 0)
        {
            sym = StringSubstr(cmd, 14);
            StringTrimLeft(sym);
            StringTrimRight(sym);
            StringToUpper(sym);
        }
        else if (StringFind(command, "spec ") == 0)
        {
            sym = StringSubstr(cmd, 5);
            StringTrimLeft(sym);
            StringTrimRight(sym);
            StringToUpper(sym);
        }
        if (StringLen(sym) == 0)
        {
            if (m_currentChartId > 0)
                sym = ChartSymbol(m_currentChartId);
            else
                sym = Symbol();
        }
        
        int digits = (int)SymbolInfoInteger(sym, SYMBOL_DIGITS);
        string currency = AccountInfoString(ACCOUNT_CURRENCY);
        
        AddLine("=== " + sym + " Specification ===");
        AddLine("Description: " + SymbolInfoString(sym, SYMBOL_DESCRIPTION));
        AddLine("Base currency: " + SymbolInfoString(sym, SYMBOL_CURRENCY_BASE));
        AddLine("Profit currency: " + SymbolInfoString(sym, SYMBOL_CURRENCY_PROFIT));
        AddLine("Margin currency: " + SymbolInfoString(sym, SYMBOL_CURRENCY_MARGIN));
        AddLine("Digits: " + IntegerToString(digits));
        AddLine("Point: " + DoubleToString(SymbolInfoDouble(sym, SYMBOL_POINT), digits));
        AddLine("Tick size: " + DoubleToString(SymbolInfoDouble(sym, SYMBOL_TRADE_TICK_SIZE), digits));
        AddLine("Tick value: " + DoubleToString(SymbolInfoDouble(sym, SYMBOL_TRADE_TICK_VALUE), 4) + " " + currency);
        AddLine("Contract size: " + DoubleToString(SymbolInfoDouble(sym, SYMBOL_TRADE_CONTRACT_SIZE), 2));
        
        // Calc mode.
        ENUM_SYMBOL_CALC_MODE calcMode = (ENUM_SYMBOL_CALC_MODE)SymbolInfoInteger(sym, SYMBOL_TRADE_CALC_MODE);
        string modeName = "";
        switch (calcMode)
        {
            case SYMBOL_CALC_MODE_FOREX:         modeName = "Forex"; break;
            case SYMBOL_CALC_MODE_FOREX_NO_LEVERAGE: modeName = "Forex No Leverage"; break;
            case SYMBOL_CALC_MODE_FUTURES:       modeName = "Futures"; break;
            case SYMBOL_CALC_MODE_CFD:           modeName = "CFD"; break;
            case SYMBOL_CALC_MODE_CFDINDEX:      modeName = "CFD Index"; break;
            case SYMBOL_CALC_MODE_CFDLEVERAGE:   modeName = "CFD Leverage"; break;
            case SYMBOL_CALC_MODE_EXCH_STOCKS:   modeName = "Exchange Stocks"; break;
            case SYMBOL_CALC_MODE_EXCH_FUTURES:  modeName = "Exchange Futures"; break;
            case SYMBOL_CALC_MODE_EXCH_FUTURES_FORTS: modeName = "Exchange FORTS Futures"; break;
            case SYMBOL_CALC_MODE_EXCH_BONDS:    modeName = "Exchange Bonds"; break;
            case SYMBOL_CALC_MODE_EXCH_STOCKS_MOEX: modeName = "Exchange MOEX Stocks"; break;
            case SYMBOL_CALC_MODE_EXCH_BONDS_MOEX: modeName = "Exchange MOEX Bonds"; break;
            case SYMBOL_CALC_MODE_SERV_COLLATERAL: modeName = "Collateral"; break;
            default: modeName = "Unknown (" + IntegerToString((int)calcMode) + ")"; break;
        }
        AddLine("Calc mode: " + modeName);
        
        AddLine("Min volume: " + DoubleToString(SymbolInfoDouble(sym, SYMBOL_VOLUME_MIN), 2));
        AddLine("Max volume: " + DoubleToString(SymbolInfoDouble(sym, SYMBOL_VOLUME_MAX), 2));
        AddLine("Volume step: " + DoubleToString(SymbolInfoDouble(sym, SYMBOL_VOLUME_STEP), 2));
        AddLine("Spread: " + IntegerToString(SymbolInfoInteger(sym, SYMBOL_SPREAD)) + (SymbolInfoInteger(sym, SYMBOL_SPREAD_FLOAT) ? " (float)" : " (fixed)"));
        AddLine("Stops level: " + IntegerToString(SymbolInfoInteger(sym, SYMBOL_TRADE_STOPS_LEVEL)) + " points");
        AddLine("Freeze level: " + IntegerToString(SymbolInfoInteger(sym, SYMBOL_TRADE_FREEZE_LEVEL)) + " points");
        
        // Trade mode.
        ENUM_SYMBOL_TRADE_MODE tradeMode = (ENUM_SYMBOL_TRADE_MODE)SymbolInfoInteger(sym, SYMBOL_TRADE_MODE);
        string tradeModeStr = "";
        switch (tradeMode)
        {
            case SYMBOL_TRADE_MODE_DISABLED:  tradeModeStr = "Disabled"; break;
            case SYMBOL_TRADE_MODE_LONGONLY:  tradeModeStr = "Long only"; break;
            case SYMBOL_TRADE_MODE_SHORTONLY: tradeModeStr = "Short only"; break;
            case SYMBOL_TRADE_MODE_CLOSEONLY: tradeModeStr = "Close only"; break;
            case SYMBOL_TRADE_MODE_FULL:      tradeModeStr = "Full access"; break;
            default: tradeModeStr = "Unknown"; break;
        }
        AddLine("Trade mode: " + tradeModeStr);
        
        // Execution mode.
        ENUM_SYMBOL_TRADE_EXECUTION execMode = (ENUM_SYMBOL_TRADE_EXECUTION)SymbolInfoInteger(sym, SYMBOL_TRADE_EXEMODE);
        string execModeStr = "";
        switch (execMode)
        {
            case SYMBOL_TRADE_EXECUTION_REQUEST:  execModeStr = "Request"; break;
            case SYMBOL_TRADE_EXECUTION_INSTANT:  execModeStr = "Instant"; break;
            case SYMBOL_TRADE_EXECUTION_MARKET:   execModeStr = "Market"; break;
            case SYMBOL_TRADE_EXECUTION_EXCHANGE: execModeStr = "Exchange"; break;
            default: execModeStr = "Unknown"; break;
        }
        AddLine("Execution: " + execModeStr);
    }
    else if (command == "range" || StringFind(command, "range ") == 0)
    {
        // Show high/low range for a period.
        if (m_currentChartId <= 0)
        {
            AddLine("No active chart");
            return;
        }
        
        string args = "";
        if (StringFind(command, "range ") == 0)
        {
            args = StringSubstr(cmd, 6);
            StringTrimLeft(args);
            StringTrimRight(args);
        }
        
        if (StringLen(args) == 0)
        {
            AddLine("Usage: range <period>");
            AddLine("Examples:");
            AddLine("  range 1 day     - Past 24 hours");
            AddLine("  range 3 days    - Past 3 days");
            AddLine("  range 1 week    - Past week");
            AddLine("  range 4 hours   - Past 4 hours");
            AddLine("  range 30 min    - Past 30 minutes");
            AddLine("  range today     - Today's range");
            AddLine("  range yesterday - Yesterday's range");
            return;
        }
        
        string sym = ChartSymbol(m_currentChartId);
        int digits = (int)SymbolInfoInteger(sym, SYMBOL_DIGITS);
        double point = SymbolInfoDouble(sym, SYMBOL_POINT);
        
        // Parse period.
        datetime startTime = 0;
        datetime endTime = TimeCurrent();
        string periodDesc = "";
        
        StringToLower(args);
        
        if (args == "today")
        {
            MqlDateTime dt;
            TimeToStruct(TimeCurrent(), dt);
            dt.hour = 0;
            dt.min = 0;
            dt.sec = 0;
            startTime = StructToTime(dt);
            periodDesc = "today";
        }
        else if (args == "yesterday")
        {
            MqlDateTime dt;
            TimeToStruct(TimeCurrent(), dt);
            dt.hour = 0;
            dt.min = 0;
            dt.sec = 0;
            endTime = StructToTime(dt);
            startTime = endTime - 86400;
            periodDesc = "yesterday";
        }
        else
        {
            // Parse "N unit" format.
            string parts[];
            int numParts = StringSplit(args, ' ', parts);
            
            int amount = 1;
            string unit = "";
            
            if (numParts >= 2)
            {
                amount = (int)StringToInteger(parts[0]);
                unit = parts[1];
            }
            else if (numParts == 1)
            {
                // Try to parse as single unit (e.g., "week")
                unit = parts[0];
                // Check if first char is digit.
                if (StringGetCharacter(parts[0], 0) >= '0' && StringGetCharacter(parts[0], 0) <= '9')
                {
                    // Extract number and unit from combined string (e.g., "3days")
                    int i = 0;
                    while (i < StringLen(parts[0]) && StringGetCharacter(parts[0], i) >= '0' && StringGetCharacter(parts[0], i) <= '9')
                        i++;
                    amount = (int)StringToInteger(StringSubstr(parts[0], 0, i));
                    unit = StringSubstr(parts[0], i);
                }
            }
            
            if (amount <= 0) amount = 1;
            
            int seconds = 0;
            
            if (StringFind(unit, "min") >= 0 || unit == "m")
            {
                seconds = amount * 60;
                periodDesc = IntegerToString(amount) + " minute" + (amount > 1 ? "s" : "");
            }
            else if (StringFind(unit, "hour") >= 0 || unit == "h")
            {
                seconds = amount * 3600;
                periodDesc = IntegerToString(amount) + " hour" + (amount > 1 ? "s" : "");
            }
            else if (StringFind(unit, "day") >= 0 || unit == "d")
            {
                seconds = amount * 86400;
                periodDesc = IntegerToString(amount) + " day" + (amount > 1 ? "s" : "");
            }
            else if (StringFind(unit, "week") >= 0 || unit == "w")
            {
                seconds = amount * 604800;
                periodDesc = IntegerToString(amount) + " week" + (amount > 1 ? "s" : "");
            }
            else if (StringFind(unit, "month") >= 0)
            {
                seconds = amount * 2592000;  // 30 days
                periodDesc = IntegerToString(amount) + " month" + (amount > 1 ? "s" : "");
            }
            else
            {
                AddLine("Unknown period unit: " + unit);
                AddLine("Use: min, hour, day, week, month");
                return;
            }
            
            startTime = endTime - seconds;
        }
        
        // Choose appropriate timeframe for calculation based on period length.
        // This ensures accuracy even when chart TF is larger than requested period.
        ENUM_TIMEFRAMES calcTf;
        int periodSeconds = (int)(endTime - startTime);
        
        if (periodSeconds <= 3600)              // <= 1 hour: use M1
            calcTf = PERIOD_M1;
        else if (periodSeconds <= 28800)        // <= 8 hours: use M5
            calcTf = PERIOD_M5;
        else if (periodSeconds <= 259200)       // <= 3 days: use M15
            calcTf = PERIOD_M15;
        else if (periodSeconds <= 604800)       // <= 1 week: use H1
            calcTf = PERIOD_H1;
        else                                   // > 1 week: use H4
            calcTf = PERIOD_H4;
        
        // Get bars in the range using calculated timeframe.
        int startBar = iBarShift(sym, calcTf, startTime, false);
        int endBar = iBarShift(sym, calcTf, endTime, false);
        
        if (startBar < 0) startBar = Bars(sym, calcTf) - 1;
        if (endBar < 0) endBar = 0;
        
        // Validate that we have bars within the requested period.
        // iBarShift with exact=false returns nearest bar even if outside range
        datetime startBarTime = iTime(sym, calcTf, startBar);
        datetime endBarTime = iTime(sym, calcTf, endBar);
        
        // Check if bars actually fall within the requested period.
        // For "yesterday" on weekend: startBarTime might be Friday, which is < startTime.
        // We need at least one bar that starts within [startTime, endTime]
        bool hasValidBars = false;
        
        // Check if end bar is within range (most recent bar in period).
        if (endBarTime >= startTime && endBarTime <= endTime)
            hasValidBars = true;
        // Check if start bar is within range  
        else if (startBarTime >= startTime && startBarTime <= endTime)
            hasValidBars = true;
        // Check if there's any bar between them that's in range.
        else if (startBar > endBar)
        {
            for (int i = endBar; i <= startBar; i++)
            {
                datetime barTime = iTime(sym, calcTf, i);
                if (barTime >= startTime && barTime <= endTime)
                {
                    hasValidBars = true;
                    break;
                }
            }
        }
        
        if (!hasValidBars)
        {
            AddLine("No trading data for " + periodDesc + ".");
            AddLine("(Weekend or holiday - no bars in this period.)");
            return;
        }
        
        // Adjust startBar and endBar to only include bars within the period.
        // Find the actual first bar within the period.
        while (endBar <= startBar && iTime(sym, calcTf, endBar) > endTime)
            endBar++;
        while (startBar >= endBar && iTime(sym, calcTf, startBar) < startTime)
            startBar--;
        
        if (startBar < endBar)
        {
            AddLine("No trading data for " + periodDesc + ".");
            return;
        }
        
        // Find high and low in range.
        int highBar = iHighest(sym, calcTf, MODE_HIGH, startBar - endBar + 1, endBar);
        int lowBar = iLowest(sym, calcTf, MODE_LOW, startBar - endBar + 1, endBar);
        
        if (highBar < 0 || lowBar < 0)
        {
            AddLine("Not enough data for range calculation.");
            return;
        }
        
        double high = iHigh(sym, calcTf, highBar);
        double low = iLow(sym, calcTf, lowBar);
        double rangePoints = (high - low) / point;
        
        AddLine("Range for " + sym + " (" + periodDesc + "):");
        AddLine("  High:  " + DoubleToString(high, digits));
        AddLine("  Low:   " + DoubleToString(low, digits));
        AddLine("  Range: " + IntegerToString((int)MathRound(rangePoints)) + " points");
    }
    else if (command == "undo")
    {
        // Undo the last undoable command.
        if (StringLen(m_lastUndoCommand) == 0)
        {
            AddLine("Previous command cannot be undone.");
            return;
        }
        
        bool undone = false;
        
        if (m_lastUndoCommand == "line")
        {
            // Undo line creation - delete the object.
            if (ObjectFind(m_lastUndoChartId, m_lastUndoData) >= 0)
            {
                if (ObjectDelete(m_lastUndoChartId, m_lastUndoData))
                {
                    AddLine("Undone: removed line.");
                    ChartRedraw(m_lastUndoChartId);
                    undone = true;
                }
                else
                {
                    AddLine("Failed to remove line.");
                }
            }
            else
            {
                AddLine("Line no longer exists (already deleted?)");
            }
        }
        else if (m_lastUndoCommand == "add")
        {
            // Undo indicator addition - parse indicator name and window.
            int sepPos = StringFind(m_lastUndoData, "|");
            if (sepPos > 0)
            {
                string indName = StringSubstr(m_lastUndoData, 0, sepPos);
                int windowNum = (int)StringToInteger(StringSubstr(m_lastUndoData, sepPos + 1));
                
                if (ChartIndicatorDelete(m_lastUndoChartId, windowNum, indName))
                {
                    AddLine("Undone: removed " + indName + ".");
                    ChartRedraw(m_lastUndoChartId);
                    undone = true;
                }
                else
                {
                    AddLine("Failed to remove indicator (may have been deleted already).");
                }
            }
            else
            {
                AddLine("Invalid undo data for indicator.");
            }
        }
        else if (m_lastUndoCommand == "chart")
        {
            // Undo chart opening - close the chart.
            long chartId = (long)StringToInteger(m_lastUndoData);
            if (chartId > 0)
            {
                if (ChartClose(chartId))
                {
                    AddLine("Undone: closed chart.");
                    undone = true;
                }
                else
                {
                    AddLine("Failed to close chart.");
                }
            }
        }
        else if (m_lastUndoCommand == "tf")
        {
            // Undo timeframe change - restore previous timeframe.
            ENUM_TIMEFRAMES oldTf = (ENUM_TIMEFRAMES)StringToInteger(m_lastUndoData);
            if (m_lastUndoChartId > 0 && oldTf != PERIOD_CURRENT)
            {
                if (ChartSetSymbolPeriod(m_lastUndoChartId, ChartSymbol(m_lastUndoChartId), oldTf))
                {
                    string tfStr = EnumToString(oldTf);
                    StringReplace(tfStr, "PERIOD_", "");
                    AddLine("Undone: timeframe restored to " + tfStr + ".");
                    undone = true;
                }
                else
                {
                    AddLine("Failed to restore timeframe.");
                }
            }
        }
        else if (m_lastUndoCommand == "auto")
        {
            // Undo autotrading toggle - toggle it back.
            // m_lastUndoData contains what state it was before ("on" or "off")
            bool currentState = (bool)TerminalInfoInteger(TERMINAL_TRADE_ALLOWED);
            bool targetState = (m_lastUndoData == "on");
            
            if (currentState != targetState)
            {
                // Need to toggle.
                SetForegroundWindow(m_hwndMT5);
                Sleep(50);
                
                keybd_event((uchar)VK_CONTROL, 0, 0, 0);
                keybd_event((uchar)VK_E, 0, 0, 0);
                keybd_event((uchar)VK_E, 0, KEYEVENTF_KEYUP, 0);
                keybd_event((uchar)VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
                
                Sleep(100);
                SetForegroundWindow(m_hwnd);
                
                bool newState = (bool)TerminalInfoInteger(TERMINAL_TRADE_ALLOWED);
                AddLine("Undone: autotrading " + (newState ? "ENABLED" : "DISABLED"));
                undone = true;
            }
            else
            {
                AddLine("Autotrading already in previous state.");
                undone = true;  // Consider it done.
            }
        }
        else if (m_lastUndoCommand == "symbol")
        {
            // Undo symbol change.
            long chartId = m_lastUndoChartId;
            if (chartId > 0 && ChartSymbol(chartId) != "")
            {
                string currentSymbol = ChartSymbol(chartId);
                if (ChartSetSymbolPeriod(chartId, m_lastUndoData, ChartPeriod(chartId)))
                {
                    AddLine("Undone: " + currentSymbol + " -> " + m_lastUndoData);
                    undone = true;
                }
                else
                {
                    AddLine("Failed to restore symbol.");
                }
            }
        }
        
        // Clear undo info after attempting.
        if (undone)
        {
            m_lastUndoCommand = "";
            m_lastUndoData = "";
            m_lastUndoChartId = 0;
        }
    }
    else if (command == "install" || StringFind(command, "install ") == 0)
    {
        // Install MQL5 program from URL
        string url = "";
        if (StringFind(command, "install ") == 0)
        {
            url = StringSubstr(cmd, 8);  // After "install "
            StringTrimLeft(url);
            StringTrimRight(url);
        }
        
        if (StringLen(url) == 0)
        {
            AddLine("Usage: install <url>");
            AddLine("Example: install https://www.earnforex.com/...");
            AddLine("");
            AddLine("Downloads and installs MQL5 programs.");
            AddLine("Supports direct .mq5/.ex5/.zip links");
            AddLine("or earnforex.com pages.");
        }
        else
        {
            // Start installation process.
            InstallFromURL(url);
        }
    }
    else if (command == "clip")
    {
        // Show clipboard contents.
        if (OpenClipboard(0))
        {
            long hData = GetClipboardData(CF_UNICODETEXT);
            if (hData != 0)
            {
                long pData = GlobalLock(hData);
                if (pData != 0)
                {
                    string text = lstrcatW(pData, "");
                    GlobalUnlock(hData);
                    if (StringLen(text) > 100)
                        text = StringSubstr(text, 0, 100) + "...";
                    AddLine("Clipboard: " + text);
                }
            }
            else
            {
                AddLine("Clipboard: (empty or not text)");
            }
            CloseClipboard();
        }
        else
        {
            AddLine("Failed to open clipboard.");
        }
    }
    else if (command == "balance" || command == "bal")
    {
        double balance = AccountInfoDouble(ACCOUNT_BALANCE);
        AddLine("Balance: " + FormatMoney(balance));
    }
    else if (command == "equity" || command == "eq")
    {
        double equity = AccountInfoDouble(ACCOUNT_EQUITY);
        double balance = AccountInfoDouble(ACCOUNT_BALANCE);
        double pl = equity - balance;
        AddLine("Equity: " + FormatMoney(equity) + " (" + FormatMoney(pl, true) + ")");
    }
    else if (command == "margin" || command == "freemargin" || command == "fm")
    {
        double freeMargin = AccountInfoDouble(ACCOUNT_MARGIN_FREE);
        double marginLevel = AccountInfoDouble(ACCOUNT_MARGIN_LEVEL);
        AddLine("Free Margin: " + FormatMoney(freeMargin));
        if (marginLevel > 0)
            AddLine("Margin Level: " + DoubleToString(marginLevel, 2) + "%");
    }
    else if (command == "credit")
    {
        double credit = AccountInfoDouble(ACCOUNT_CREDIT);
        if (credit > 0)
            AddLine("Credit: " + FormatMoney(credit));
        else
            AddLine("No credit on account");
    }
    else if (command == "cmdhist" || command == "cmdhistory") // ⌘
    {
        // Command history.
        for (int i = 0; i < ArraySize(m_commandHistory); i++)
        {
            AddLine("  " + IntegerToString(i+1) + ": " + m_commandHistory[i]);
        }
    }
    else if (command == "history" || StringFind(command, "history ") == 0)
    {
        // Trade history commands.
        string args = "";
        if (StringLen(cmd) > 8)
        {
            args = StringSubstr(cmd, 8);
            StringTrimLeft(args);
            StringTrimRight(args);
        }
        
        string parts[];
        int partCount = StringSplit(args, ' ', parts);
        
        string histType = "positions";  // Default type.
        string modifier = "today";      // Default period.
        
        // Check if first argument is a type or a modifier.
        if (partCount > 0 && StringLen(parts[0]) > 0)
        {
            string firstArg = parts[0];
            StringToLower(firstArg);
            
            if (firstArg == "deals" || firstArg == "orders" || firstArg == "positions" || firstArg == "pos")
            {
                histType = firstArg;
                if (histType == "pos") histType = "positions";
                modifier = (partCount > 1) ? parts[1] : "today";
            }
            else if (firstArg == "today" || firstArg == "week" || firstArg == "month" || 
                      firstArg == "prevweek" || firstArg == "prevmonth")
            {
                modifier = firstArg;
            }
            else
            {
                AddLine("Usage: history [type] [period]");
                AddLine("Types: deals, orders, positions (default)");
                AddLine("Periods: today (default), week, month, prevweek, prevmonth");
                AddLine("");
                AddLine("Examples:");
                AddLine("  history              - Today's closed positions");
                AddLine("  history week         - This week's closed positions");
                AddLine("  history deals        - Today's deals");
                AddLine("  history orders month - This month's orders");
                return;
            }
        }
        
        StringToLower(modifier);
        
        // Calculate time range based on modifier.
        datetime fromTime, toTime;
        MqlDateTime dt;
        TimeToStruct(TimeCurrent(), dt);
        
        if (modifier == "today" || modifier == "")
        {
            // Today: midnight to now.
            dt.hour = 0; dt.min = 0; dt.sec = 0;
            fromTime = StructToTime(dt);
            toTime = TimeCurrent();
            modifier = "today";
        }
        else if (modifier == "yesterday")
        {
            // Yesterday: previous day midnight to midnight.
            dt.hour = 0; dt.min = 0; dt.sec = 0;
            toTime = StructToTime(dt);  // Today midnight.
            fromTime = toTime - 86400;  // Yesterday midnight.
        }
        else if (modifier == "week")
        {
            // Current week (from Monday).
            dt.hour = 0; dt.min = 0; dt.sec = 0;
            int dayOfWeek = dt.day_of_week;
            if (dayOfWeek == 0) dayOfWeek = 7;  // Sunday = 7
            fromTime = StructToTime(dt) - (dayOfWeek - 1) * 86400;
            toTime = TimeCurrent();
        }
        else if (modifier == "month")
        {
            // Current month.
            dt.day = 1; dt.hour = 0; dt.min = 0; dt.sec = 0;
            fromTime = StructToTime(dt);
            toTime = TimeCurrent();
        }
        else if (modifier == "prevweek")
        {
            // Previous week.
            dt.hour = 0; dt.min = 0; dt.sec = 0;
            int dayOfWeek = dt.day_of_week;
            if (dayOfWeek == 0) dayOfWeek = 7;
            toTime = StructToTime(dt) - (dayOfWeek - 1) * 86400;  // Start of this week.
            fromTime = toTime - 7 * 86400;  // 7 days before
        }
        else if (modifier == "prevmonth")
        {
            // Previous month.
            dt.day = 1; dt.hour = 0; dt.min = 0; dt.sec = 0;
            toTime = StructToTime(dt);  // Start of this month.
            dt.mon--;
            if (dt.mon < 1) { dt.mon = 12; dt.year--; }
            fromTime = StructToTime(dt);
        }
        else
        {
            AddLine("Unknown modifier: " + modifier);
            AddLine("Use: today, yesterday, week, month, prevweek, prevmonth");
            return;
        }
        
        if (histType == "deals")
        {
            // History of deals.
            if (!HistorySelect(fromTime, toTime))
            {
                AddLine("Failed to select history.");
                return;
            }
            
            int total = HistoryDealsTotal();
            AddLine("=== Deals History (" + modifier + ": " + IntegerToString(total) + ") ===");
            
            if (total == 0)
            {
                AddLine("No deals found.");
            }
            else
            {
                double totalProfit = 0;
                int count = 0;
                
                for (int i = 0; i < total && count < 50; i++)
                {
                    ulong ticket = HistoryDealGetTicket(i);
                    if (ticket > 0)
                    {
                        string symbol = HistoryDealGetString(ticket, DEAL_SYMBOL);
                        double volume = HistoryDealGetDouble(ticket, DEAL_VOLUME);
                        double profit = HistoryDealGetDouble(ticket, DEAL_PROFIT);
                        double price = HistoryDealGetDouble(ticket, DEAL_PRICE);
                        ENUM_DEAL_TYPE type = (ENUM_DEAL_TYPE)HistoryDealGetInteger(ticket, DEAL_TYPE);
                        datetime time = (datetime)HistoryDealGetInteger(ticket, DEAL_TIME);
                        
                        if (symbol == "") continue;  // Skip balance operations.
                        
                        string typeStr;
                        if (type == DEAL_TYPE_BUY) typeStr = "Buy ";
                        else if (type == DEAL_TYPE_SELL) typeStr = "Sell";
                        else continue;
                        
                        int digits = (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS);
                        
                        string profitStr = "";
                        if (profit != 0)
                        {
                            profitStr = (profit >= 0) ? " +" : " ";
                            profitStr += DoubleToString(profit, 2);
                        }
                        
                        AddLine(TimeToString(time, TIME_DATE|TIME_MINUTES) + " " + typeStr + " " + 
                                  symbol + " " + DoubleToString(volume, 2) + " @ " + 
                                  DoubleToString(price, digits) + profitStr);
                        
                        totalProfit += profit;
                        count++;
                    }
                }
                
                if (count >= 50)
                    AddLine("... (showing first 50)");
                
                AddLine("");
                AddLine("Total P/L: " + FormatMoney(totalProfit, true));
            }
        }
        else if (histType == "orders")
        {
            // History of orders.
            if (!HistorySelect(fromTime, toTime))
            {
                AddLine("Failed to select history.");
                return;
            }
            
            int total = HistoryOrdersTotal();
            AddLine("=== Orders History (" + modifier + ": " + IntegerToString(total) + ") ===");
            
            if (total == 0)
            {
                AddLine("No orders found.");
            }
            else
            {
                int count = 0;
                for (int i = 0; i < total && count < 50; i++)
                {
                    ulong ticket = HistoryOrderGetTicket(i);
                    if (ticket > 0)
                    {
                        string symbol = HistoryOrderGetString(ticket, ORDER_SYMBOL);
                        double volume = HistoryOrderGetDouble(ticket, ORDER_VOLUME_INITIAL);
                        double price = HistoryOrderGetDouble(ticket, ORDER_PRICE_OPEN);
                        ENUM_ORDER_TYPE type = (ENUM_ORDER_TYPE)HistoryOrderGetInteger(ticket, ORDER_TYPE);
                        ENUM_ORDER_STATE state = (ENUM_ORDER_STATE)HistoryOrderGetInteger(ticket, ORDER_STATE);
                        datetime time = (datetime)HistoryOrderGetInteger(ticket, ORDER_TIME_SETUP);
                        
                        string typeStr;
                        switch (type)
                        {
                            case ORDER_TYPE_BUY: typeStr = "Buy"; break;
                            case ORDER_TYPE_SELL: typeStr = "Sell"; break;
                            case ORDER_TYPE_BUY_LIMIT: typeStr = "BuyLmt"; break;
                            case ORDER_TYPE_SELL_LIMIT: typeStr = "SellLmt"; break;
                            case ORDER_TYPE_BUY_STOP: typeStr = "BuyStp"; break;
                            case ORDER_TYPE_SELL_STOP: typeStr = "SellStp"; break;
                            default: typeStr = "Other"; break;
                        }
                        
                        string stateStr;
                        switch (state)
                        {
                            case ORDER_STATE_FILLED: stateStr = "Filled"; break;
                            case ORDER_STATE_CANCELED: stateStr = "Canceled"; break;
                            case ORDER_STATE_REJECTED: stateStr = "Rejected"; break;
                            case ORDER_STATE_EXPIRED: stateStr = "Expired"; break;
                            default: stateStr = "Other"; break;
                        }
                        
                        int digits = (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS);
                        
                        AddLine(TimeToString(time, TIME_DATE|TIME_MINUTES) + " " + typeStr + " " + 
                                  symbol + " " + DoubleToString(volume, 2) + " @ " + 
                                  DoubleToString(price, digits) + " [" + stateStr + "]");
                        
                        count++;
                    }
                }
                
                if (count >= 50)
                    AddLine("... (showing first 50)");
            }
        }
        else if (histType == "positions")
        {
            // History of positions (closed trades).
            if (!HistorySelect(fromTime, toTime))
            {
                AddLine("Failed to select history.");
                return;
            }
            
            int total = HistoryDealsTotal();
            AddLine("=== Positions History (" + modifier + ") ===");
            
            double totalProfit = 0;
            int closedCount = 0;
            
            for (int i = 0; i < total; i++)
            {
                ulong ticket = HistoryDealGetTicket(i);
                if (ticket > 0)
                {
                    ENUM_DEAL_ENTRY entry = (ENUM_DEAL_ENTRY)HistoryDealGetInteger(ticket, DEAL_ENTRY);
                    
                    // Only show exit deals (closed positions).
                    if (entry == DEAL_ENTRY_OUT || entry == DEAL_ENTRY_INOUT)
                    {
                        string symbol = HistoryDealGetString(ticket, DEAL_SYMBOL);
                        double volume = HistoryDealGetDouble(ticket, DEAL_VOLUME);
                        double profit = HistoryDealGetDouble(ticket, DEAL_PROFIT);
                        double price = HistoryDealGetDouble(ticket, DEAL_PRICE);
                        ENUM_DEAL_TYPE type = (ENUM_DEAL_TYPE)HistoryDealGetInteger(ticket, DEAL_TYPE);
                        datetime time = (datetime)HistoryDealGetInteger(ticket, DEAL_TIME);
                        
                        if (symbol == "") continue;
                        
                        // Exit type is opposite of position type.
                        string posType = (type == DEAL_TYPE_BUY) ? "Sell" : "Buy ";
                        
                        int digits = (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS);
                        
                        string profitStr = (profit >= 0) ? "+" : "";
                        profitStr += DoubleToString(profit, 2);
                        
                        AddLine(TimeToString(time, TIME_DATE|TIME_MINUTES) + " " + posType + " " + 
                                  symbol + " " + DoubleToString(volume, 2) + " @ " + 
                                  DoubleToString(price, digits) + " = " + profitStr);
                        
                        totalProfit += profit;
                        closedCount++;
                        
                        if (closedCount >= 50)
                        {
                            AddLine("... (showing first 50)");
                            break;
                        }
                    }
                }
            }
            
            if (closedCount == 0)
            {
                AddLine("No closed positions found.");
            }
            else
            {
                AddLine("");
                AddLine("Closed: " + IntegerToString(closedCount) + ", Total P/L: " + FormatMoney(totalProfit, true));
            }
        }
    }
    else if (command == "stats" || StringFind(command, "stats ") == 0)
    {
        // Trading statistics for a period.
        string args = "";
        if (StringLen(cmd) > 6)
        {
            args = StringSubstr(cmd, 6);
            StringTrimLeft(args);
            StringTrimRight(args);
        }
        
        // Parse arguments - can be: [period] [symbol] or byweekday [symbol]
        string parts[];
        StringSplit(args, ' ', parts);
        
        string modifier = "today";
        string symbolFilter = "";
        bool byWeekday = false;
        
        for (int p = 0; p < ArraySize(parts); p++)
        {
            string part = parts[p];
            string partLower = part;
            StringToLower(partLower);
            
            if (partLower == "byweekday" || partLower == "weekday")
                byWeekday = true;
            else if (partLower == "today" || partLower == "yesterday" || partLower == "week" ||
                      partLower == "month" || partLower == "prevweek" || partLower == "prevmonth" ||
                      partLower == "all")
                modifier = partLower;
            else if (StringLen(part) > 0)
            {
                symbolFilter = part;
                StringToUpper(symbolFilter);
            }
        }
        
        // Calculate time range based on modifier.
        datetime fromTime, toTime;
        MqlDateTime dt;
        TimeToStruct(TimeCurrent(), dt);
        
        string periodName = "";
        string monthNames[] = {"", "January", "February", "March", "April", "May", "June",
                                      "July", "August", "September", "October", "November", "December"};
        
        if (byWeekday || modifier == "all")
        {
            fromTime = 0;
            toTime = TimeCurrent();
            periodName = "All History";
        }
        else if (modifier == "today" || modifier == "")
        {
            dt.hour = 0; dt.min = 0; dt.sec = 0;
            fromTime = StructToTime(dt);
            toTime = TimeCurrent();
            periodName = "Today";
        }
        else if (modifier == "yesterday")
        {
            dt.hour = 0; dt.min = 0; dt.sec = 0;
            toTime = StructToTime(dt);  // Today midnight.
            fromTime = toTime - 86400;  // Yesterday midnight.
            periodName = "Yesterday";
        }
        else if (modifier == "week")
        {
            dt.hour = 0; dt.min = 0; dt.sec = 0;
            int dayOfWeek = dt.day_of_week;
            if (dayOfWeek == 0) dayOfWeek = 7;
            fromTime = StructToTime(dt) - (dayOfWeek - 1) * 86400;
            toTime = TimeCurrent();
            periodName = "Current week";
        }
        else if (modifier == "month")
        {
            dt.day = 1; dt.hour = 0; dt.min = 0; dt.sec = 0;
            fromTime = StructToTime(dt);
            toTime = TimeCurrent();
            periodName = monthNames[dt.mon] + " " + IntegerToString(dt.year);
        }
        else if (modifier == "prevweek")
        {
            dt.hour = 0; dt.min = 0; dt.sec = 0;
            int dayOfWeek = dt.day_of_week;
            if (dayOfWeek == 0) dayOfWeek = 7;
            toTime = StructToTime(dt) - (dayOfWeek - 1) * 86400;
            fromTime = toTime - 7 * 86400;
            periodName = "Previous week";
        }
        else if (modifier == "prevmonth")
        {
            dt.day = 1; dt.hour = 0; dt.min = 0; dt.sec = 0;
            toTime = StructToTime(dt);
            dt.mon--;
            if (dt.mon < 1) { dt.mon = 12; dt.year--; }
            fromTime = StructToTime(dt);
            periodName = monthNames[dt.mon] + " " + IntegerToString(dt.year);
        }
        else
        {
            AddLine("Usage: stats [period] [symbol]");
            AddLine("       stats byweekday [symbol]");
            AddLine("Periods: today, yesterday, week, month, prevweek, prevmonth, all");
            return;
        }
        
        if (!HistorySelect(fromTime, toTime))
        {
            AddLine("Failed to select history.");
            return;
        }
        
        if (byWeekday)
        {
            // Calculate stats by day of week.
            string dayNames[] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
            double dayProfit[7];
            int dayTrades[7];
            int dayWins[7];
            ArrayInitialize(dayProfit, 0);
            ArrayInitialize(dayTrades, 0);
            ArrayInitialize(dayWins, 0);
            
            int dealCount = HistoryDealsTotal();
            
            for (int i = 0; i < dealCount; i++)
            {
                ulong ticket = HistoryDealGetTicket(i);
                if (ticket > 0)
                {
                    ENUM_DEAL_ENTRY entry = (ENUM_DEAL_ENTRY)HistoryDealGetInteger(ticket, DEAL_ENTRY);
                    
                    if (entry == DEAL_ENTRY_OUT || entry == DEAL_ENTRY_INOUT)
                    {
                        string symbol = HistoryDealGetString(ticket, DEAL_SYMBOL);
                        if (symbol == "") continue;
                        
                        if (StringLen(symbolFilter) > 0)
                        {
                            string symUpper = symbol;
                            StringToUpper(symUpper);
                            if (symUpper != symbolFilter) continue;
                        }
                        
                        datetime dealTime = (datetime)HistoryDealGetInteger(ticket, DEAL_TIME);
                        MqlDateTime dealDt;
                        TimeToStruct(dealTime, dealDt);
                        int dow = dealDt.day_of_week;
                        
                        double profit = HistoryDealGetDouble(ticket, DEAL_PROFIT);
                        double commission = HistoryDealGetDouble(ticket, DEAL_COMMISSION);
                        double swap = HistoryDealGetDouble(ticket, DEAL_SWAP);
                        
                        dayProfit[dow] += profit + commission + swap;
                        dayTrades[dow]++;
                        if (profit > 0) dayWins[dow]++;
                    }
                }
            }
            
            AddLine("=== Stats by Weekday" + (StringLen(symbolFilter) > 0 ? " (" + symbolFilter + ")" : "") + " ===");
            AddLine("");
            
            for (int d = 1; d <= 5; d++)  // Monday to Friday.
            {
                int dow = d;
                string profitStr = (dayProfit[dow] >= 0 ? "+" : "") + DoubleToString(dayProfit[dow], 2);
                double winRate = (dayTrades[dow] > 0) ? (double)dayWins[dow] / dayTrades[dow] * 100 : 0;
                AddLine(StringFormat("%-10s: %3d trades, %s, %.1f%% WR", 
                          dayNames[dow], dayTrades[dow], profitStr, winRate));
            }
            
            // Weekend if any.
            if (dayTrades[0] > 0 || dayTrades[6] > 0)
            {
                AddLine("");
                if (dayTrades[6] > 0)
                    AddLine("Saturday:   " + IntegerToString(dayTrades[6]) + " trades, " + DoubleToString(dayProfit[6], 2));
                if (dayTrades[0] > 0)
                    AddLine("Sunday:     " + IntegerToString(dayTrades[0]) + " trades, " + DoubleToString(dayProfit[0], 2));
            }
        }
        else
        {
            // Regular stats.
            int totalTrades = 0;
            int winningTrades = 0;
            int losingTrades = 0;
            double grossProfit = 0;
            double grossLoss = 0;
            double totalCommission = 0;
            double totalSwap = 0;
            
            int dealCount = HistoryDealsTotal();
            
            for (int i = 0; i < dealCount; i++)
            {
                ulong ticket = HistoryDealGetTicket(i);
                if (ticket > 0)
                {
                    ENUM_DEAL_ENTRY entry = (ENUM_DEAL_ENTRY)HistoryDealGetInteger(ticket, DEAL_ENTRY);
                    
                    // Only count exit deals (closed positions).
                    if (entry == DEAL_ENTRY_OUT || entry == DEAL_ENTRY_INOUT)
                    {
                        string symbol = HistoryDealGetString(ticket, DEAL_SYMBOL);
                        if (symbol == "") continue;  // Skip balance operations.
                        
                        // Apply symbol filter.
                        if (StringLen(symbolFilter) > 0)
                        {
                            string symUpper = symbol;
                            StringToUpper(symUpper);
                            if (symUpper != symbolFilter) continue;
                        }
                        
                        double profit = HistoryDealGetDouble(ticket, DEAL_PROFIT);
                        double commission = HistoryDealGetDouble(ticket, DEAL_COMMISSION);
                        double swap = HistoryDealGetDouble(ticket, DEAL_SWAP);
                        
                        totalTrades++;
                        totalCommission += commission;
                        totalSwap += swap;
                        
                        if (profit > 0)
                        {
                            winningTrades++;
                            grossProfit += profit;
                        }
                        else if (profit < 0)
                        {
                            losingTrades++;
                            grossLoss += MathAbs(profit);
                        }
                        // profit == 0 counts as neither win nor loss
                    }
                }
            }
            
            // Calculate derived statistics.
            double netProfit = grossProfit - grossLoss;
            double netProfitWithCosts = netProfit + totalCommission + totalSwap;
            double winRate = (totalTrades > 0) ? (double)winningTrades / totalTrades * 100.0 : 0;
            double profitFactor = (grossLoss > 0) ? grossProfit / grossLoss : (grossProfit > 0 ? 999.99 : 0);
            double expectancy = (totalTrades > 0) ? netProfitWithCosts / totalTrades : 0;
            double avgWin = (winningTrades > 0) ? grossProfit / winningTrades : 0;
            double avgLoss = (losingTrades > 0) ? grossLoss / losingTrades : 0;
            
            // Display results.
            string title = "=== Trading Stats (" + periodName + ")";
            if (StringLen(symbolFilter) > 0)
                title += " [" + symbolFilter + "]";
            title += " ===";
            AddLine(title);
            AddLine("Trades: " + IntegerToString(totalTrades) + 
                      " (W:" + IntegerToString(winningTrades) + 
                      " L:" + IntegerToString(losingTrades) + ")");
            AddLine("");
            AddLine("Gross Profit:  " + FormatMoney(grossProfit, true));
            AddLine("Gross Loss:    " + FormatMoney(-grossLoss, true));
            AddLine("Net Profit:    " + FormatMoney(netProfit, true));
            
            if (totalCommission != 0 || totalSwap != 0)
            {
                AddLine("");
                AddLine("Commission:    " + FormatMoney(totalCommission, true));
                AddLine("Swap:          " + FormatMoney(totalSwap, true));
                AddLine("Net (w/costs): " + FormatMoney(netProfitWithCosts, true));
            }
            
            AddLine("");
            AddLine("Win Rate:      " + DoubleToString(winRate, 1) + "%");
            AddLine("Profit Factor: " + (profitFactor >= 999 ? "inf" : DoubleToString(profitFactor, 2)));
            AddLine("Expectancy:    " + FormatMoney(expectancy, true));
            
            if (winningTrades > 0 || losingTrades > 0)
            {
                AddLine("");
                AddLine("Avg Win:       " + FormatMoney(avgWin, true));
                AddLine("Avg Loss:      " + FormatMoney(-avgLoss, true));
            }
        }
    }
    else if (command == "exit")
    {
        Hide();
    }
    else if (command == "debug")
    {
        // Debug info about chart windows.
        AddLine("=== Debug Info ===");
        AddLine("Console hwnd: " + IntegerToString(m_hwnd));
        AddLine("MT5 hwnd: " + IntegerToString(m_hwndMT5));
        AddLine("Current chart ID: " + IntegerToString(m_currentChartId));
        
        long hwndMDI = FindWindowExW(m_hwndMT5, 0, "MDIClient", NULL);
        AddLine("MDIClient hwnd: " + IntegerToString(hwndMDI));
        
        long hwndActive = SendMessageW(hwndMDI, WM_MDIGETACTIVE, 0, 0);
        AddLine("MDI Active child: " + IntegerToString(hwndActive));
        
        AddLine("--- Charts ---");
        long chartId = ChartFirst();
        while (chartId >= 0)
        {
            string sym = ChartSymbol(chartId);
            long chartHwnd = ChartGetInteger(chartId, CHART_WINDOW_HANDLE);
            long parent = GetParent(chartHwnd);
            string marker = (chartHwnd == hwndActive) ? " <-- ACTIVE" : "";
            if (parent == hwndActive) marker = " <-- PARENT IS ACTIVE";
            AddLine("  ID:" + IntegerToString(chartId) + " " + sym + 
                      " hwnd:" + IntegerToString(chartHwnd) + 
                      " parent:" + IntegerToString(parent) + marker);
            chartId = ChartNext(chartId);
        }
    }
    else if (command == "version")
    {
        AddLine("Console: ver. " + Version);
        AddLine("MT5:     Build " + IntegerToString(TerminalInfoInteger(TERMINAL_BUILD)) + 
                  " (" + TerminalInfoString(TERMINAL_LANGUAGE) + ")");
    }
    else if (command == "quit")
    {
        AddLine("Stopping service...");
        m_quitRequested = true;
    }
    else if (StringFind(command, "chart ") == 0 || command == "chart")
    {
        // Extract symbol and optional timeframe from command.
        // Format: chart <symbol> [timeframe]
        string args = StringSubstr(cmd, 6);
        StringTrimLeft(args);
        StringTrimRight(args);
        
        if (StringLen(args) == 0)
        {
            AddLine("Usage: chart <symbol> [timeframe]");
            AddLine("Example: chart EURUSD");
            AddLine("         chart EURUSD D1");
            AddLine("         chart GBPUSD H4");
        }
        else
        {
            // Parse symbol and optional timeframe.
            string parts[];
            int count = StringSplit(args, ' ', parts);
            
            string symbol = parts[0];
            StringToUpper(symbol);
            
            ENUM_TIMEFRAMES tf = PERIOD_H1;  // Default timeframe.
            string tfStr = "H1";
            
            if (count > 1)
            {
                tfStr = parts[1];
                StringToUpper(tfStr);
                tf = ParseTimeframe(tfStr);
                if (tf == PERIOD_CURRENT)
                {
                    AddLine("Invalid timeframe: " + tfStr);
                    AddLine("Use: M1, M5, M15, M30, H1, H4, D1, W1, MN1, etc.");
                    return;
                }
            }
            
            // Check if symbol exists.
            if (SymbolSelect(symbol, true))
            {
                ResetLastError();
                long chartId = ChartOpen(symbol, tf);
                int err = GetLastError();
                
                if (chartId > 0)
                {
                    AddLine("Opened chart: " + symbol + " (" + tfStr + ")");
                    
                    // Save undo info.
                    m_lastUndoCommand = "chart";
                    m_lastUndoData = IntegerToString(chartId);
                    m_lastUndoChartId = chartId;
                }
                else
                {
                    AddLine("Failed to open chart for: " + symbol);
                    AddLine("Error code: " + IntegerToString(err));
                }
            }
            else
            {
                AddLine("Symbol not found: " + symbol);
            }
        }
    }
    else if (StringFind(command, "run ") == 0 || command == "run")
    {
        // Run a script by name using MT5 internal message.
        string scriptName = StringSubstr(cmd, 4);
        StringTrimLeft(scriptName);
        StringTrimRight(scriptName);
        
        if (StringLen(scriptName) == 0)
        {
            AddLine("Usage: run <script_name>");
            AddLine("Example: run MyScript");
        }
        else
        {
            // Remove .ex5/.mq5 extension if present.
            StringReplace(scriptName, ".ex5", "");
            StringReplace(scriptName, ".mq5", "");
            
            AddLine("Running: " + scriptName);
            
            // Run using MT5 internal message.
            string result;
            if (RunEX5(m_hwndMT5, scriptName, result))
            {
                AddLine(result);
                AddLine("Script launched!");
            }
            else
            {
                AddLine("Failed: " + result);
            }
        }
    }
    else if (StringFind(command, "tf ") == 0 || command == "tf" || 
                StringFind(command, "timeframe ") == 0 || command == "timeframe")
    {
        // Change current chart timeframe.
        string args = "";
        if (StringFind(command, "tf ") == 0)
            args = StringSubstr(cmd, 3);
        else if (StringFind(command, "timeframe ") == 0)
            args = StringSubstr(cmd, 10);
        
        StringTrimLeft(args);
        StringTrimRight(args);
        StringToUpper(args);
        
        if (StringLen(args) == 0)
        {
            AddLine("Usage: tf <timeframe>");
            AddLine("Example: tf H1");
            AddLine("");
            AddLine("Timeframes: M1, M2, M3, M4, M5, M6, M10, M12, M15, M20, M30");
            AddLine("            H1, H2, H3, H4, H6, H8, H12, D1, W1, MN1");
        }
        else if (m_currentChartId <= 0)
        {
            AddLine("No active chart");
        }
        else
        {
            ENUM_TIMEFRAMES newTf = ParseTimeframe(args);
            if (newTf == PERIOD_CURRENT)
            {
                AddLine("Invalid timeframe: " + args);
                AddLine("Use: M1, M5, M15, M30, H1, H4, D1, W1, MN1, etc.");
            }
            else
            {
                // Save previous timeframe for undo.
                ENUM_TIMEFRAMES oldTf = (ENUM_TIMEFRAMES)ChartPeriod(m_currentChartId);
                
                if (ChartSetSymbolPeriod(m_currentChartId, ChartSymbol(m_currentChartId), newTf))
                {
                    AddLine("Timeframe changed to " + args + ".");
                    
                    // Save undo info.
                    m_lastUndoCommand = "tf";
                    m_lastUndoData = IntegerToString((int)oldTf);
                    m_lastUndoChartId = m_currentChartId;
                }
                else
                {
                    AddLine("Failed to change timeframe.");
                }
            }
        }
    }
    else if (command == "left" || command == "l")
    {
        SwitchChart(-1);
    }
    else if (command == "right" || command == "r")
    {
        SwitchChart(+1);
    }
    else if (command == "shift")
    {
        // Toggle chart shift.
        if (m_currentChartId <= 0)
        {
            AddLine("No active chart.");
            return;
        }
        
        bool currentShift = (bool)ChartGetInteger(m_currentChartId, CHART_SHIFT);
        ChartSetInteger(m_currentChartId, CHART_SHIFT, !currentShift);
        ChartRedraw(m_currentChartId);
        AddLine("Chart shift " + (!currentShift ? "enabled" : "disabled") + ".");
    }
    else if (command == "scroll")
    {
        // Toggle chart auto-scroll.
        if (m_currentChartId <= 0)
        {
            AddLine("No active chart.");
            return;
        }
        
        bool currentScroll = (bool)ChartGetInteger(m_currentChartId, CHART_AUTOSCROLL);
        ChartSetInteger(m_currentChartId, CHART_AUTOSCROLL, !currentScroll);
        ChartRedraw(m_currentChartId);
        AddLine("Chart auto-scroll " + (!currentScroll ? "enabled" : "disabled") + ".");
    }
    else if (command == "auto" || command == "algo" || StringFind(command, "auto ") == 0 || StringFind(command, "algo ") == 0)
    {
        // Get current state.
        bool currentState = (bool)TerminalInfoInteger(TERMINAL_TRADE_ALLOWED);
        
        // Check for on/off argument.
        string arg = "";
        if (StringLen(command) > 5)
        {
            arg = StringSubstr(command, 5);
            StringTrimLeft(arg);
            StringTrimRight(arg);
        }
        
        bool shouldToggle = false;
        
        if (arg == "on")
        {
            if (currentState)
            {
                AddLine("Autotrading is already ENABLED.");
            }
            else
            {
                shouldToggle = true;
            }
        }
        else if (arg == "off")
        {
            if (!currentState)
            {
                AddLine("Autotrading is already DISABLED.");
            }
            else
            {
                shouldToggle = true;
            }
        }
        else if (arg == "")
        {
            // No argument - toggle.
            shouldToggle = true;
        }
        else
        {
            AddLine("Usage: auto [on|off]");
            AddLine("  auto     - Toggle autotrading");
            AddLine("  auto on  - Enable autotrading");
            AddLine("  auto off - Disable autotrading");
        }
        
        if (shouldToggle)
        {
            // Save previous state for undo.
            bool prevState = currentState;
            
            // Bring MT5 to foreground temporarily for keyboard to work.
            SetForegroundWindow(m_hwndMT5);
            Sleep(50);
            
            // Simulate Ctrl+E keypress.
            keybd_event((uchar)VK_CONTROL, 0, 0, 0);
            keybd_event((uchar)VK_E, 0, 0, 0);
            keybd_event((uchar)VK_E, 0, KEYEVENTF_KEYUP, 0);
            keybd_event((uchar)VK_CONTROL, 0, KEYEVENTF_KEYUP, 0);
            
            Sleep(100);
            
            // Bring console back to foreground.
            SetForegroundWindow(m_hwnd);
            
            // Check new state.
            bool newState = (bool)TerminalInfoInteger(TERMINAL_TRADE_ALLOWED);
            AddLine("Autotrading: " + (newState ? "ENABLED" : "DISABLED"));
            
            // Save undo info if state actually changed.
            if (newState != prevState)
            {
                m_lastUndoCommand = "auto";
                m_lastUndoData = prevState ? "on" : "off";  // What it was before.
                m_lastUndoChartId = 0;
            }
        }
    }
    else if (StringFind(command, "buy ") == 0 || command == "buy")
    {
        ExecuteTrade(true, false, StringSubstr(cmd, 4));
    }
    else if (StringFind(command, "sell ") == 0 || command == "sell")
    {
        ExecuteTrade(false, false, StringSubstr(cmd, 5));
    }
    else if (StringFind(command, "abuy ") == 0 || command == "abuy")
    {
        ExecuteTrade(true, true, StringSubstr(cmd, 5));
    }
    else if (StringFind(command, "asell ") == 0 || command == "asell")
    {
        ExecuteTrade(false, true, StringSubstr(cmd, 6));
    }
    else if (command == "aclose all")
    {
        // Async close all positions.
        AddLine("Async closing all positions...");
        
        CTrade trade;
        trade.SetExpertMagicNumber(123456);
        trade.SetDeviationInPoints(10);
        trade.SetAsyncMode(true);
        
        int total = PositionsTotal();
        int sent = 0;
        
        for (int i = total - 1; i >= 0; i--)
        {
            ulong ticket = PositionGetTicket(i);
            if (ticket > 0)
            {
                string symbol = PositionGetString(POSITION_SYMBOL);
                if (trade.PositionClose(ticket))
                {
                    sent++;
                    AddLine("Sent close: " + symbol + " #" + IntegerToString(ticket));
                }
            }
        }
        
        AddLine("Sent " + IntegerToString(sent) + " close requests.");
    }
    else if (StringFind(command, "aclose ") == 0 || command == "aclose")
    {
        // Async close positions for symbol.
        string symbolArg = StringSubstr(cmd, 7);
        StringTrimLeft(symbolArg);
        StringTrimRight(symbolArg);
        StringToUpper(symbolArg);
        
        if (StringLen(symbolArg) == 0)
        {
            AddLine("Usage: aclose <symbol> or aclose all");
            AddLine("Example: aclose EURUSD");
        }
        else
        {
            AddLine("Async closing " + symbolArg + " positions...");
            
            CTrade trade;
            trade.SetExpertMagicNumber(123456);
            trade.SetDeviationInPoints(10);
            trade.SetAsyncMode(true);
            
            int total = PositionsTotal();
            int sent = 0;
            
            for (int i = total - 1; i >= 0; i--)
            {
                ulong ticket = PositionGetTicket(i);
                if (ticket > 0)
                {
                    string posSymbol = PositionGetString(POSITION_SYMBOL);
                    string posSymbolUpper = posSymbol;
                    StringToUpper(posSymbolUpper);
                    
                    if (posSymbolUpper == symbolArg)
                    {
                        if (trade.PositionClose(ticket))
                        {
                            sent++;
                            AddLine("Sent close: #" + IntegerToString(ticket));
                        }
                    }
                }
            }
            
            if (sent == 0)
                AddLine("No positions found for " + symbolArg);
            else
                AddLine("Sent " + IntegerToString(sent) + " close requests.");
        }
    }
    else if (command == "pending" || command == "orders")
    {
        // List all pending orders.
        int total = OrdersTotal();
        
        if (total == 0)
        {
            AddLine("No pending orders.");
        }
        else
        {
            AddLine("=== Pending Orders (" + IntegerToString(total) + ") ===");
            
            for (int i = 0; i < total; i++)
            {
                ulong ticket = OrderGetTicket(i);
                if (ticket > 0)
                {
                    string symbol = OrderGetString(ORDER_SYMBOL);
                    double volume = OrderGetDouble(ORDER_VOLUME_CURRENT);
                    double price = OrderGetDouble(ORDER_PRICE_OPEN);
                    double sl = OrderGetDouble(ORDER_SL);
                    double tp = OrderGetDouble(ORDER_TP);
                    ENUM_ORDER_TYPE type = (ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);
                    datetime time = (datetime)OrderGetInteger(ORDER_TIME_SETUP);
                    
                    string typeStr;
                    switch (type)
                    {
                        case ORDER_TYPE_BUY_LIMIT: typeStr = "BuyLimit "; break;
                        case ORDER_TYPE_SELL_LIMIT: typeStr = "SellLimit"; break;
                        case ORDER_TYPE_BUY_STOP: typeStr = "BuyStop  "; break;
                        case ORDER_TYPE_SELL_STOP: typeStr = "SellStop "; break;
                        case ORDER_TYPE_BUY_STOP_LIMIT: typeStr = "BuyStpLmt"; break;
                        case ORDER_TYPE_SELL_STOP_LIMIT: typeStr = "SellStpLmt"; break;
                        default: typeStr = "Unknown  "; break;
                    }
                    
                    int digits = (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS);
                    
                    string line = "#" + IntegerToString(ticket) + " " + typeStr + " " + 
                                      symbol + " " + DoubleToString(volume, 2) + " @ " + 
                                      DoubleToString(price, digits);
                    
                    if (sl != 0) line += " SL=" + DoubleToString(sl, digits);
                    if (tp != 0) line += " TP=" + DoubleToString(tp, digits);
                    
                    AddLine(line);
                }
            }
        }
    }
    else if (command == "positions" || command == "pos")
    {
        // List all open positions.
        int total = PositionsTotal();
        
        if (total == 0)
        {
            AddLine("No open positions.");
        }
        else
        {
            AddLine("=== Open Positions (" + IntegerToString(total) + ") ===");
            
            double totalProfit = 0;
            
            for (int i = 0; i < total; i++)
            {
                ulong ticket = PositionGetTicket(i);
                if (ticket > 0)
                {
                    string symbol = PositionGetString(POSITION_SYMBOL);
                    double volume = PositionGetDouble(POSITION_VOLUME);
                    double profit = PositionGetDouble(POSITION_PROFIT);
                    double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);
                    ENUM_POSITION_TYPE type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
                    string typeStr = (type == POSITION_TYPE_BUY) ? "Buy " : "Sell";
                    
                    int digits = (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS);
                    
                    string profitStr = (profit >= 0) ? "+" : "";
                    profitStr += DoubleToString(profit, 2);
                    
                    AddLine(typeStr + " " + symbol + " " + 
                              DoubleToString(volume, 2) + " @ " + 
                              DoubleToString(openPrice, digits) + " = " + profitStr);
                    
                    totalProfit += profit;
                }
            }
            
            AddLine("");
            AddLine("Total P/L: " + FormatMoney(totalProfit, true));
        }
    }
    else if (StringFind(command, "close") == 0)
    {
        // Parse close command: close[?] <all|last|symbol> [partial] [profit|loss]
        string closeCmd = cmd;
        bool simulate = false;
        
        // Check for ? flag.
        if (StringFind(closeCmd, "close?") == 0)
        {
            simulate = true;
            closeCmd = "close" + StringSubstr(closeCmd, 6);
        }
        
        // Parse arguments.
        string args = StringSubstr(closeCmd, 5);
        StringTrimLeft(args);
        StringTrimRight(args);
        
        if (StringLen(args) == 0)
        {
            AddLine("Usage: close[?] <all|last|symbol> [partial] [profit|loss]");
            AddLine("Examples:");
            AddLine("  close all           - Close all positions");
            AddLine("  close all 0.5       - Close 50% of all positions");
            AddLine("  close all profit    - Close all profitable trades");
            AddLine("  close all loss 0.5  - Close 50% of losing trades");
            AddLine("  close EURUSD        - Close all EURUSD positions");
            AddLine("  close EURUSD 0.7    - Close 70% of EURUSD positions");
            AddLine("  close last          - Close last opened trade");
            AddLine("  close? all          - Simulate closing all (show P/L)");
        }
        else
        {
            // Split args into parts.
            string parts[];
            StringSplit(args, ' ', parts);
            
            string target = "";
            double partial = 1.0;  // Default: close 100%
            bool profitOnly = false;
            bool lossOnly = false;
            bool closeLast = false;
            
            for (int p = 0; p < ArraySize(parts); p++)
            {
                string part = parts[p];
                StringToLower(part);
                
                if (part == "all")
                    target = "ALL";
                else if (part == "last" || part == "prev")
                    closeLast = true;
                else if (part == "profit" || part == "profitable")
                    profitOnly = true;
                else if (part == "loss" || part == "losing")
                    lossOnly = true;
                else if (StringFind(part, "0.") == 0 || part == "1" || part == "1.0")
                {
                    partial = StringToDouble(part);
                    if (partial <= 0 || partial > 1)
                        partial = 1.0;
                }
                else if (StringLen(part) > 0)
                {
                    target = parts[p];  // Use original case for symbol.
                    StringToUpper(target);
                }
            }
            
            if (closeLast)
            {
                // Find latest position by open time.
                datetime latestTime = 0;
                ulong latestTicket = 0;
                
                for (int i = 0; i < PositionsTotal(); i++)
                {
                    ulong ticket = PositionGetTicket(i);
                    if (ticket > 0)
                    {
                        datetime openTime = (datetime)PositionGetInteger(POSITION_TIME);
                        if (openTime > latestTime)
                        {
                            latestTime = openTime;
                            latestTicket = ticket;
                        }
                    }
                }
                
                if (latestTicket == 0)
                {
                    AddLine("No positions found.");
                }
                else
                {
                    PositionSelectByTicket(latestTicket);
                    string symbol = PositionGetString(POSITION_SYMBOL);
                    double volume = PositionGetDouble(POSITION_VOLUME);
                    double profit = PositionGetDouble(POSITION_PROFIT);
                    ENUM_POSITION_TYPE type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
                    string typeStr = (type == POSITION_TYPE_BUY) ? "Buy" : "Sell";
                    
                    double closeVol = NormalizeDouble(volume * partial, 2);
                    if (closeVol < SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN))
                        closeVol = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN);
                    
                    if (simulate)
                    {
                        double estProfit = profit * partial;
                        double newBalance = AccountInfoDouble(ACCOUNT_BALANCE) + estProfit;
                        AddLine("=== SIMULATION ===");
                        AddLine("Would close: " + typeStr + " " + symbol + " " + DoubleToString(closeVol, 2) + " lots");
                        AddLine("Est. P/L: " + FormatMoney(estProfit, true));
                        AddLine("Est. Balance: " + FormatMoney(newBalance));
                    }
                    else
                    {
                        CTrade trade;
                        trade.SetExpertMagicNumber(123456);
                        trade.SetDeviationInPoints(10);
                        
                        if (partial < 1.0)
                        {
                            if (trade.PositionClosePartial(latestTicket, closeVol))
                                AddLine("Closed partial: " + typeStr + " " + symbol + " " + DoubleToString(closeVol, 2) + " lots");
                            else
                                AddLine("Failed: " + trade.ResultComment());
                        }
                        else
                        {
                            if (trade.PositionClose(latestTicket))
                                AddLine("Closed: " + typeStr + " " + symbol + " " + DoubleToString(volume, 2) + " lots");
                            else
                                AddLine("Failed: " + trade.ResultComment());
                        }
                    }
                }
            }
            else if (StringLen(target) > 0)
            {
                // Close positions matching criteria.
                string actionStr = simulate ? "Would close" : "Closing";
                if (target == "ALL")
                    AddLine(actionStr + " all positions" + (partial < 1.0 ? " (" + DoubleToString(partial * 100, 0) + "%)" : "") + "...");
                else
                    AddLine(actionStr + " " + target + " positions" + (partial < 1.0 ? " (" + DoubleToString(partial * 100, 0) + "%)" : "") + "...");
                
                CTrade trade;
                trade.SetExpertMagicNumber(123456);
                trade.SetDeviationInPoints(10);
                
                int total = PositionsTotal();
                int closed = 0;
                int failed = 0;
                int skipped = 0;
                double totalPL = 0;
                
                for (int i = total - 1; i >= 0; i--)
                {
                    ulong ticket = PositionGetTicket(i);
                    if (ticket > 0)
                    {
                        string symbol = PositionGetString(POSITION_SYMBOL);
                        double volume = PositionGetDouble(POSITION_VOLUME);
                        double profit = PositionGetDouble(POSITION_PROFIT);
                        ENUM_POSITION_TYPE type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
                        string typeStr = (type == POSITION_TYPE_BUY) ? "Buy" : "Sell";
                        
                        // Check symbol match.
                        string symbolUpper = symbol;
                        StringToUpper(symbolUpper);
                        if (target != "ALL" && symbolUpper != target)
                            continue;
                        
                        // Check profit/loss filter.
                        if (profitOnly && profit < 0)
                        {
                            skipped++;
                            continue;
                        }
                        if (lossOnly && profit >= 0)
                        {
                            skipped++;
                            continue;
                        }
                        
                        double closeVol = NormalizeDouble(volume * partial, 2);
                        double volMin = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN);
                        if (closeVol < volMin)
                            closeVol = volMin;
                        if (closeVol > volume)
                            closeVol = volume;
                        
                        if (simulate)
                        {
                            double estProfit = profit * (closeVol / volume);
                            totalPL += estProfit;
                            closed++;
                            AddLine("  " + typeStr + " " + symbol + " " + DoubleToString(closeVol, 2) + " lots, P/L: " + FormatMoney(estProfit, true));
                        }
                        else
                        {
                            bool success = false;
                            if (partial < 1.0 && closeVol < volume)
                                success = trade.PositionClosePartial(ticket, closeVol);
                            else
                                success = trade.PositionClose(ticket);
                            
                            if (success)
                            {
                                closed++;
                                AddLine("Closed: " + typeStr + " " + symbol + " " + DoubleToString(closeVol, 2) + " lots");
                            }
                            else
                            {
                                failed++;
                                AddLine("Failed: " + symbol + " - " + trade.ResultComment());
                            }
                        }
                    }
                }
                
                AddLine("");
                if (simulate)
                {
                    AddLine("=== SIMULATION RESULTS ===");
                    AddLine("Positions: " + IntegerToString(closed) + (skipped > 0 ? " (skipped: " + IntegerToString(skipped) + ")" : ""));
                    AddLine("Total P/L: " + FormatMoney(totalPL, true));
                    AddLine("Est. Balance: " + FormatMoney(AccountInfoDouble(ACCOUNT_BALANCE) + totalPL));
                }
                else
                {
                    AddLine("Closed: " + IntegerToString(closed) + ", Failed: " + IntegerToString(failed) + 
                              (skipped > 0 ? ", Skipped: " + IntegerToString(skipped) : ""));
                }
            }
            else
            {
                AddLine("Invalid close command. Use 'close' for help.");
            }
        }
    }
    else if (StringFind(command, "hedge") == 0)
    {
        // Hedge command: hedge <all|symbol>
        string args = StringSubstr(cmd, 5);
        StringTrimLeft(args);
        StringTrimRight(args);
        StringToUpper(args);
        
        if (StringLen(args) == 0)
        {
            AddLine("Usage: hedge <all|symbol>");
            AddLine("Opens opposite positions to hedge existing ones.");
        }
        else
        {
            AddLine("Hedging " + args + " positions...");
            
            CTrade trade;
            trade.SetExpertMagicNumber(123456);
            trade.SetDeviationInPoints(10);
            
            // First, calculate net volume per symbol.
            string symbols[];
            double buyVols[];
            double sellVols[];
            int symCount = 0;
            
            for (int i = 0; i < PositionsTotal(); i++)
            {
                ulong ticket = PositionGetTicket(i);
                if (ticket > 0)
                {
                    string symbol = PositionGetString(POSITION_SYMBOL);
                    string symbolUpper = symbol;
                    StringToUpper(symbolUpper);
                    
                    if (args != "ALL" && symbolUpper != args)
                        continue;
                    
                    double volume = PositionGetDouble(POSITION_VOLUME);
                    ENUM_POSITION_TYPE type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
                    
                    // Find or add symbol.
                    int idx = -1;
                    for (int j = 0; j < symCount; j++)
                    {
                        if (symbols[j] == symbol)
                        {
                            idx = j;
                            break;
                        }
                    }
                    if (idx < 0)
                    {
                        idx = symCount;
                        symCount++;
                        ArrayResize(symbols, symCount);
                        ArrayResize(buyVols, symCount);
                        ArrayResize(sellVols, symCount);
                        symbols[idx] = symbol;
                        buyVols[idx] = 0;
                        sellVols[idx] = 0;
                    }
                    
                    if (type == POSITION_TYPE_BUY)
                        buyVols[idx] += volume;
                    else
                        sellVols[idx] += volume;
                }
            }
            
            if (symCount == 0)
            {
                AddLine("No positions found to hedge.");
            }
            else
            {
                int hedged = 0;
                for (int i = 0; i < symCount; i++)
                {
                    double netVol = buyVols[i] - sellVols[i];
                    if (MathAbs(netVol) < 0.01)
                    {
                        AddLine(symbols[i] + ": Already hedged");
                        continue;
                    }
                    
                    // Open opposite position.
                    double hedgeVol = MathAbs(netVol);
                    double volMin = SymbolInfoDouble(symbols[i], SYMBOL_VOLUME_MIN);
                    double volStep = SymbolInfoDouble(symbols[i], SYMBOL_VOLUME_STEP);
                    hedgeVol = MathFloor(hedgeVol / volStep) * volStep;
                    if (hedgeVol < volMin)
                        hedgeVol = volMin;
                    
                    bool success = false;
                    if (netVol > 0)
                    {
                        // Net long, open sell.
                        success = trade.Sell(hedgeVol, symbols[i]);
                        if (success)
                            AddLine("Opened Sell " + symbols[i] + " " + DoubleToString(hedgeVol, 2) + " lots");
                    }
                    else
                    {
                        // Net short, open buy.
                        success = trade.Buy(hedgeVol, symbols[i]);
                        if (success)
                            AddLine("Opened Buy " + symbols[i] + " " + DoubleToString(hedgeVol, 2) + " lots");
                    }
                    
                    if (success)
                        hedged++;
                    else
                        AddLine("Failed: " + symbols[i] + " - " + trade.ResultComment());
                }
                
                AddLine("");
                AddLine("Hedged " + IntegerToString(hedged) + " symbol" + (hedged > 1 ? "s" : "") + ".");
            }
        }
    }
    else if (StringFind(command, "flip") == 0)
    {
        // Flip command: close all positions and open opposite.
        string args = StringSubstr(cmd, 4);
        StringTrimLeft(args);
        StringTrimRight(args);
        StringToUpper(args);
        
        if (StringLen(args) == 0)
            args = "ALL";
        
        AddLine("Flipping " + args + " positions...");
        
        CTrade trade;
        trade.SetExpertMagicNumber(123456);
        trade.SetDeviationInPoints(10);
        
        // First, calculate net volume per symbol.
        string symbols[];
        double netVols[];  // positive = net long, negative = net short
        int symCount = 0;
        
        for (int i = 0; i < PositionsTotal(); i++)
        {
            ulong ticket = PositionGetTicket(i);
            if (ticket > 0)
            {
                string symbol = PositionGetString(POSITION_SYMBOL);
                string symbolUpper = symbol;
                StringToUpper(symbolUpper);
                
                if (args != "ALL" && symbolUpper != args)
                    continue;
                
                double volume = PositionGetDouble(POSITION_VOLUME);
                ENUM_POSITION_TYPE type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
                
                // Find or add symbol.
                int idx = -1;
                for (int j = 0; j < symCount; j++)
                {
                    if (symbols[j] == symbol)
                    {
                        idx = j;
                        break;
                    }
                }
                if (idx < 0)
                {
                    idx = symCount;
                    symCount++;
                    ArrayResize(symbols, symCount);
                    ArrayResize(netVols, symCount);
                    symbols[idx] = symbol;
                    netVols[idx] = 0;
                }
                
                if (type == POSITION_TYPE_BUY)
                    netVols[idx] += volume;
                else
                    netVols[idx] -= volume;
            }
        }
        
        if (symCount == 0)
        {
            AddLine("No positions found to flip.");
        }
        else
        {
            // Check how many symbols actually have net exposure to flip.
            int flippableCount = 0;
            for (int i = 0; i < symCount; i++)
            {
                if (MathAbs(netVols[i]) >= 0.01)
                    flippableCount++;
            }
            
            if (flippableCount == 0)
            {
                AddLine("All positions are already hedged - nothing to flip.");
            }
            else
            {
                // Close positions only for symbols with net exposure.
                AddLine("Closing existing positions...");
                int closed = 0;
                
                for (int i = PositionsTotal() - 1; i >= 0; i--)
                {
                    ulong ticket = PositionGetTicket(i);
                    if (ticket > 0)
                    {
                        string symbol = PositionGetString(POSITION_SYMBOL);
                        string symbolUpper = symbol;
                        StringToUpper(symbolUpper);
                        
                        if (args != "ALL" && symbolUpper != args)
                            continue;
                        
                        // Check if this symbol has net exposure (skip hedged symbols).
                        bool hasExposure = false;
                        for (int j = 0; j < symCount; j++)
                        {
                            if (symbols[j] == symbol && MathAbs(netVols[j]) >= 0.01)
                            {
                                hasExposure = true;
                                break;
                            }
                        }
                        
                        if (!hasExposure)
                            continue;  // Skip - this symbol is hedged.
                        
                        if (trade.PositionClose(ticket))
                            closed++;
                    }
                }
                
                AddLine("Closed " + IntegerToString(closed) + " position" + (closed > 1 ? "s" : "") + ".");
                Sleep(100);  // Brief pause before opening new positions.
                
                // Now open opposite positions.
                AddLine("Opening opposite positions...");
                int opened = 0;
                
                for (int i = 0; i < symCount; i++)
                {
                    if (MathAbs(netVols[i]) < 0.01)
                        continue;  // Was already hedged/neutral.
                    
                    double flipVol = MathAbs(netVols[i]);
                    double volMin = SymbolInfoDouble(symbols[i], SYMBOL_VOLUME_MIN);
                    double volStep = SymbolInfoDouble(symbols[i], SYMBOL_VOLUME_STEP);
                    flipVol = MathFloor(flipVol / volStep) * volStep;
                    if (flipVol < volMin)
                        flipVol = volMin;
                    
                    bool success = false;
                    if (netVols[i] > 0)
                    {
                        // Was net long, open sell (flip to short).
                        success = trade.Sell(flipVol, symbols[i]);
                        if (success)
                            AddLine("Opened Sell " + symbols[i] + " " + DoubleToString(flipVol, 2) + " lots");
                    }
                    else
                    {
                        // Was net short, open buy (flip to long).
                        success = trade.Buy(flipVol, symbols[i]);
                        if (success)
                            AddLine("Opened Buy " + symbols[i] + " " + DoubleToString(flipVol, 2) + " lots");
                    }
                    
                    if (success)
                        opened++;
                else
                    AddLine("Failed: " + symbols[i] + " - " + trade.ResultComment());
            }
            
            AddLine("");
            AddLine("Flipped " + IntegerToString(opened) + " symbol" + (opened > 1 ? "s" : "") + ".");
            }
        }
    }
    else if (StringFind(command, "double") == 0)
    {
        // Double command: double the volume of positions.
        string args = StringSubstr(cmd, 6);
        StringTrimLeft(args);
        StringTrimRight(args);
        StringToUpper(args);
        
        if (StringLen(args) == 0)
            args = "ALL";
        
        AddLine("Doubling " + args + " positions...");
        
        CTrade trade;
        trade.SetExpertMagicNumber(123456);
        trade.SetDeviationInPoints(10);
        
        // Collect positions to double (can't modify while iterating).
        ulong tickets[];
        string symbols[];
        double volumes[];
        ENUM_POSITION_TYPE types[];
        int posCount = 0;
        
        for (int i = 0; i < PositionsTotal(); i++)
        {
            ulong ticket = PositionGetTicket(i);
            if (ticket > 0)
            {
                string symbol = PositionGetString(POSITION_SYMBOL);
                string symbolUpper = symbol;
                StringToUpper(symbolUpper);
                
                if (args != "ALL" && symbolUpper != args)
                    continue;
                
                ArrayResize(tickets, posCount + 1);
                ArrayResize(symbols, posCount + 1);
                ArrayResize(volumes, posCount + 1);
                ArrayResize(types, posCount + 1);
                
                tickets[posCount] = ticket;
                symbols[posCount] = symbol;
                volumes[posCount] = PositionGetDouble(POSITION_VOLUME);
                types[posCount] = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
                posCount++;
            }
        }
        
        if (posCount == 0)
        {
            AddLine("No positions found to double.");
        }
        else
        {
            int doubled = 0;
            
            for (int i = 0; i < posCount; i++)
            {
                // Normalize volume.
                double vol = volumes[i];
                double volMin = SymbolInfoDouble(symbols[i], SYMBOL_VOLUME_MIN);
                double volStep = SymbolInfoDouble(symbols[i], SYMBOL_VOLUME_STEP);
                vol = MathFloor(vol / volStep) * volStep;
                if (vol < volMin)
                    vol = volMin;
                
                bool success = false;
                if (types[i] == POSITION_TYPE_BUY)
                {
                    success = trade.Buy(vol, symbols[i]);
                    if (success)
                        AddLine("Opened Buy " + symbols[i] + " " + DoubleToString(vol, 2) + " lots");
                }
                else
                {
                    success = trade.Sell(vol, symbols[i]);
                    if (success)
                        AddLine("Opened Sell " + symbols[i] + " " + DoubleToString(vol, 2) + " lots");
                }
                
                if (success)
                    doubled++;
                else
                    AddLine("Failed: " + symbols[i] + " - " + trade.ResultComment());
            }
            
            AddLine("");
            AddLine("Doubled " + IntegerToString(doubled) + " position" + (doubled > 1 ? "s" : "") + ".");
        }
    }
    else if (command == "streak" || command == "streaks")
    {
        // Find longest winning and losing streaks in history.
        AddLine("Calculating streaks...");
        
        HistorySelect(0, TimeCurrent());
        int totalDeals = HistoryDealsTotal();
        
        int winStreak = 0;
        int lossStreak = 0;
        int maxWinStreak = 0;
        int maxLossStreak = 0;
        int currentStreak = 0;
        bool lastWasWin = false;
        bool firstDeal = true;
        
        for (int i = 0; i < totalDeals; i++)
        {
            ulong ticket = HistoryDealGetTicket(i);
            if (ticket > 0)
            {
                ENUM_DEAL_ENTRY entry = (ENUM_DEAL_ENTRY)HistoryDealGetInteger(ticket, DEAL_ENTRY);
                double profit = HistoryDealGetDouble(ticket, DEAL_PROFIT);
                
                // Only count exit deals.
                if (entry != DEAL_ENTRY_OUT && entry != DEAL_ENTRY_INOUT)
                    continue;
                
                bool isWin = (profit > 0);
                
                if (firstDeal)
                {
                    currentStreak = 1;
                    lastWasWin = isWin;
                    firstDeal = false;
                }
                else if (isWin == lastWasWin)
                {
                    currentStreak++;
                }
                else
                {
                    // Streak ended.
                    if (lastWasWin && currentStreak > maxWinStreak)
                        maxWinStreak = currentStreak;
                    else if (!lastWasWin && currentStreak > maxLossStreak)
                        maxLossStreak = currentStreak;
                    
                    currentStreak = 1;
                    lastWasWin = isWin;
                }
            }
        }
        
        // Check final streak.
        if (!firstDeal)
        {
            if (lastWasWin && currentStreak > maxWinStreak)
                maxWinStreak = currentStreak;
            else if (!lastWasWin && currentStreak > maxLossStreak)
                maxLossStreak = currentStreak;
        }
        
        AddLine("");
        AddLine("=== Trading Streaks ===");
        AddLine("Longest winning streak: " + IntegerToString(maxWinStreak) + " trades");
        AddLine("Longest losing streak: " + IntegerToString(maxLossStreak) + " trades");
    }
    else if (StringFind(command, "breathe") == 0 || StringFind(command, "breath") == 0)
    {
        // Breathing exercise with platform lockout.
        string args = "";
        if (StringFind(command, "breathe ") == 0)
            args = StringSubstr(cmd, 8);
        else if (StringFind(command, "breath ") == 0)
            args = StringSubstr(cmd, 7);
        
        StringTrimLeft(args);
        StringTrimRight(args);
        
        int duration = 30;  // Default 60 seconds.
        if (StringLen(args) > 0)
        {
            duration = (int)StringToInteger(args);
            if (duration <= 0) duration = 30;
            if (duration > 300) duration = 300;  // Max 5 minutes.
        }
        
        // Start breathing mode.
        m_breathingMode = true;
        m_breathingStart = GetTickCount();
        m_breathingDuration = duration;
        m_breathingPhase = 0;  // Start with inhale.
        m_breathingPhaseStart = GetTickCount();
        
        // Disable and minimize MT5 window to freeze display.
        EnableWindow(m_hwndMT5, false);
        ShowWindow(m_hwndMT5, 6);  // SW_MINIMIZE
        
        // Clear screen and show initial state.
        ArrayResize(m_lines, 0);
        m_scrollOffset = 0;
        
        AddLine("");
        AddLine("  ╔════════════════════════════════════════╗");
        AddLine("  ║       BREATHING EXERCISE ACTIVE        ║");
        AddLine("  ║                                        ║");
        AddLine("  ║   Platform locked - take a moment      ║");
        AddLine("  ║                                        ║");
        AddLine("  ║        Press ESC to stop early         ║");
        AddLine("  ╚════════════════════════════════════════╝");
        AddLine("");
    }
    else if (StringFind(command, "shutdown") == 0)
    {
        // Shutdown command: close MT5 after delay.
        string args = "";
        if (StringFind(command, "shutdown ") == 0)
            args = StringSubstr(cmd, 9);
        
        StringTrimLeft(args);
        StringTrimRight(args);
        StringToLower(args);
        
        if (args == "cancel")
        {
            // Cancel pending shutdown.
            if (m_shutdownPending)
            {
                m_shutdownPending = false;
                AddLine("Shutdown cancelled.");
            }
            else
            {
                AddLine("No shutdown pending.");
            }
        }
        else if (StringLen(args) == 0)
        {
            // Immediate shutdown.
            AddLine("Shutting down MT5...");
            TerminalClose(0);
        }
        else
        {
            // Parse time: 5s, 10m, 1h, etc.
            int duration = 0;
            int len = StringLen(args);
            string unit = StringSubstr(args, len - 1, 1);
            string numPart = StringSubstr(args, 0, len - 1);
            int value = (int)StringToInteger(numPart);
            
            if (value <= 0)
            {
                AddLine("Invalid time format. Use: 5s, 10m, 1h");
            }
            else
            {
                if (unit == "s")
                    duration = value;
                else if (unit == "m")
                    duration = value * 60;
                else if (unit == "h")
                    duration = value * 3600;
                else
                {
                    AddLine("Invalid time unit. Use: s (seconds), m (minutes), h (hours)");
                    duration = 0;
                }
                
                if (duration > 0)
                {
                    m_shutdownPending = true;
                    m_shutdownStart = GetTickCount();
                    m_shutdownDuration = duration;
                    m_shutdownWarned = (duration <= 60);  // No warning needed if <= 1 minute.
                    m_lastCountdown = -1;
                    
                    string timeStr = "";
                    if (duration >= 3600)
                        timeStr = IntegerToString(duration / 3600) + "h " + IntegerToString((duration % 3600) / 60) + "m";
                    else if (duration >= 60)
                        timeStr = IntegerToString(duration / 60) + "m " + IntegerToString(duration % 60) + "s";
                    else
                        timeStr = IntegerToString(duration) + "s";
                    
                    AddLine("Shutdown scheduled in " + timeStr);
                    AddLine("Type 'shutdown cancel' to abort.");
                }
            }
        }
    }
    else if (StringFind(command, "template-save") == 0)
    {
        // Save current chart as template.
        string templateName = "";
        if (StringFind(command, "template-save ") == 0)
            templateName = StringSubstr(cmd, 14);
        
        StringTrimLeft(templateName);
        StringTrimRight(templateName);
        
        if (StringLen(templateName) == 0)
        {
            AddLine("Usage: template-save <name>");
            AddLine("Example: template-save MySetup");
        }
        else
        {
            // Add .tpl extension if not present.
            if (StringFind(templateName, ".tpl") < 0)
                templateName = templateName + ".tpl";
            
            // Get current chart.
            long chartId = ChartFirst();
            if (m_currentChartId != 0)
                chartId = m_currentChartId;
            
            // Save template.
            if (ChartSaveTemplate(chartId, templateName))
            {
                AddLine("Template saved: " + templateName);
            }
            else
            {
                int err = GetLastError();
                AddLine("Failed to save template: " + templateName);
                if (err != 0)
                    AddLine("Error: " + IntegerToString(err));
            }
        }
    }
    else if (StringFind(command, "template") == 0)
    {
        // Load template on current chart.
        string templateName = "";
        if (StringFind(command, "template ") == 0)
            templateName = StringSubstr(cmd, 9);
        
        StringTrimLeft(templateName);
        StringTrimRight(templateName);
        
        if (StringLen(templateName) == 0)
        {
            AddLine("Usage: template <name>");
            AddLine("Example: template Default");
        }
        else
        {
            // Add .tpl extension if not present.
            if (StringFind(templateName, ".tpl") < 0)
                templateName = templateName + ".tpl";
            
            // Get current chart.
            long chartId = ChartFirst();
            if (m_currentChartId != 0)
                chartId = m_currentChartId;
            
            // Apply template.
            if (ChartApplyTemplate(chartId, templateName))
            {
                AddLine("Template '" + templateName + "' applied");
                
                // Set undo.
                m_lastUndoCommand = "";
            }
            else
            {
                int err = GetLastError();
                AddLine("Failed to apply template: " + templateName);
                if (err == 5002)
                    AddLine("Template not found");
                else if (err != 0)
                    AddLine("Error: " + IntegerToString(err));
            }
        }
    }
    else if (StringFind(command, "compile") == 0)
    {
        // Compile an MQL5 file using MetaEditor64.exe.
        string args = "";
        if (StringFind(command, "compile ") == 0)
            args = StringSubstr(cmd, 8);
        
        StringTrimLeft(args);
        StringTrimRight(args);
        
        if (StringLen(args) == 0)
        {
            AddLine("Usage: compile <file> [options]");
            AddLine("Path formats:");
            AddLine("  MyEA             - Search in MQL5 folders");
            AddLine("  Experts\\MyEA    - Relative to MQL5");
            AddLine("  MQL5\\Experts\\X - Relative to data folder");
            AddLine("  C:\\full\\path   - Full path");
            AddLine("Options:");
            AddLine("  /inc:<path>        - Add include path");
            AddLine("  /proj              - Compile entire project");
            AddLine("  /avx /avx2 /avx512 - Optimization level");
            AddLine("  /fast              - No optimization");
            AddLine("  /s                 - Syntax check only");
        }
        else
        {
            string dataPath = TerminalInfoString(TERMINAL_DATA_PATH);
            string termPath = TerminalInfoString(TERMINAL_PATH);
            string mql5Path = dataPath + "\\MQL5\\";
            
            // Parse arguments: first token is filename, rest are options.
            string fileName = "";
            string options = "";
            
            // Find first space that's not inside a path.
            int spacePos = -1;
            bool inQuotes = false;
            for (int i = 0; i < StringLen(args); i++)
            {
                ushort ch = StringGetCharacter(args, i);
                if (ch == '"') inQuotes = !inQuotes;
                if (ch == ' ' && !inQuotes)
                {
                    // Check if this looks like a parameter start.
                    if (i + 1 < StringLen(args) && StringGetCharacter(args, i + 1) == '/')
                    {
                        spacePos = i;
                        break;
                    }
                }
            }
            
            if (spacePos > 0)
            {
                fileName = StringSubstr(args, 0, spacePos);
                options = StringSubstr(args, spacePos + 1);
            }
            else
            {
                fileName = args;
            }
            
            StringTrimLeft(fileName);
            StringTrimRight(fileName);
            
            // Remove surrounding double quotes if present (for paths with spaces).
            if (StringLen(fileName) >= 2 && 
                StringGetCharacter(fileName, 0) == '"' && 
                StringGetCharacter(fileName, StringLen(fileName) - 1) == '"')
            {
                fileName = StringSubstr(fileName, 1, StringLen(fileName) - 2);
            }
            
            // Smart path detection and auto-completion.
            string foundPath = "";
            string fileNameLower = fileName;
            StringToLower(fileNameLower);
            
            // Check if it's a full path with drive letter.
            bool isFullPath = (StringFind(fileName, ":") >= 0);
            
            // Check for partial paths that need auto-completion.
            bool needsMQL5Prefix = false;
            bool needsDataPrefix = false;
            
            // Check for \MQL5 or MQL5 prefix.
            if (StringFind(fileNameLower, "\\mql5") == 0 || StringFind(fileNameLower, "mql5") == 0)
            {
                needsDataPrefix = true;
                // Remove leading backslash if present.
                if (StringGetCharacter(fileName, 0) == '\\')
                    fileName = StringSubstr(fileName, 1);
            }
            // Check for \Experts, Experts, \Indicators, etc.
            else if (StringFind(fileNameLower, "\\experts") == 0 || StringFind(fileNameLower, "experts") == 0 ||
                        StringFind(fileNameLower, "\\indicators") == 0 || StringFind(fileNameLower, "indicators") == 0 ||
                        StringFind(fileNameLower, "\\scripts") == 0 || StringFind(fileNameLower, "scripts") == 0 ||
                        StringFind(fileNameLower, "\\include") == 0 || StringFind(fileNameLower, "include") == 0 ||
                        StringFind(fileNameLower, "\\libraries") == 0 || StringFind(fileNameLower, "libraries") == 0)
            {
                needsMQL5Prefix = true;
                // Remove leading backslash if present.
                if (StringGetCharacter(fileName, 0) == '\\')
                    fileName = StringSubstr(fileName, 1);
            }
            
            // Add .mq5 extension if not present (for all path types).
            if (StringFind(fileName, ".mq5") < 0 && StringFind(fileName, ".mqh") < 0)
                fileName = fileName + ".mq5";
            
            if (isFullPath)
            {
                // Use as-is, just verify it exists.
                if (GetFileAttributesW(fileName) != -1)
                {
                    foundPath = fileName;
                    AddLine("Using: " + fileName);
                }
                else
                {
                    AddLine("File not found: " + fileName);
                }
            }
            else if (needsDataPrefix)
            {
                // Prepend data path to MQL5\...
                string fullPath = dataPath + "\\" + fileName;
                if (GetFileAttributesW(fullPath) != -1)
                {
                    foundPath = fullPath;
                    AddLine("Using: " + fileName);
                }
                else
                {
                    AddLine("File not found: " + fullPath);
                }
            }
            else if (needsMQL5Prefix)
            {
                // Prepend data path + MQL5 to Experts\..., Indicators\..., etc.
                string fullPath = mql5Path + fileName;
                if (GetFileAttributesW(fullPath) != -1)
                {
                    foundPath = fullPath;
                    AddLine("Using: MQL5\\" + fileName);
                }
                else
                {
                    AddLine("File not found: " + fullPath);
                }
            }
            else
            {
                // Search for the file in Experts, Indicators, Scripts folders.
                string folders[] = {"Experts", "Indicators", "Scripts", "Include", "Libraries"};
                
                AddLine("Searching for " + fileName + "...");
                ForceRedraw();
                
                // Search in each folder recursively.
                for (int f = 0; f < ArraySize(folders) && foundPath == ""; f++)
                {
                    string searchPath = mql5Path + folders[f] + "\\" + fileName;
                    if (GetFileAttributesW(searchPath) != -1)
                    {
                        foundPath = searchPath;
                        AddLine("Found: " + folders[f] + "\\" + fileName);
                    }
                    else
                    {
                        // Search subdirectories.
                        string searchPattern = mql5Path + folders[f] + "\\*";
                        WIN32_FIND_DATAW findData;
                        long hFind = FindFirstFileW(searchPattern, findData);
                        if (hFind != -1)
                        {
                            do
                            {
                                string subName = "";
                                for (int c = 0; c < 260 && findData.cFileName[c] != 0; c++)
                                    subName += ShortToString(findData.cFileName[c]);
                                
                                if (subName != "." && subName != ".." && 
                                    (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0)
                                {
                                    string subPath = mql5Path + folders[f] + "\\" + subName + "\\" + fileName;
                                    if (GetFileAttributesW(subPath) != -1)
                                    {
                                        foundPath = subPath;
                                        AddLine("Found: " + folders[f] + "\\" + subName + "\\" + fileName);
                                        break;
                                    }
                                }
                            }
                            while (FindNextFileW(hFind, findData) && foundPath == "");
                            FindClose(hFind);
                        }
                    }
                }
                
                if (foundPath == "")
                    AddLine("File not found: " + fileName);
            }
            
            if (foundPath != "")
            {
                // Use MetaEditor64.exe from terminal folder.
                string editorPath = termPath + "\\metaeditor64.exe";
                
                if (GetFileAttributesW(editorPath) == -1)
                {
                    AddLine("MetaEditor64.exe not found in terminal folder.");
                }
                else
                {
                    // Run compiler.
                    AddLine("Compiling...");
                    ForceRedraw();
                    
                    // Build command: metaeditor64.exe /compile:"path\file.mq5" /log:"logfile" [options]
                    string logFile = dataPath + "\\MQL5\\Files\\compile_log.txt";
                    string compileCmd = "/C \"\"" + editorPath + "\" /compile:\"" + foundPath + "\" /log:\"" + logFile + "\" /inc:\"" + mql5Path + "\"";
                    
                    // Add user options.
                    if (StringLen(options) > 0)
                        compileCmd += " " + options;
                    
                    compileCmd += "\"";
                    
                    // Delete old log.
                    FileDelete("compile_log.txt");
                    
                    ShellExecuteW(0, "open", "cmd.exe", compileCmd, "", SW_HIDE);
                    
                    // Wait for compilation with progress indicator.
                    // Check for log file containing "Result:" which indicates completion.
                    int waitCount = 0;
                    int maxWait = 300;  // Max 5 minutes (300 * 1000ms).
                    string dots = "";
                    bool compileDone = false;
                    
                    while (waitCount < maxWait && !compileDone)
                    {
                        Sleep(1000);
                        waitCount++;
                        
                        // Update progress dots (cycle through 1-20 dots).
                        dots += ".";
                        if (StringLen(dots) > 20)
                            dots = ".";
                        
                        // Update the "Compiling..." line with dots.
                        int lineSize = ArraySize(m_lines);
                        if (lineSize > 0)
                        {
                            m_lines[lineSize - 1] = "Compiling" + dots;
                            ForceRedraw();
                        }
                        
                        // Check if log file exists and contains completion marker.
                        if (FileIsExist("compile_log.txt"))
                        {
                            int checkHandle = FileOpen("compile_log.txt", FILE_READ | FILE_TXT | FILE_ANSI | FILE_SHARE_READ);
                            if (checkHandle != INVALID_HANDLE)
                            {
                                string content = "";
                                while (!FileIsEnding(checkHandle))
                                {
                                    content += FileReadString(checkHandle) + "\n";
                                }
                                FileClose(checkHandle);
                                
                                // Check for completion markers.
                                if (StringFind(content, "Result:") >= 0)
                                {
                                    compileDone = true;
                                }
                            }
                        }
                    }
                    
                    // Remove the progress line.
                    int curSize = ArraySize(m_lines);
                    if (curSize > 0)
                        ArrayResize(m_lines, curSize - 1);
                    
                    // Read and display the log file.
                    if (compileDone || FileIsExist("compile_log.txt"))
                    {
                        // Small delay to ensure file is fully written.
                        Sleep(200);
                        
                        int logHandle = FileOpen("compile_log.txt", FILE_READ | FILE_TXT | FILE_ANSI | FILE_SHARE_READ);
                        if (logHandle != INVALID_HANDLE)
                        {
                            int lineCount = 0;
                            string lastLine = "";
                            
                            while (!FileIsEnding(logHandle))
                            {
                                string line = FileReadString(logHandle);
                                if (StringLen(line) > 0)
                                {
                                    // Show relevant lines.
                                    if (StringFind(line, "compiling") >= 0 ||
                                        StringFind(line, "error") >= 0 || StringFind(line, "Error") >= 0 ||
                                        StringFind(line, "warning") >= 0 || StringFind(line, "Warning") >= 0 ||
                                        StringFind(line, "Result") >= 0 || StringFind(line, "result") >= 0 ||
                                        StringFind(line, "0 error") >= 0 || StringFind(line, "0 warning") >= 0 ||
                                        StringFind(line, "information") >= 0)
                                    {
                                        AddLine(line);
                                        lineCount++;
                                    }
                                    lastLine = line;
                                }
                            }
                            FileClose(logHandle);
                            
                            if (lineCount == 0)
                            {
                                AddLine("Compilation completed.");
                                if (lastLine != "") AddLine(lastLine);
                            }
                        }
                        else
                        {
                            AddLine("Could not read compilation log.");
                        }
                    }
                    else
                    {
                        AddLine("Compilation timed out after 5 minutes.");
                    }
                }
            }
        }
    }
    else if (command == "watch-clear")
    {
        // Remove all symbols from Market Watch.
        int totalSymbols = SymbolsTotal(true);
        int removed = 0;
        
        // Need to iterate backwards since we're removing.
        for (int i = totalSymbols - 1; i >= 0; i--)
        {
            string sym = SymbolName(i, true);
            // Don't remove the current chart symbol.
            if (sym != Symbol())
            {
                if (SymbolSelect(sym, false))
                    removed++;
            }
        }
        
        AddLine("Removed " + IntegerToString(removed) + " symbol" + (removed > 1 ? "s" : "") + " from Market Watch.");
    }
    else if (command == "watch" || StringFind(command, "watch ") == 0)
    {
        // Add symbol to Market Watch.
        string sym = StringSubstr(cmd, 6);
        StringTrimLeft(sym);
        StringTrimRight(sym);
        StringToUpper(sym);
        
        if (StringLen(sym) == 0)
        {
            AddLine("Usage: watch <symbol>");
            AddLine("Example: watch EURUSD");
        }
        else
        {
            if (SymbolSelect(sym, true))
            {
                AddLine("Added " + sym + " to Market Watch.");
            }
            else
            {
                AddLine("Symbol not found: " + sym);
            }
        }
    }
    else if (command == "declutter")
    {
        // Hide all chart objects.
        long chartId = ChartFirst();
        if (m_currentChartId != 0)
            chartId = m_currentChartId;
        
        int total = ObjectsTotal(chartId);
        int hidden = 0;
        
        for (int i = 0; i < total; i++)
        {
            string objName = ObjectName(chartId, i);
            ObjectSetInteger(chartId, objName, OBJPROP_TIMEFRAMES, OBJ_NO_PERIODS);
            hidden++;
        }
        
        ChartRedraw(chartId);
        AddLine("Hidden " + IntegerToString(hidden) + " object" + (hidden > 1 ? "s" : "") + ".");
    }
    else if (command == "reclutter")
    {
        // Show all chart objects.
        long chartId = ChartFirst();
        if (m_currentChartId != 0)
            chartId = m_currentChartId;
        
        int total = ObjectsTotal(chartId);
        int shown = 0;
        
        for (int i = 0; i < total; i++)
        {
            string objName = ObjectName(chartId, i);
            ObjectSetInteger(chartId, objName, OBJPROP_TIMEFRAMES, OBJ_ALL_PERIODS);
            shown++;
        }
        
        ChartRedraw(chartId);
        AddLine("Showing " + IntegerToString(shown) + " object" + (shown > 1 ? "s" : "") + ".");
    }
    else if (command == "charts-close-all")
    {
        // Close all charts.
        int closed = 0;
        long chartId = ChartFirst();
        
        while (chartId >= 0)
        {
            long nextChart = ChartNext(chartId);
            ChartClose(chartId);
            closed++;
            chartId = nextChart;
        }
        
        AddLine("Closed " + IntegerToString(closed) + " chart" + (closed > 1 ? "s" : "") + ".");
    }
    else if (command == "load" || StringFind(command, "load ") == 0)
    {
        // Attach EA to current chart using MT5 internal message (same as scripts).
        string eaName = StringSubstr(cmd, 5);
        StringTrimLeft(eaName);
        StringTrimRight(eaName);
        
        if (StringLen(eaName) == 0)
        {
            AddLine("Usage: load <ea>");
            AddLine("Example: load MyExpert");
        }
        else
        {
            // Remove quotes if present.
            if (StringGetCharacter(eaName, 0) == '"' && StringGetCharacter(eaName, StringLen(eaName)-1) == '"')
                eaName = StringSubstr(eaName, 1, StringLen(eaName) - 2);
            
            AddLine("Loading: " + eaName);
            
            // Find active chart via MDI (same as unload command).
            long hwndMDI = FindWindowExW(m_hwndMT5, 0, "MDIClient", NULL);
            if (hwndMDI == 0)
            {
                AddLine("MDI client not found.");
            }
            else
            {
                long hwndActiveChild = SendMessageW(hwndMDI, WM_MDIGETACTIVE, 0, 0);
                if (hwndActiveChild == 0)
                {
                    AddLine("No active chart.");
                }
                else
                {
                    long hwndChart = GetDlgItem(hwndActiveChild, 0xE900);
                    if (hwndChart == 0)
                    {
                        AddLine("Chart control not found.");
                    }
                    else
                    {
                        // Refresh EX5 file list.
                        RefreshEX5Numbers(m_hwndMT5);
                        Sleep(50);
                        
                        // Get all EX5 files.
                        string dataPath = TerminalInfoString(TERMINAL_DATA_PATH);
                        string mql5Path = dataPath + "\\MQL5\\";
                        
                        string files[];
                        GetEX5FilesWinAPI(mql5Path + "Experts", files);
                        GetEX5FilesWinAPI(mql5Path + "Indicators", files);
                        GetEX5FilesWinAPI(mql5Path + "Scripts", files);
                        
                        int totalFiles = ArraySize(files);
                        
                        // Find our EA by name (search in Experts folder).
                        string searchName = eaName;
                        StringToLower(searchName);
                        // Normalize path separators.
                        StringReplace(searchName, "/", "\\");
                        if (StringFind(searchName, ".ex5") < 0)
                            searchName = searchName + ".ex5";
                        
                        // Check if user provided a path or just filename.
                        bool hasPath = (StringFind(searchName, "\\") >= 0);
                        
                        int eaIndex = -1;
                        for (int i = 0; i < totalFiles; i++)
                        {
                            string filePath = files[i];
                            StringToLower(filePath);
                            
                            // Check if this file is in Experts folder.
                            int expertsPos = StringFind(filePath, "\\experts\\");
                            if (expertsPos >= 0)
                            {
                                if (hasPath)
                                {
                                    // Match relative path from \experts\ folder.
                                    string relativePath = StringSubstr(filePath, expertsPos + 9);  // 9 = len("\experts\")
                                    if (relativePath == searchName)
                                    {
                                        eaIndex = i;
                                        break;
                                    }
                                }
                                else
                                {
                                    // Match just the filename.
                                    int lastSlash = -1;
                                    for (int j = StringLen(filePath) - 1; j >= 0; j--)
                                    {
                                        if (StringGetCharacter(filePath, j) == '\\')
                                        {
                                            lastSlash = j;
                                            break;
                                        }
                                    }
                                    
                                    string foundName = (lastSlash >= 0) ? StringSubstr(filePath, lastSlash + 1) : filePath;
                                    if (foundName == searchName)
                                    {
                                        eaIndex = i;
                                        break;
                                    }
                                }
                            }
                        }
                        
                        if (eaIndex < 0)
                        {
                            AddLine("EA not found: " + eaName);
                        }
                        else
                        {
                            // Register and send the internal message.
                            uint mt5Msg = RegisterWindowMessageW("MetaTrader5_Internal_Message");
                            long sendResult = SendMessageW(hwndChart, mt5Msg, 0x1D, (long)eaIndex);
                            
                            if (sendResult == 0)
                                AddLine("EA attached: " + eaName);
                            else
                                AddLine("Failed to attach EA (code: " + IntegerToString((int)sendResult) + ").");
                        }
                    }
                }
            }
        }
    }
    else if (command == "unload")
    {
        // Remove EA from current chart via Navigator TreeView.
        // Tree structure: Root(MT5) -> Accounts -> ServerName -> AccountNumber:Name -> [EAs]
        
        // Find the active chart via MDI window (ChartID() returns 0 for services).
        long currentChartId = 0;
        long hwndMDI = FindWindowExW(m_hwndMT5, 0, "MDIClient", NULL);
        if (hwndMDI == 0)
        {
            AddLine("MDI client not found.");
            return;
        }
        
        long hwndActiveChild = SendMessageW(hwndMDI, WM_MDIGETACTIVE, 0, 0);
        if (hwndActiveChild == 0)
        {
            AddLine("No active chart.");
            return;
        }
        
        // Find chart ID for active MDI child.
        long cid = ChartFirst();
        while (cid >= 0)
        {
            long chartHwnd = ChartGetInteger(cid, CHART_WINDOW_HANDLE);
            long chartParent = GetParent(chartHwnd);
            if (chartParent == hwndActiveChild)
            {
                currentChartId = cid;
                break;
            }
            cid = ChartNext(cid);
        }
        
        if (currentChartId == 0)
        {
            AddLine("Could not find active chart.");
            return;
        }
        
        string currentEA = ChartGetString(currentChartId, CHART_EXPERT_NAME);
        string currentSymbol = ChartSymbol(currentChartId);
        
        if (currentEA == "")
        {
            AddLine("No EA running on current chart.");
            return;
        }
        
        // Count charts with EAs that come before current chart to find position in Navigator.
        int targetPosition = 0;
        cid = ChartFirst();
        while (cid >= 0)
        {
            if (cid == currentChartId)
                break;
            string chartEA = ChartGetString(cid, CHART_EXPERT_NAME);
            if (chartEA != "")
                targetPosition++;
            cid = ChartNext(cid);
        }
        
        AddLine("Removing: " + currentEA + " on " + currentSymbol);
        
        // Find Navigator TreeView.
        long hTreeView = FindNavigatorTreeView(m_hwndMT5);
        if (hTreeView == 0)
        {
            AddLine("Navigator TreeView not found.");
            return;
        }
        
        // Focus the TreeView.
        SetForegroundWindow(m_hwndMT5);
        SetFocus(hTreeView);
        Sleep(20);
        
        // Level 1: Get root item (MT5 platform).
        long hRoot = SendMessageW(hTreeView, TVM_GETNEXTITEM, TVGN_ROOT, (long)0);
        if (hRoot == 0)
        {
            AddLine("TreeView root not found.");
            return;
        }
        
        // Expand root.
        SendMessageW(hTreeView, TVM_SELECTITEM, TVGN_CARET, hRoot);
        SendMessageW(hTreeView, TVM_EXPAND, TVE_EXPAND, hRoot);
        Sleep(10);
        
        // Level 2: Get first child of root (should be "Accounts").
        long hAccounts = SendMessageW(hTreeView, TVM_GETNEXTITEM, TVGN_CHILD, hRoot);
        if (hAccounts == 0)
        {
            AddLine("Accounts node not found.");
            return;
        }
        
        // Expand Accounts.
        SendMessageW(hTreeView, TVM_SELECTITEM, TVGN_CARET, hAccounts);
        SendMessageW(hTreeView, TVM_EXPAND, TVE_EXPAND, hAccounts);
        Sleep(10);
        
        // Level 3: Get first child of Accounts (server name).
        long hServer = SendMessageW(hTreeView, TVM_GETNEXTITEM, TVGN_CHILD, hAccounts);
        if (hServer == 0)
        {
            AddLine("Server node not found.");
            return;
        }
        
        // Expand server.
        SendMessageW(hTreeView, TVM_SELECTITEM, TVGN_CARET, hServer);
        SendMessageW(hTreeView, TVM_EXPAND, TVE_EXPAND, hServer);
        Sleep(10);
        
        // Level 4: Get first child of server (account number:name).
        long hAccount = SendMessageW(hTreeView, TVM_GETNEXTITEM, TVGN_CHILD, hServer);
        if (hAccount == 0)
        {
            AddLine("Account node not found.");
            return;
        }
        
        // Expand account to reveal EAs.
        SendMessageW(hTreeView, TVM_SELECTITEM, TVGN_CARET, hAccount);
        SendMessageW(hTreeView, TVM_EXPAND, TVE_EXPAND, hAccount);
        Sleep(20);
        
        // Level 5: Get first EA child.
        long hEA = SendMessageW(hTreeView, TVM_GETNEXTITEM, TVGN_CHILD, hAccount);
        
        if (hEA == 0)
        {
            AddLine("No EAs found in Navigator.");
            return;
        }
        
        // Navigate to target position.
        for (int i = 0; i < targetPosition && hEA != 0; i++)
        {
            long hNext = SendMessageW(hTreeView, TVM_GETNEXTITEM, TVGN_NEXT, hEA);
            if (hNext == 0)
                break;
            hEA = hNext;
        }
        
        // Select the target EA and open context menu.
        SendMessageW(hTreeView, TVM_SELECTITEM, TVGN_CARET, hEA);
        SetFocus(hTreeView);
        Sleep(30);
        
        // Send WM_CONTEXTMENU to TreeView.
        int tvRect[4];
        GetWindowRect(hTreeView, tvRect);
        int menuX = (tvRect[0] + tvRect[2]) / 2;
        int menuY = (tvRect[1] + tvRect[3]) / 2;
        long lParam = (menuY << 16) | (menuX & 0xFFFF);
        
        PostMessageW(hTreeView, 0x007B, (long)hTreeView, lParam);  // WM_CONTEXTMENU = 0x007B
        Sleep(50);
        
        // Press 'R' for "Remove from chart" menu item.
        PressKey('R');
        Sleep(30);
        
        AddLine("EA removed.");
        SetForegroundWindow(m_hwnd);
    }
    else if (command == "panic")
    {
        // Emergency: Remove all EAs, close all positions, delete all pending orders.
        AddLine("=== PANIC MODE ===");
        
        // 1. Remove all EAs via Navigator TreeView.
        // Tree structure: Root(MT5) -> Accounts -> ServerName -> AccountNumber:Name -> [EAs]
        int eaCount = 0;
        
        // Find Navigator TreeView.
        long hTreeView = FindNavigatorTreeView(m_hwndMT5);
        if (hTreeView != 0)
        {
            // Focus the TreeView.
            SetForegroundWindow(m_hwndMT5);
            SetFocus(hTreeView);
            Sleep(20);
            
            // Level 1: Get root item (MT5 platform).
            long hRoot = SendMessageW(hTreeView, TVM_GETNEXTITEM, TVGN_ROOT, (long)0);
            if (hRoot != 0)
            {
                // Expand root.
                SendMessageW(hTreeView, TVM_SELECTITEM, TVGN_CARET, hRoot);
                SendMessageW(hTreeView, TVM_EXPAND, TVE_EXPAND, hRoot);
                Sleep(10);
                
                // Level 2: Get first child of root (Accounts).
                long hAccounts = SendMessageW(hTreeView, TVM_GETNEXTITEM, TVGN_CHILD, hRoot);
                if (hAccounts != 0)
                {
                    // Expand Accounts.
                    SendMessageW(hTreeView, TVM_SELECTITEM, TVGN_CARET, hAccounts);
                    SendMessageW(hTreeView, TVM_EXPAND, TVE_EXPAND, hAccounts);
                    Sleep(10);
                    
                    // Level 3: Get first child of Accounts (server name).
                    long hServer = SendMessageW(hTreeView, TVM_GETNEXTITEM, TVGN_CHILD, hAccounts);
                    if (hServer != 0)
                    {
                        // Expand server.
                        SendMessageW(hTreeView, TVM_SELECTITEM, TVGN_CARET, hServer);
                        SendMessageW(hTreeView, TVM_EXPAND, TVE_EXPAND, hServer);
                        Sleep(10);
                        
                        // Level 4: Get first child of server (account).
                        long hAccount = SendMessageW(hTreeView, TVM_GETNEXTITEM, TVGN_CHILD, hServer);
                        if (hAccount != 0)
                        {
                            // Expand account to reveal EAs.
                            SendMessageW(hTreeView, TVM_SELECTITEM, TVGN_CARET, hAccount);
                            SendMessageW(hTreeView, TVM_EXPAND, TVE_EXPAND, hAccount);
                            Sleep(20);
                            
                            // Count EAs first.
                            int totalEAs = 0;
                            long hEA = SendMessageW(hTreeView, TVM_GETNEXTITEM, TVGN_CHILD, hAccount);
                            while (hEA != 0)
                            {
                                totalEAs++;
                                hEA = SendMessageW(hTreeView, TVM_GETNEXTITEM, TVGN_NEXT, hEA);
                            }
                            
                            // Get TreeView rect for context menu position.
                            int tvRect[4];
                            GetWindowRect(hTreeView, tvRect);
                            int menuX = (tvRect[0] + tvRect[2]) / 2;
                            int menuY = (tvRect[1] + tvRect[3]) / 2;
                            long lParam = (menuY << 16) | (menuX & 0xFFFF);
                            
                            // Remove all EAs (always delete first child repeatedly).
                            for (int i = 0; i < totalEAs; i++)
                            {
                                hEA = SendMessageW(hTreeView, TVM_GETNEXTITEM, TVGN_CHILD, hAccount);
                                if (hEA == 0)
                                    break;
                                
                                // Select the EA and open context menu.
                                SendMessageW(hTreeView, TVM_SELECTITEM, TVGN_CARET, hEA);
                                SetFocus(hTreeView);
                                Sleep(30);
                                
                                // Send WM_CONTEXTMENU.
                                PostMessageW(hTreeView, 0x007B, (long)hTreeView, lParam);
                                Sleep(50);
                                
                                // Press 'R' for "Remove from chart".
                                PressKey('R');
                                Sleep(30);
                                
                                eaCount++;
                            }
                        }
                    }
                }
            }
        }
        
        // Return focus to console.
        SetForegroundWindow(m_hwnd);
        
        AddLine("EAs removed: " + IntegerToString(eaCount));
        
        // 2. Close all positions.
        int posCount = 0;
        CTrade trade;
        
        for (int i = PositionsTotal() - 1; i >= 0; i--)
        {
            ulong ticket = PositionGetTicket(i);
            if (ticket > 0)
            {
                if (trade.PositionClose(ticket))
                    posCount++;
            }
        }
        AddLine("Positions closed: " + IntegerToString(posCount));
        
        // 3. Delete all pending orders.
        int ordCount = 0;
        for (int i = OrdersTotal() - 1; i >= 0; i--)
        {
            ulong ticket = OrderGetTicket(i);
            if (ticket > 0)
            {
                if (trade.OrderDelete(ticket))
                    ordCount++;
            }
        }
        AddLine("Orders deleted: " + IntegerToString(ordCount));
        
        AddLine("=== PANIC COMPLETE ===");
    }
    else if (command == "hide" || StringFind(command, "hide ") == 0 || command == "show" || StringFind(command, "show ") == 0)
    {
        // Hide/show chart elements.
        bool showMode = (command == "show" || StringFind(command, "show ") == 0);
        int cmdLen = (command == "hide" || command == "show") ? 4 : 5;
        string what = StringSubstr(command, cmdLen);
        StringTrimLeft(what);
        StringTrimRight(what);
        
        long chartId = ChartFirst();
        if (m_currentChartId != 0)
            chartId = m_currentChartId;
        
        if (what == "history")
        {
            ChartSetInteger(chartId, CHART_SHOW_TRADE_HISTORY, showMode);
            AddLine(string(showMode ? "Showing" : "Hiding") + " trade history");
        }
        else if (what == "trade" || what == "trades" || what == "trade levels" || what == "levels")
        {
            ChartSetInteger(chartId, CHART_SHOW_TRADE_LEVELS, showMode);
            AddLine(string(showMode ? "Showing" : "Hiding") + " trade levels");
        }
        else if (what == "volume" || what == "volumes")
        {
            ChartSetInteger(chartId, CHART_SHOW_VOLUMES, showMode ? CHART_VOLUME_TICK : CHART_VOLUME_HIDE);
            AddLine(string(showMode ? "Showing" : "Hiding") + " tick volume");
        }
        else if (what == "grid")
        {
            ChartSetInteger(chartId, CHART_SHOW_GRID, showMode);
            AddLine(string(showMode ? "Showing" : "Hiding") + " grid");
        }
        else if (what == "quick" || what == "quicktrading" || what == "quick trading")
        {
            ChartSetInteger(chartId, CHART_SHOW_ONE_CLICK, showMode);
            AddLine(string(showMode ? "Showing" : "Hiding") + " quick trading");
        }
        else
        {
            AddLine("Usage: hide/show history|trade|volume|grid|quick");
        }
        ChartRedraw(chartId);
    }
    else if (StringFind(command, "chartcolors") == 0 || StringFind(command, "chartcolor") == 0)
    {
        // Chart color schemes.
        string scheme = "";
        if (StringFind(command, "chartcolors ") == 0)
            scheme = StringSubstr(cmd, 12);
        else if (StringFind(command, "chartcolor ") == 0)
            scheme = StringSubstr(cmd, 11);
        
        StringTrimLeft(scheme);
        StringTrimRight(scheme);
        StringToLower(scheme);
        
        long chartId = ChartFirst();
        if (m_currentChartId != 0)
            chartId = m_currentChartId;
        
        if (scheme == "green" || scheme == "1")
        {
            // Green on Black (matches MT5 built-in preset).
            ChartSetInteger(chartId, CHART_COLOR_BACKGROUND, clrBlack);
            ChartSetInteger(chartId, CHART_COLOR_FOREGROUND, clrWhite);
            ChartSetInteger(chartId, CHART_COLOR_GRID, clrLightSlateGray);
            ChartSetInteger(chartId, CHART_COLOR_CHART_UP, clrLime);
            ChartSetInteger(chartId, CHART_COLOR_CHART_DOWN, clrLime);
            ChartSetInteger(chartId, CHART_COLOR_CANDLE_BULL, clrBlack);
            ChartSetInteger(chartId, CHART_COLOR_CANDLE_BEAR, clrWhite);
            ChartSetInteger(chartId, CHART_COLOR_CHART_LINE, clrLime);
            ChartSetInteger(chartId, CHART_COLOR_VOLUME, clrLimeGreen);
            ChartSetInteger(chartId, CHART_COLOR_BID, clrLightSlateGray);
            ChartSetInteger(chartId, CHART_COLOR_ASK, clrRed);
            ChartSetInteger(chartId, CHART_COLOR_LAST, clrLime);
            ChartSetInteger(chartId, CHART_COLOR_STOP_LEVEL, clrRed);
            AddLine("Applied: Green on Black");
        }
        else if (scheme == "bw" || scheme == "2")
        {
            // Black on White.
            ChartSetInteger(chartId, CHART_COLOR_BACKGROUND, clrWhite);
            ChartSetInteger(chartId, CHART_COLOR_FOREGROUND, clrBlack);
            ChartSetInteger(chartId, CHART_COLOR_GRID, clrSilver);
            ChartSetInteger(chartId, CHART_COLOR_CHART_UP, clrBlack);
            ChartSetInteger(chartId, CHART_COLOR_CHART_DOWN, clrBlack);
            ChartSetInteger(chartId, CHART_COLOR_CANDLE_BULL, clrWhite);
            ChartSetInteger(chartId, CHART_COLOR_CANDLE_BEAR, clrBlack);
            ChartSetInteger(chartId, CHART_COLOR_CHART_LINE, clrBlack);
            ChartSetInteger(chartId, CHART_COLOR_VOLUME, clrGreen);
            ChartSetInteger(chartId, CHART_COLOR_BID, clrGray);
            ChartSetInteger(chartId, CHART_COLOR_ASK, clrGray);
            ChartSetInteger(chartId, CHART_COLOR_LAST, clrBlack);
            ChartSetInteger(chartId, CHART_COLOR_STOP_LEVEL, clrRed);
            AddLine("Applied: Black on White");
        }
        else if (scheme == "yellow" || scheme == "3")
        {
            // Yellow on Black (Custom - similar to Amber).
            ChartSetInteger(chartId, CHART_COLOR_BACKGROUND, clrBlack);
            ChartSetInteger(chartId, CHART_COLOR_FOREGROUND, clrWhite);
            ChartSetInteger(chartId, CHART_COLOR_GRID, clrLightSlateGray);
            ChartSetInteger(chartId, CHART_COLOR_CHART_UP, clrYellow);
            ChartSetInteger(chartId, CHART_COLOR_CHART_DOWN, clrYellow);
            ChartSetInteger(chartId, CHART_COLOR_CANDLE_BULL, clrBlack);
            ChartSetInteger(chartId, CHART_COLOR_CANDLE_BEAR, clrWhite);
            ChartSetInteger(chartId, CHART_COLOR_CHART_LINE, clrYellow);
            ChartSetInteger(chartId, CHART_COLOR_VOLUME, clrLimeGreen);
            ChartSetInteger(chartId, CHART_COLOR_BID, clrLightSlateGray);
            ChartSetInteger(chartId, CHART_COLOR_ASK, clrRed);
            ChartSetInteger(chartId, CHART_COLOR_LAST, C'0,192,0');
            ChartSetInteger(chartId, CHART_COLOR_STOP_LEVEL, clrRed);
            AddLine("Applied: Yellow on Black");
        }
        else if (scheme == "color" || scheme == "4")
        {
            // Color on White (MT5 default colorful).
            // Bull: RGB(38,166,154), Bear: RGB(239,83,80)
            ChartSetInteger(chartId, CHART_COLOR_BACKGROUND, clrWhite);
            ChartSetInteger(chartId, CHART_COLOR_FOREGROUND, clrBlack);
            ChartSetInteger(chartId, CHART_COLOR_GRID, clrSilver);
            ChartSetInteger(chartId, CHART_COLOR_CHART_UP, C'38,166,154');
            ChartSetInteger(chartId, CHART_COLOR_CHART_DOWN, C'239,83,80');
            ChartSetInteger(chartId, CHART_COLOR_CANDLE_BULL, C'38,166,154');
            ChartSetInteger(chartId, CHART_COLOR_CANDLE_BEAR, C'239,83,80');
            ChartSetInteger(chartId, CHART_COLOR_CHART_LINE, C'38,166,154');
            ChartSetInteger(chartId, CHART_COLOR_VOLUME, clrGreen);
            ChartSetInteger(chartId, CHART_COLOR_BID, C'38,166,154');
            ChartSetInteger(chartId, CHART_COLOR_ASK, C'239,83,80');
            ChartSetInteger(chartId, CHART_COLOR_LAST, clrBlack);
            ChartSetInteger(chartId, CHART_COLOR_STOP_LEVEL, C'239,83,80');
            AddLine("Applied: Color on White");
        }
        else
        {
            AddLine("Usage: chartcolors <scheme>");
            AddLine("Schemes: green, bw, yellow, color (or 1-4)");
        }
        ChartRedraw(chartId);
    }
    else if (command == "darkmode" || command == "dm")
    {
        SetColorScheme(2, "Dark");
    }
    else if (command == "lightmode" || command == "lm")
    {
        SetColorScheme(1, "Light");
    }
    else if (command == "systemmode" || command == "sysmode" || command == "sm")
    {
        SetColorScheme(0, "System");
    }
    else if (StringLen(command) > 0)
    {
        AddLine("Unknown: " + cmd);
    }
    
    AddLine("");
}

//+------------------------------------------------------------------+
//| Update breathing animation.                                      |
//+------------------------------------------------------------------+
void CWindowsConsole::UpdateBreathing()
{
    if (!m_breathingMode)
        return;
    
    uint now = GetTickCount();
    uint elapsed = now - m_breathingStart;
    uint phaseElapsed = now - m_breathingPhaseStart;
    
    // Check if breathing exercise is complete.
    if (elapsed >= (uint)(m_breathingDuration * 1000))
    {
        // End breathing mode.
        m_breathingMode = false;
        EnableWindow(m_hwndMT5, true);
        ShowWindow(m_hwndMT5, 9);  // SW_RESTORE
        SetForegroundWindow(m_hwndMT5);
        
        ArrayResize(m_lines, 0);
        m_scrollOffset = 0;
        AddLine("");
        AddLine("  Breathing exercise complete!");
        AddLine("  Platform unlocked.");
        AddLine("");
        ForceRedraw();
        return;
    }
    
    // Phase timing: 4s inhale, 4s exhale (no hold).
    int phaseDuration = 4000;  // 4 seconds per phase
    
    if (phaseElapsed >= (uint)phaseDuration)
    {
        m_breathingPhase = (m_breathingPhase + 1) % 2;  // 2 phases only
        m_breathingPhaseStart = now;
        phaseElapsed = 0;
    }
    
    // Calculate animation frame (0-100% through phase).
    int progress = (int)((phaseElapsed * 100) / phaseDuration);
    
    // Build ASCII animation.
    string phaseText = "";
    string sizeText = "";
    int size = 0;
    
    if (m_breathingPhase == 0)  // Inhale.
    {
        phaseText = "   B R E A T H E   I N . . .";
        size = 1 + (progress * 4 / 100);  // 1 to 5
    }
    else  // Exhale.
    {
        phaseText = "  B R E A T H E   O U T . . .";
        size = 5 - (progress * 4 / 100);  // 5 to 1
        if (size < 1) size = 1;
    }
    
    // Create expanding/contracting circle with fixed 5-line placeholder.
    string circle1 = "", circle2 = "", circle3 = "", circle4 = "", circle5 = "";
    
     if (size == 1)
     {
          circle1 = "";
          circle2 = "";
          circle3 = "             ●";
          circle4 = "";
          circle5 = "";
     }
    else if (size == 2)
     {
        circle1 = "";
        circle2 = "            ●●●";
        circle3 = "            ●●●";
        circle4 = "            ●●●";
        circle5 = "";
    }
    else if (size == 3)
     {
        circle1 = "";
        circle2 = "           ●●●●●";
        circle3 = "          ●●●●●●●";
        circle4 = "           ●●●●●";
        circle5 = "";
    }
    else if (size == 4)
     {
        circle1 = "          ●●●●●●●";
        circle2 = "         ●●●●●●●●●";
        circle3 = "        ●●●●●●●●●●●";
        circle4 = "         ●●●●●●●●●";
        circle5 = "          ●●●●●●●";
    }
    else {  // size >= 5
        circle1 = "         ●●●●●●●●●";
        circle2 = "       ●●●●●●●●●●●●●";
        circle3 = "      ●●●●●●●●●●●●●●●";
        circle4 = "       ●●●●●●●●●●●●●";
        circle5 = "         ●●●●●●●●●";
    }
    
    // Time remaining.
    int remaining = m_breathingDuration - (int)(elapsed / 1000);
    string timeText = "      Time remaining: " + IntegerToString(remaining) + "s";
    
    // Update display.
    ArrayResize(m_lines, 0);
    m_scrollOffset = 0;
    
    AddLine("");
    AddLine("  ╔════════════════════════════════════════╗");
    AddLine("  ║       BREATHING EXERCISE ACTIVE        ║");
    AddLine("  ╚════════════════════════════════════════╝");
    AddLine("");
    AddLine(phaseText);
    AddLine("");
    AddLine(circle1);
    AddLine(circle2);
    AddLine(circle3);
    AddLine(circle4);
    AddLine(circle5);
    AddLine("");
    AddLine(timeText);
    AddLine("");
    AddLine("        Press ESC to stop early");
    
    ForceRedraw();
}

//+------------------------------------------------------------------+
//| Update shutdown countdown.                                       |
//+------------------------------------------------------------------+
void CWindowsConsole::UpdateShutdown()
{
    if (!m_shutdownPending)
    {
        return;
    }
    
    uint now = GetTickCount();
    uint elapsed = now - m_shutdownStart;
    int remaining = m_shutdownDuration - (int)(elapsed / 1000);
    
    // Check if shutdown time reached.
    if (remaining <= 0)
    {
        m_shutdownPending = false;
        AddLine("Shutting down MT5...");
        ForceRedraw();
        Sleep(500);  // Brief pause so message is visible.
        TerminalClose(0);
        return;
    }
    
    // Show 1-minute warning (only once, only if duration > 60s).
    if (!m_shutdownWarned && remaining <= 60)
    {
        m_shutdownWarned = true;
        AddLine("Shutting down in 1 minute.");
        ForceRedraw();
    }
    
    // Countdown for last 10 seconds (or less if duration was shorter).
    if (remaining <= 10 && remaining != m_lastCountdown)
    {
        m_lastCountdown = remaining;
        AddLine("Shutdown in " + IntegerToString(remaining) + "...");
        ForceRedraw();
    }
}

//+------------------------------------------------------------------+
//| Refresh EX5 numbers in MT5.                                      |
//+------------------------------------------------------------------+
void RefreshEX5Numbers(long hwndTerminal)
{
    uint mt5Msg = RegisterWindowMessageW("MetaTrader5_Internal_Message");
    
    // Send refresh commands.
    SendMessageW(hwndTerminal, WM_COMMAND, 0x8288, 0);
    
    uchar codes[] = {0x01, 0x02, 0x03, 0x1A, 0x04};
    for (int i = 0; i < ArraySize(codes); i++)
        SendMessageW(hwndTerminal, mt5Msg, codes[i], 0);
}

//+------------------------------------------------------------------+
//| Get EX5 files using Windows API (more reliable).                 |
//+------------------------------------------------------------------+
int GetEX5FilesWinAPI(string folder, string &files[])
{
    int count = 0;
    WIN32_FIND_DATAW findData;
    
    long hFind = FindFirstFileW(folder + "\\*", findData);
    if (hFind == INVALID_HANDLE)
        return 0;
    
    do
    {
        string fileName = ShortArrayToString(findData.cFileName);
        if (fileName == "." || fileName == "..")
            continue;
        
        string fullPath = folder + "\\" + fileName;
        
        if ((findData.dwFileAttributes & 0x10) != 0)  // FILE_ATTRIBUTE_DIRECTORY
        {
            // Recurse into subdirectory.
            count += GetEX5FilesWinAPI(fullPath, files);
        }
        else
        {
            string ext = "";
            if (StringLen(fileName) > 4)
                ext = StringSubstr(fileName, StringLen(fileName) - 4);
            StringToLower(ext);
            
            if (ext == ".ex5")
            {
                int size = ArraySize(files);
                ArrayResize(files, size + 1);
                files[size] = fullPath;
                count++;
            }
        }
    }
    while (FindNextFileW(hFind, findData));
    
    FindClose(hFind);
    return count;
}

//+------------------------------------------------------------------+
//| Delete folder contents recursively (files and subfolders).       |
//+------------------------------------------------------------------+
int DeleteFolderContents(string folder)
{
    int deleted = 0;
    WIN32_FIND_DATAW findData;
    
    long hFind = FindFirstFileW(folder + "\\*", findData);
    if (hFind == INVALID_HANDLE || hFind == -1)
        return 0;
    
    do
    {
        string fileName = ShortArrayToString(findData.cFileName);
        if (fileName == "." || fileName == "..")
            continue;
        
        string fullPath = folder + "\\" + fileName;
        
        if ((findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0)
        {
            // Recursively delete subdirectory contents first.
            deleted += DeleteFolderContents(fullPath);
            // Then remove the empty directory.
            if (RemoveDirectoryW(fullPath))
                deleted++;
        }
        else
        {
            if (DeleteFileW(fullPath))
                deleted++;
        }
    }
    while (FindNextFileW(hFind, findData));
    
    FindClose(hFind);
    return deleted;
}

//+------------------------------------------------------------------+
//| Collect EX5 file names recursively (without extension).          |
//+------------------------------------------------------------------+
void CollectEX5Names(string folder, string &names[])
{
    WIN32_FIND_DATAW findData;
    long hFind = FindFirstFileW(folder + "\\*", findData);
    if (hFind == INVALID_HANDLE || hFind == -1)
        return;
    
    do
    {
        string fileName = ShortArrayToString(findData.cFileName);
        
        // Strip any control characters including newlines.
        string cleanName = "";
        for (int c = 0; c < StringLen(fileName); c++)
        {
            ushort ch = StringGetCharacter(fileName, c);
            if (ch >= 32 && ch < 127)  // printable ASCII only
                cleanName += CharToString((uchar)ch);
        }
        fileName = cleanName;
        
        if (fileName == "." || fileName == "..")
            continue;
        
        if (StringLen(fileName) == 0)
            continue;
        
        string fullPath = folder + "\\" + fileName;
        
        if ((findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0)
        {
            // Recurse into subdirectory.
            CollectEX5Names(fullPath, names);
        }
        else
        {
            // Check for .ex5 extension.
            if (StringLen(fileName) > 4)
            {
                string ext = StringSubstr(fileName, StringLen(fileName) - 4);
                StringToLower(ext);
                if (ext == ".ex5")
                {
                    // Add name without extension.
                    string nameOnly = StringSubstr(fileName, 0, StringLen(fileName) - 4);
                    StringTrimLeft(nameOnly);
                    StringTrimRight(nameOnly);
                    if (StringLen(nameOnly) > 0)
                    {
                        int size = ArraySize(names);
                        ArrayResize(names, size + 1);
                        names[size] = nameOnly;
                    }
                }
            }
        }
    }
    while (FindNextFileW(hFind, findData));
    
    FindClose(hFind);
}

//+------------------------------------------------------------------+
//| Format array of strings into columns.                            |
//+------------------------------------------------------------------+
void FormatInColumns(string &items[], string prefix, string &output[])
{
    // First, collect only valid (non-empty, printable) items.
    string validItems[];
    int validCount = 0;
    
    for (int i = 0; i < ArraySize(items); i++)
    {
        // Strip control characters.
        string item = "";
        for (int c = 0; c < StringLen(items[i]); c++)
        {
            ushort ch = StringGetCharacter(items[i], c);
            if (ch >= 32 && ch < 127)
                item += CharToString((uchar)ch);
        }
        StringTrimLeft(item);
        StringTrimRight(item);
        if (StringLen(item) > 0)
        {
            ArrayResize(validItems, validCount + 1);
            validItems[validCount] = item;
            validCount++;
        }
    }
    
    if (validCount == 0) return;
    
    // Find max length.
    int maxLen = 0;
    for (int i = 0; i < validCount; i++)
    {
        int len = StringLen(validItems[i]);
        if (len > maxLen)
            maxLen = len;
    }
    
    // Add padding between columns.
    int colWidth = maxLen + 2;
    if (colWidth < 3) colWidth = 3;
    
    // Console width approximately 95 chars, minus prefix.
    int consoleWidth = 95 - StringLen(prefix);
    int numCols = consoleWidth / colWidth;
    if (numCols < 1) numCols = 1;
    if (numCols > validCount) numCols = validCount;
    
    // Build output lines.
    ArrayResize(output, 0);
    int outputCount = 0;
    string line = prefix;
    int col = 0;
    
    for (int i = 0; i < validCount; i++)
    {
        // Pad item to column width.
        string paddedItem = validItems[i];
        while (StringLen(paddedItem) < colWidth)
            paddedItem += " ";
        
        line += paddedItem;
        col++;
        
        // Check if we need to start a new row.
        if (col >= numCols || i == validCount - 1)
        {
            // Trim trailing whitespace from line.
            StringTrimRight(line);
            
            // Only add non-empty lines.
            if (StringLen(line) > 0)
            {
                ArrayResize(output, outputCount + 1);
                output[outputCount] = line;
                outputCount++;
            }
            
            line = prefix;
            col = 0;
        }
    }
}

//+------------------------------------------------------------------+
//| Run EX5 file using MT5 internal message.                         |
//+------------------------------------------------------------------+
bool RunEX5(long hwndTerminal, string scriptName, string &result)
{
    // Get chart window handle using the proper method from MTTester.
    // First get the MDI client area (0xE900)
    long hwndMDI = GetDlgItem(hwndTerminal, 0xE900);
    if (hwndMDI == 0)
    {
        result = "MDI client not found.";
        return false;
    }
    
    // Get first chart window (0xFF00)
    long hwndChartFrame = GetDlgItem(hwndMDI, 0xFF00);
    if (hwndChartFrame == 0)
    {
        result = "No chart window found.";
        return false;
    }
    
    // Get the actual chart control (0xE900 inside chart frame).
    long hwndChart = GetDlgItem(hwndChartFrame, 0xE900);
    if (hwndChart == 0)
    {
        result = "Chart control not found.";
        return false;
    }
    
    result = "Chart HWND: " + IntegerToString(hwndChart);
    
    // Refresh EX5 file list.
    RefreshEX5Numbers(hwndTerminal);
    Sleep(50);
    
    // Get all EX5 files.
    string dataPath = TerminalInfoString(TERMINAL_DATA_PATH);
    string mql5Path = dataPath + "\\MQL5\\";
    
    string files[];
    GetEX5FilesWinAPI(mql5Path + "Experts", files);
    GetEX5FilesWinAPI(mql5Path + "Indicators", files);
    GetEX5FilesWinAPI(mql5Path + "Scripts", files);
    
    int totalFiles = ArraySize(files);
    result += ", " + IntegerToString(totalFiles) + " EX5 files";
    
    // Find our script by name (exact match).
    string searchName = scriptName;
    StringToLower(searchName);
    
    int scriptIndex = -1;
    for (int i = 0; i < totalFiles; i++)
    {
        string filePath = files[i];
        StringToLower(filePath);
        
        // Check if this file matches our script name (exact match at end of path).
        if (StringFind(filePath, "\\scripts\\" + searchName + ".ex5") >= 0)
        {
            // Verify it's an exact match (not just substring).
            int pos = StringFind(filePath, "\\scripts\\");
            if (pos >= 0)
            {
                string foundName = StringSubstr(filePath, pos + 9);  // Skip "\scripts\"
                foundName = StringSubstr(foundName, 0, StringLen(foundName) - 4);  // Remove ".ex5"
                if (foundName == searchName)
                {
                    scriptIndex = i;
                    result += ", Index=" + IntegerToString(i);
                    break;
                }
            }
        }
    }
    
    if (scriptIndex < 0)
    {
        result += ", '" + scriptName + "' not found.";
        return false;
    }
    
    // Register the internal message.
    uint mt5Msg = RegisterWindowMessageW("MetaTrader5_Internal_Message");
    
    // Send the run command: wParam=0x1D, lParam=scriptIndex.
    // Message goes to the chart window!
    long sendResult = SendMessageW(hwndChart, mt5Msg, 0x1D, (long)scriptIndex);
    result += ", Result=" + IntegerToString((int)sendResult);
    
    return (sendResult == 0);  // Returns 0 on success.
}

//+------------------------------------------------------------------+
//| Attach custom indicator via Insert menu Custom submenu.           |
//+------------------------------------------------------------------+
bool AttachCustomIndicator(long hwndTerminal, string indicatorName, string &result)
{
    // Get main menu bar.
    long hMenu = GetMenu(hwndTerminal);
    if (hMenu == 0)
    {
        result = "Failed to get menu bar.";
        return false;
    }
    
    // Find Insert menu.
    int menuCount = GetMenuItemCount(hMenu);
    long hInsertMenu = 0;
    
    for (int i = 0; i < menuCount; i++)
    {
        ushort menuText[64];
        ArrayInitialize(menuText, 0);
        GetMenuStringW(hMenu, i, menuText, 64, MF_BYPOSITION);
        string menuName = ShortArrayToString(menuText);
        
        if (StringFind(menuName, "Insert") >= 0 || StringFind(menuName, "nsert") >= 0)
        {
            hInsertMenu = GetSubMenu(hMenu, i);
            break;
        }
    }
    
    if (hInsertMenu == 0)
    {
        result = "Insert menu not found.";
        return false;
    }
    
    // Find Indicators submenu.
    long hIndicatorsMenu = 0;
    int insertCount = GetMenuItemCount(hInsertMenu);
    
    for (int i = 0; i < insertCount; i++)
    {
        ushort menuText[64];
        ArrayInitialize(menuText, 0);
        GetMenuStringW(hInsertMenu, i, menuText, 64, MF_BYPOSITION);
        string menuName = ShortArrayToString(menuText);
        
        if (StringFind(menuName, "Indicator") >= 0)
        {
            hIndicatorsMenu = GetSubMenu(hInsertMenu, i);
            break;
        }
    }
    
    if (hIndicatorsMenu == 0)
    {
        result = "Indicators submenu not found.";
        return false;
    }
    
    // Find Custom submenu in Indicators menu.
    long hCustomMenu = 0;
    int indCount = GetMenuItemCount(hIndicatorsMenu);
    
    for (int i = 0; i < indCount; i++)
    {
        ushort menuText[64];
        ArrayInitialize(menuText, 0);
        GetMenuStringW(hIndicatorsMenu, i, menuText, 64, MF_BYPOSITION);
        string menuName = ShortArrayToString(menuText);
        
        if (StringFind(menuName, "Custom") >= 0)
        {
            hCustomMenu = GetSubMenu(hIndicatorsMenu, i);
            break;
        }
    }
    
    if (hCustomMenu == 0)
    {
        result = "Custom indicators submenu not found.";
        return false;
    }
    
    // Search for the indicator in Custom menu (may be nested in subfolders).
    string searchName = indicatorName;
    StringToLower(searchName);
    
    uint cmdId = FindIndicatorInMenu(hCustomMenu, searchName);
    
    if (cmdId == 0 || cmdId == 0xFFFFFFFF)
    {
        result = "Indicator '" + indicatorName + "' not found in Custom menu.";
        return false;
    }
    
    // Send command to open indicator dialog.
    PostMessageW(hwndTerminal, WM_COMMAND, (int)cmdId, 0);
    result = "Command sent.";
    return true;
}

//+------------------------------------------------------------------+
//| Recursively search for indicator in menu by name.                 |
//+------------------------------------------------------------------+
uint FindIndicatorInMenu(long hMenu, string searchName)
{
    int itemCount = GetMenuItemCount(hMenu);
    
    for (int i = 0; i < itemCount; i++)
    {
        ushort menuText[128];
        ArrayInitialize(menuText, 0);
        GetMenuStringW(hMenu, i, menuText, 128, MF_BYPOSITION);
        string menuName = ShortArrayToString(menuText);
        string menuNameLower = menuName;
        StringToLower(menuNameLower);
        
        // Check if this is a submenu.
        long hSubMenu = GetSubMenu(hMenu, i);
        if (hSubMenu != 0)
        {
            // Recurse into submenu.
            uint found = FindIndicatorInMenu(hSubMenu, searchName);
            if (found != 0 && found != 0xFFFFFFFF)
                return found;
        }
        else
        {
            // Check if item name matches.
            if (StringFind(menuNameLower, searchName) >= 0)
            {
                return GetMenuItemID(hMenu, i);
            }
        }
    }
    
    return 0;
}

//+------------------------------------------------------------------+
//| Convert string to color with smart detection.                     |
//| Supports: color names, 0xRRGGBB, #RRGGBB, RRGGBB formats.         |
//+------------------------------------------------------------------+
color CustomStringToColor(string colorStr, color defaultColor = clrRed)
{
    if (StringLen(colorStr) == 0)
        return defaultColor;
    
    string s = colorStr;
    StringToLower(s);
    StringTrimLeft(s);
    StringTrimRight(s);
    
    // Check for hex format: 0xRRGGBB or #RRGGBB or just RRGGBB.
    if (StringFind(s, "0x") == 0)
        s = StringSubstr(s, 2);
    else if (StringFind(s, "#") == 0)
        s = StringSubstr(s, 1);
    
    // Try to parse as hex if it looks like hex (6 hex chars).
    if (StringLen(s) == 6)
    {
        bool isHex = true;
        for (int i = 0; i < 6; i++)
        {
            ushort ch = StringGetCharacter(s, i);
            if (!((ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f')))
            {
                isHex = false;
                break;
            }
        }
        
        if (isHex)
        {
            // Parse hex RRGGBB - note: MQL5 color is BGR internally.
            int r = 0, g = 0, b = 0;
            
            // Parse RR.
            string rStr = StringSubstr(s, 0, 2);
            string gStr = StringSubstr(s, 2, 2);
            string bStr = StringSubstr(s, 4, 2);
            
            for (int i = 0; i < 2; i++)
            {
                ushort ch = StringGetCharacter(rStr, i);
                r = r * 16 + (ch >= 'a' ? ch - 'a' + 10 : ch - '0');
                ch = StringGetCharacter(gStr, i);
                g = g * 16 + (ch >= 'a' ? ch - 'a' + 10 : ch - '0');
                ch = StringGetCharacter(bStr, i);
                b = b * 16 + (ch >= 'a' ? ch - 'a' + 10 : ch - '0');
            }
            
            // MQL5 color is 0x00BBGGRR.
            return (color)((b << 16) | (g << 8) | r);
        }
    }
    
    // Try standard color names.
    if (s == "red")             return clrRed;
    if (s == "green")           return clrLime;
    if (s == "blue")            return clrDodgerBlue;
    if (s == "yellow")          return clrYellow;
    if (s == "white")           return clrWhite;
    if (s == "black")           return clrBlack;
    if (s == "gray" || s == "grey") return clrGray;
    if (s == "orange")          return clrOrange;
    if (s == "cyan" || s == "aqua") return clrCyan;
    if (s == "magenta" || s == "pink" || s == "fuchsia") return clrMagenta;
    if (s == "purple")          return clrPurple;
    if (s == "gold")            return clrGold;
    if (s == "silver")          return clrSilver;
    if (s == "lime")            return clrLime;
    if (s == "navy")            return clrNavy;
    if (s == "maroon")          return clrMaroon;
    if (s == "olive")           return clrOlive;
    if (s == "teal")            return clrTeal;
    if (s == "brown")           return clrBrown;
    if (s == "coral")           return clrCoral;
    if (s == "salmon")          return clrSalmon;
    if (s == "tomato")          return clrTomato;
    if (s == "chocolate")       return clrChocolate;
    if (s == "crimson")         return clrCrimson;
    if (s == "darkblue")        return clrDarkBlue;
    if (s == "darkgreen")       return clrDarkGreen;
    if (s == "darkred")         return clrDarkRed;
    if (s == "darkorange")      return clrDarkOrange;
    if (s == "deeppink")        return clrDeepPink;
    if (s == "firebrick")       return clrFireBrick;
    if (s == "forestgreen")     return clrForestGreen;
    if (s == "hotpink")         return clrHotPink;
    if (s == "indigo")          return clrIndigo;
    if (s == "khaki")           return clrKhaki;
    if (s == "lavender")        return clrLavender;
    if (s == "lightblue")       return clrLightBlue;
    if (s == "lightgreen")      return clrLightGreen;
    if (s == "lightgray" || s == "lightgrey") return clrLightGray;
    if (s == "lightpink")       return clrLightPink;
    if (s == "limegreen")       return clrLimeGreen;
    if (s == "mediumblue")      return clrMediumBlue;
    if (s == "midnightblue")    return clrMidnightBlue;
    if (s == "orangered")       return clrOrangeRed;
    if (s == "orchid")          return clrOrchid;
    if (s == "plum")            return clrPlum;
    if (s == "royalblue")       return clrRoyalBlue;
    if (s == "seagreen")        return clrSeaGreen;
    if (s == "sienna")          return clrSienna;
    if (s == "skyblue")         return clrSkyBlue;
    if (s == "slateblue")       return clrSlateBlue;
    if (s == "slategray" || s == "slategrey") return clrSlateGray;
    if (s == "springgreen")     return clrSpringGreen;
    if (s == "steelblue")       return clrSteelBlue;
    if (s == "tan")             return clrTan;
    if (s == "turquoise")       return clrTurquoise;
    if (s == "violet")          return clrViolet;
    if (s == "wheat")           return clrWheat;
    if (s == "yellowgreen")     return clrYellowGreen;
    
    // Try MQL5 StringToColor as fallback (handles "clrRed", "C'255,0,0'" formats).
    color c = StringToColor(colorStr);
    if (c != 0 || colorStr == "0" || StringFind(colorStr, "black") >= 0)
        return c;
    
    return defaultColor;
}

//+------------------------------------------------------------------+
//| Get window class name as string.                                 |
//+------------------------------------------------------------------+
string GetWindowClassName(long hWnd)
{
    ushort className[256];
    ArrayInitialize(className, 0);
    int len = GetClassNameW(hWnd, className, 256);
    if (len > 0)
        return ShortArrayToString(className, 0, len);
    return "";
}

//+------------------------------------------------------------------+
//| Get window text as string.                                       |
//+------------------------------------------------------------------+
string GetWindowText(long hWnd)
{
    int textLen = GetWindowTextLengthW(hWnd);
    if (textLen <= 0) return "";
    
    ushort windowText[512];
    ArrayInitialize(windowText, 0);
    int len = GetWindowTextW(hWnd, windowText, 512);
    if (len > 0)
        return ShortArrayToString(windowText, 0, len);
    return "";
}

//+------------------------------------------------------------------+
//| Find Navigator control bar by title.                             |
//+------------------------------------------------------------------+
long FindNavigatorWindow(long hParent)
{
    long hChild = GetWindow(hParent, GW_CHILD);
    while (hChild != 0)
    {
        string windowText = GetWindowText(hChild);
        
        // Check if this is the Navigator.
        if (windowText == "Navigator")
            return hChild;
        
        // Check children recursively.
        long found = FindNavigatorWindow(hChild);
        if (found != 0)
            return found;
        
        hChild = GetWindow(hChild, GW_HWNDNEXT);
    }
    return 0;
}

//+------------------------------------------------------------------+
//| Recursively find TreeView control.                               |
//+------------------------------------------------------------------+
long FindTreeViewRecursive(long hParent, int depth)
{
    if (depth > 10) return 0;  // Prevent infinite recursion.
    
    // Use GetWindow instead of FindWindowExW
    long hChild = GetWindow(hParent, GW_CHILD);
    while (hChild != 0)
    {
        string className = GetWindowClassName(hChild);
        
        // Check if this is a TreeView.
        if (className == "SysTreeView32")
            return hChild;
        
        // Recurse into children.
        long found = FindTreeViewRecursive(hChild, depth + 1);
        if (found != 0)
            return found;
        
        // Get next sibling.
        hChild = GetWindow(hChild, GW_HWNDNEXT);
    }
    return 0;
}

//+------------------------------------------------------------------+
//| Find Navigator TreeView specifically.                            |
//+------------------------------------------------------------------+
long FindNavigatorTreeView(long hwndMT5)
{
    // First, find the Navigator window by title.
    long hNavigator = FindNavigatorWindow(hwndMT5);
    if (hNavigator != 0)
    {
        // Now find the TreeView inside Navigator.
        long hChild = GetWindow(hNavigator, GW_CHILD);
        while (hChild != 0)
        {
            string className = GetWindowClassName(hChild);
            if (className == "SysTreeView32")
                return hChild;
            hChild = GetWindow(hChild, GW_HWNDNEXT);
        }
    }
    
    // Fallback: search all windows recursively.
    return FindTreeViewRecursive(hwndMT5, 0);
}

//+------------------------------------------------------------------+
//| Get character from virtual key code.                             |
//+------------------------------------------------------------------+
string GetCharFromVK(int vk, bool shiftPressed)
{
    if (vk == VK_SPACE) return " ";
    if (vk >= 'A' && vk <= 'Z') return CharToString((uchar)(shiftPressed ? vk : vk + 32));
    if (vk >= '0' && vk <= '9')
    {
        if (!shiftPressed) return CharToString((uchar)vk);
        // Shifted number row.
        switch (vk)
        {
            case '1': return "!";
            case '2': return "@";
            case '3': return "#";
            case '4': return "$";
            case '5': return "%";
            case '6': return "^";
            case '7': return "&";
            case '8': return "*";
            case '9': return "(";
            case '0': return ")";
        }
    }
    // Numpad numbers.
    if (vk >= VK_NUMPAD0 && vk <= VK_NUMPAD9)
    {
        return CharToString((uchar)('0' + (vk - VK_NUMPAD0)));
    }
    if (vk == VK_DECIMAL) return ".";
    // OEM keys.
    switch (vk)
    {
        case VK_OEM_1:      return shiftPressed ? ":" : ";";
        case VK_OEM_PLUS:   return shiftPressed ? "+" : "=";
        case VK_OEM_COMMA:  return shiftPressed ? "<" : ",";
        case VK_OEM_MINUS:  return shiftPressed ? "_" : "-";
        case VK_OEM_PERIOD: return shiftPressed ? ">" : ".";
        case VK_OEM_2:      return shiftPressed ? "?" : "/";
        case VK_OEM_4:      return shiftPressed ? "{" : "[";
        case VK_OEM_5:      return shiftPressed ? "|" : "\\";
        case VK_OEM_6:      return shiftPressed ? "}" : "]";
        case VK_OEM_7:      return shiftPressed ? "\"" : "'";
    }
    return "";
}

//+------------------------------------------------------------------+
//| Service Start Function.                                          |
//+------------------------------------------------------------------+
void OnStart()
{
    Print("===========================================");
    Print("   MT5 Console Service ver. " + Version + " Starting");
    Print("===========================================");
    
    if (!TerminalInfoInteger(TERMINAL_DLLS_ALLOWED))
    {
        Print("ERROR: DLL imports not allowed!");
        return;
    }
    
    CWindowsConsole* g_console = new CWindowsConsole();
    
    if (!g_console.Create())
    {
        Print("ERROR: Failed to create console.");
        delete g_console;
        return;
    }
    
    Print("Console ready - press ` to toggle.");
    
    bool keyStates[256];
    ArrayInitialize(keyStates, false);
    bool wasVisible = false;
    
    while (!IsStopped())
    {
        if (g_console.IsQuitRequested())
        {
            Print("Quit command received.");
            break;
        }
        
        // Process Windows messages - CRITICAL for responsiveness.
        if (!g_console.ProcessMessages())
        {
            // Window was closed.
            break;
        }
        
        // Check if MT5 or console is the active window.
        bool isMT5Active = g_console.IsMT5Active();
        
        // Update console position to follow active chart.
        g_console.UpdatePosition();
        
        // Check for backtick - always track state but only toggle when MT5 active.
        static bool backtickWasPressed = false;
        bool backtickPressed = (GetAsyncKeyState(VK_OEM_3) & 0x8000) != 0;
        
        if (backtickPressed && !backtickWasPressed && isMT5Active && !g_console.IsBreathing())
        {
            g_console.Toggle();
        }
        backtickWasPressed = backtickPressed;
        
        // Sync key states when console just became visible to prevent first char skip.
        bool isVisible = g_console.IsVisible();
        static bool resetHeldKeys = false;
        if (isVisible && !wasVisible)
        {
            for (int vk = 0x20; vk <= 0x7E; vk++)
            {
                keyStates[vk] = (GetAsyncKeyState(vk) & 0x8000) != 0;
            }
            resetHeldKeys = true;
        }
        wasVisible = isVisible;
        
        if (isVisible && isMT5Active)
        {
            // Key repeat timing constants.
            uint KEY_REPEAT_DELAY = 400;    // Initial delay before repeat starts (ms).
            uint KEY_REPEAT_RATE = 50;      // Repeat interval (ms).
            
            // Track held keys and their timing.
            static int heldSpecialKey = 0;
            static uint heldSpecialKeyTime = 0;
            static uint lastSpecialRepeat = 0;
            
            static int heldCharKey = 0;
            static uint heldCharKeyTime = 0;
            static uint lastCharRepeat = 0;
            
            // Reset held key tracking when console just became visible.
            if (resetHeldKeys)
            {
                heldSpecialKey = 0;
                heldCharKey = 0;
                resetHeldKeys = false;
            }
            
            // Handle special keys with repeat.
            static bool enterWasPressed = false;
            static bool backWasPressed = false;
            static bool escWasPressed = false;
            static bool upWasPressed = false;
            static bool downWasPressed = false;
            static bool pgUpWasPressed = false;
            static bool pgDnWasPressed = false;
            static bool leftWasPressed = false;
            static bool rightWasPressed = false;
            static bool homeWasPressed = false;
            static bool endWasPressed = false;
            static bool deleteWasPressed = false;
            
            bool enterPressed = (GetAsyncKeyState(VK_RETURN) & 0x8000) != 0;
            bool backPressed = (GetAsyncKeyState(VK_BACK) & 0x8000) != 0;
            bool escPressed = (GetAsyncKeyState(VK_ESCAPE) & 0x8000) != 0;
            bool upPressed = (GetAsyncKeyState(VK_UP) & 0x8000) != 0;
            bool downPressed = (GetAsyncKeyState(VK_DOWN) & 0x8000) != 0;
            bool pgUpPressed = (GetAsyncKeyState(VK_PRIOR) & 0x8000) != 0;
            bool pgDnPressed = (GetAsyncKeyState(VK_NEXT) & 0x8000) != 0;
            bool leftPressed = (GetAsyncKeyState(VK_LEFT) & 0x8000) != 0;
            bool rightPressed = (GetAsyncKeyState(VK_RIGHT) & 0x8000) != 0;
            bool homePressed = (GetAsyncKeyState(VK_HOME) & 0x8000) != 0;
            bool endPressed = (GetAsyncKeyState(VK_END) & 0x8000) != 0;
            bool deletePressed = (GetAsyncKeyState(VK_DELETE) & 0x8000) != 0;
            
            uint now = GetTickCount();
            
            // Check which special key is currently pressed (priority order).
            int currentSpecialKey = 0;
            if (backPressed) currentSpecialKey = VK_BACK;
            else if (deletePressed) currentSpecialKey = VK_DELETE;
            else if (enterPressed) currentSpecialKey = VK_RETURN;
            else if (escPressed) currentSpecialKey = VK_ESCAPE;
            else if (leftPressed) currentSpecialKey = VK_LEFT;
            else if (rightPressed) currentSpecialKey = VK_RIGHT;
            else if (homePressed) currentSpecialKey = VK_HOME;
            else if (endPressed) currentSpecialKey = VK_END;
            else if (upPressed) currentSpecialKey = VK_UP;
            else if (downPressed) currentSpecialKey = VK_DOWN;
            else if (pgUpPressed) currentSpecialKey = VK_PRIOR;
            else if (pgDnPressed) currentSpecialKey = VK_NEXT;
            
            // Handle special key press/repeat.
            if (currentSpecialKey != 0)
            {
                if (currentSpecialKey != heldSpecialKey)
                {
                    // New key pressed.
                    g_console.ProcessKey(currentSpecialKey);
                    heldSpecialKey = currentSpecialKey;
                    heldSpecialKeyTime = now;
                    lastSpecialRepeat = now;
                }
                else if (now - heldSpecialKeyTime > KEY_REPEAT_DELAY)
                {
                    // Key held long enough, check for repeat.
                    if (now - lastSpecialRepeat > KEY_REPEAT_RATE)
                    {
                        g_console.ProcessKey(currentSpecialKey);
                        lastSpecialRepeat = now;
                    }
                }
            }
            else
            {
                heldSpecialKey = 0;
            }
            
            enterWasPressed = enterPressed;
            backWasPressed = backPressed;
            escWasPressed = escPressed;
            upWasPressed = upPressed;
            downWasPressed = downPressed;
            pgUpWasPressed = pgUpPressed;
            pgDnWasPressed = pgDnPressed;
            leftWasPressed = leftPressed;
            rightWasPressed = rightPressed;
            homeWasPressed = homePressed;
            endWasPressed = endPressed;
            deleteWasPressed = deletePressed;
            
            // Character input with repeat.
            bool shiftPressed = (GetAsyncKeyState(VK_SHIFT) & 0x8000) != 0;
            bool ctrlPressed = (GetAsyncKeyState(VK_CONTROL) & 0x8000) != 0;
            
            // Check for paste: Ctrl+V or Shift+Insert.
            static bool pasteWasPressed = false;
            static string pasteText = "";
            bool ctrlV = ctrlPressed && (GetAsyncKeyState(VK_V) & 0x8000) != 0;
            bool shiftIns = shiftPressed && (GetAsyncKeyState(VK_INSERT) & 0x8000) != 0;
            bool pastePressed = ctrlV || shiftIns;
            
            if (pastePressed && !pasteWasPressed)
            {
                // Direct clipboard access using WinAPI
                if (OpenClipboard(0))
                {
                    long hData = GetClipboardData(CF_UNICODETEXT);
                    if (hData != 0)
                    {
                        long pData = GlobalLock(hData);
                        if (pData != 0)
                        {
                            // Use lstrcatW trick to get string from pointer.
                            pasteText = lstrcatW(pData, "");
                            GlobalUnlock(hData);
                            
                            StringTrimLeft(pasteText);
                            StringTrimRight(pasteText);
                            
                            for (int i = 0; i < StringLen(pasteText); i++)
                            {
                                ushort ch = StringGetCharacter(pasteText, i);
                                if (ch >= 32 && ch < 127)
                                    g_console.ProcessChar(ShortToString(ch));
                            }
                        }
                    }
                    CloseClipboard();
                }
            }
            pasteWasPressed = pastePressed;
            
            // Skip regular character processing if Ctrl or Win key is held (for shortcuts).
            bool winPressed = ((GetAsyncKeyState(VK_LWIN) & 0x8000) != 0) || ((GetAsyncKeyState(VK_RWIN) & 0x8000) != 0);
            if (ctrlPressed || winPressed)
            {
                // Don't process Ctrl+key or Win+key as regular character input.
            }
            else
            {
                // List of all virtual keys to check (including OEM keys).
                int vkList[] = {
                    VK_SPACE,
                    'A','B','C','D','E','F','G','H','I','J','K','L','M',
                    'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
                    '0','1','2','3','4','5','6','7','8','9',
                    VK_NUMPAD0, VK_NUMPAD1, VK_NUMPAD2, VK_NUMPAD3, VK_NUMPAD4,
                    VK_NUMPAD5, VK_NUMPAD6, VK_NUMPAD7, VK_NUMPAD8, VK_NUMPAD9,
                    VK_DECIMAL,
                    VK_OEM_1, VK_OEM_PLUS, VK_OEM_COMMA, VK_OEM_MINUS,
                    VK_OEM_PERIOD, VK_OEM_2, VK_OEM_4, VK_OEM_5, VK_OEM_6, VK_OEM_7
                };
                int vkCount = ArraySize(vkList);
                
                // First pass: detect all newly pressed keys and update states.
                int currentCharKey = 0;
                for (int i = 0; i < vkCount; i++)
                {
                    int vk = vkList[i];
                    
                    bool keyPressed = (GetAsyncKeyState(vk) & 0x8000) != 0;
                    bool wasPressed = keyStates[vk];
                    
                    // Process newly pressed keys (transition from up to down).
                    if (keyPressed && !wasPressed)
                    {
                        string character = GetCharFromVK(vk, shiftPressed);
                        
                        if (character != "")
                        {
                            g_console.ProcessChar(character);
                            // Track for repeat.
                            heldCharKey = vk;
                            heldCharKeyTime = now;
                            lastCharRepeat = now;
                        }
                    }
                    
                    // Track currently held key for repeat functionality.
                    if (keyPressed)
                    {
                        string character = GetCharFromVK(vk, shiftPressed);
                        
                        if (character != "" && currentCharKey == 0)
                        {
                            currentCharKey = vk;
                            
                            // Handle key repeat for held key.
                            if (vk == heldCharKey && wasPressed)
                            {
                                if (now - heldCharKeyTime > KEY_REPEAT_DELAY)
                                {
                                    if (now - lastCharRepeat > KEY_REPEAT_RATE)
                                    {
                                        g_console.ProcessChar(character);
                                        lastCharRepeat = now;
                                    }
                                }
                            }
                        }
                    }
                    
                    // Always update key state.
                    keyStates[vk] = keyPressed;
                }
                
                if (currentCharKey == 0)
                {
                    heldCharKey = 0;
                }
            }  // End of else (!ctrlPressed).
            
            // Redraw.
            g_console.Redraw();
            
            // Cursor blink - only redraw when cursor state changes.
            static bool lastCursorState = false;
            bool currentCursorState = ((GetTickCount() / 500) % 2 == 0);
            if (currentCursorState != lastCursorState)
            {
                g_console.ForceRedraw();
                lastCursorState = currentCursorState;
            }
        }
        
        // Update breathing animation if active.
        if (g_console.IsBreathing())
        {
            g_console.UpdateBreathing();
        }
        
        // Update shutdown countdown if pending.
        if (g_console.IsShutdownPending())
        {
            g_console.UpdateShutdown();
        }
        
        Sleep(10); // Shorter sleep for better responsiveness.
    }
    
    if (g_console != NULL)
    {
        g_console.Destroy();
        delete g_console;
    }
    
    Print("=== SERVICE STOPPED ===");
}