my-Mt5Bridge/Program.cs

using MtApi5;
using Microsoft.AspNetCore.Mvc;
using System.Reflection;
using System.Globalization;
using System.Collections.Concurrent;
using System.Net.WebSockets;
using System.Text;
using Newtonsoft.Json;

var builder = WebApplication.CreateBuilder(args);
builder.WebHost.UseUrls("http://0.0.0.0:8080");
builder.Services.AddSingleton<MtApi5Client>(sp =>
{
    var client = new MtApi5Client();
    try
    {
        var prop = typeof(MtApi5Client).GetProperty("CommandTimeout");
        if (prop != null && prop.CanWrite)
        {
            prop.SetValue(client, 120000);
        }
        else
        {
            var field = typeof(MtApi5Client).GetField("_command_timeout",
                BindingFlags.NonPublic | BindingFlags.Instance);
            field?.SetValue(client, 120000);
        }
        Console.WriteLine("CommandTimeout set to 120000ms");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Could not set CommandTimeout: {ex.Message}");
    }
    return client;
});
builder.Services.AddSingleton(new SemaphoreSlim(1, 1));
builder.Services.AddHostedService<MtConnectionService>();
builder.Services.AddCors(options =>
{
    options.AddDefaultPolicy(policy =>
    {
        policy.AllowAnyOrigin()
              .AllowAnyMethod()
              .AllowAnyHeader();
    });
});
var app = builder.Build();
app.UseCors();
app.UseWebSockets();

app.UseExceptionHandler(errorApp =>
{
    errorApp.Run(async context =>
    {
        var logger = context.RequestServices.GetRequiredService<ILoggerFactory>().CreateLogger("GlobalExceptionHandler");
        var exception = context.Features.Get<Microsoft.AspNetCore.Diagnostics.IExceptionHandlerFeature>()?.Error;
        if (exception != null)
        {
            logger.LogError(exception, "Unhandled exception while processing {Method} {Path}", context.Request.Method, context.Request.Path);
        }

        context.Response.StatusCode = StatusCodes.Status500InternalServerError;
        await context.Response.WriteAsJsonAsync(new
        {
            detail = "The bridge could not process the request.",
            status = StatusCodes.Status500InternalServerError
        });
    });
});

// API Key 认证
const string API_KEY = "UiHMqtaYLZzwBdcuS4RFmEGhgDO8N2eI";
app.Use(async (context, next) =>
{
    var key = context.Request.Headers["X-API-Key"].FirstOrDefault()
           ?? context.Request.Query["key"].FirstOrDefault();
    if (key != API_KEY)
    {
        context.Response.StatusCode = 401;
        await context.Response.WriteAsync("Unauthorized");
        return;
    }
    await next();
});

app.MapGet("/health", (MtApi5Client mt) =>
{
    var connected = mt.ConnectionState == Mt5ConnectionState.Connected;
    return connected
        ? Results.Ok(new { status = "healthy", mt5_connected = true, mt5_version = "unknown", api_version = "1.0.0" })
        : Results.Json(new { status = "disconnected", mt5_connected = false, mt5_version = "unknown", api_version = "1.0.0" }, statusCode: StatusCodes.Status503ServiceUnavailable);
});

app.MapGet("/account", (MtApi5Client mt) =>
{
    var login = (ulong)mt.AccountInfoInteger(ENUM_ACCOUNT_INFO_INTEGER.ACCOUNT_LOGIN);
    var leverage = (uint)mt.AccountInfoInteger(ENUM_ACCOUNT_INFO_INTEGER.ACCOUNT_LEVERAGE);
    var tradeAllowed = mt.AccountInfoInteger(ENUM_ACCOUNT_INFO_INTEGER.ACCOUNT_TRADE_ALLOWED) != 0;
    var tradeExpert = mt.AccountInfoInteger(ENUM_ACCOUNT_INFO_INTEGER.ACCOUNT_TRADE_EXPERT) != 0;
    var currency = mt.AccountInfoString(ENUM_ACCOUNT_INFO_STRING.ACCOUNT_CURRENCY) ?? "USD";
    var server = mt.AccountInfoString(ENUM_ACCOUNT_INFO_STRING.ACCOUNT_SERVER) ?? "";
    var name = mt.AccountInfoString(ENUM_ACCOUNT_INFO_STRING.ACCOUNT_NAME) ?? "";
    var company = mt.AccountInfoString(ENUM_ACCOUNT_INFO_STRING.ACCOUNT_COMPANY) ?? "";
    var balance = mt.AccountInfoDouble(ENUM_ACCOUNT_INFO_DOUBLE.ACCOUNT_BALANCE);
    var equity = mt.AccountInfoDouble(ENUM_ACCOUNT_INFO_DOUBLE.ACCOUNT_EQUITY);
    var profit = mt.AccountInfoDouble(ENUM_ACCOUNT_INFO_DOUBLE.ACCOUNT_PROFIT);
    var margin = mt.AccountInfoDouble(ENUM_ACCOUNT_INFO_DOUBLE.ACCOUNT_MARGIN);
    var marginFree = mt.AccountInfoDouble(ENUM_ACCOUNT_INFO_DOUBLE.ACCOUNT_MARGIN_FREE);
    var marginLevel = mt.AccountInfoDouble(ENUM_ACCOUNT_INFO_DOUBLE.ACCOUNT_MARGIN_LEVEL);

    return Results.Ok(new
    {
        data = new[]
        {
            new { login, leverage, trade_allowed = tradeAllowed, trade_expert = tradeExpert, currency, currency_digits = 2, server, name, company, balance, equity, profit, margin, margin_free = marginFree, margin_level = marginLevel }
        },
        count = 1,
        format = "json"
    });
});

app.MapGet("/symbols/{symbol}", (string symbol, MtApi5Client mt, ILoggerFactory loggerFactory) =>
{
    if (string.IsNullOrWhiteSpace(symbol)) return Results.BadRequest(new { detail = "Symbol is required." });
    try
    {
        // ponytail: SymbolSelect(true) subscribes to MT5 quotes for this symbol — without it
        // SymbolInfoDouble returns 0 for bid/ask until a tick arrives naturally.
        mt.SymbolSelect(symbol, true);
        var digits = (int)mt.SymbolInfoInteger(symbol, ENUM_SYMBOL_INFO_INTEGER.SYMBOL_DIGITS);
        var spreadFloat = mt.SymbolInfoInteger(symbol, ENUM_SYMBOL_INFO_INTEGER.SYMBOL_SPREAD_FLOAT) != 0;
        var spread = (int)mt.SymbolInfoInteger(symbol, ENUM_SYMBOL_INFO_INTEGER.SYMBOL_SPREAD);
        var point = mt.SymbolInfoDouble(symbol, ENUM_SYMBOL_INFO_DOUBLE.SYMBOL_POINT);
        double bid = 0, ask = 0;
        var tickInfo = WaitForTick(mt, symbol);
        if (tickInfo != null) { bid = tickInfo.bid; ask = tickInfo.ask; }
        if (bid == 0) bid = mt.SymbolInfoDouble(symbol, ENUM_SYMBOL_INFO_DOUBLE.SYMBOL_BID);
        if (ask == 0) ask = mt.SymbolInfoDouble(symbol, ENUM_SYMBOL_INFO_DOUBLE.SYMBOL_ASK);
        var volumeMin = mt.SymbolInfoDouble(symbol, ENUM_SYMBOL_INFO_DOUBLE.SYMBOL_VOLUME_MIN);
        var volumeMax = mt.SymbolInfoDouble(symbol, ENUM_SYMBOL_INFO_DOUBLE.SYMBOL_VOLUME_MAX);
        var volumeStep = mt.SymbolInfoDouble(symbol, ENUM_SYMBOL_INFO_DOUBLE.SYMBOL_VOLUME_STEP);
        var contractSize = mt.SymbolInfoDouble(symbol, ENUM_SYMBOL_INFO_DOUBLE.SYMBOL_TRADE_CONTRACT_SIZE);

        string description = "", currencyBase = "", currencyProfit = "", path = "";
        try { description = mt.SymbolInfoString(symbol, ENUM_SYMBOL_INFO_STRING.SYMBOL_DESCRIPTION) ?? ""; } catch { }
        try { currencyBase = mt.SymbolInfoString(symbol, ENUM_SYMBOL_INFO_STRING.SYMBOL_CURRENCY_BASE) ?? ""; } catch { }
        try { currencyProfit = mt.SymbolInfoString(symbol, ENUM_SYMBOL_INFO_STRING.SYMBOL_CURRENCY_PROFIT) ?? ""; } catch { }
        try { path = mt.SymbolInfoString(symbol, ENUM_SYMBOL_INFO_STRING.SYMBOL_PATH) ?? ""; } catch { }

        return Results.Ok(new
        {
            data = new[]
            {
                new { name = symbol, description, digits, point, bid, ask, spread, spread_float = spreadFloat, volume_min = volumeMin, volume_max = volumeMax, volume_step = volumeStep, trade_contract_size = contractSize, currency_base = currencyBase, currency_profit = currencyProfit, category = path }
            },
            count = 1,
            format = "json"
        });
    }
    catch (Exception ex)
    {
        loggerFactory.CreateLogger("SymbolsEndpoint").LogError(ex, "Failed to read symbol info for {Symbol}", symbol);
        return Results.Problem("Failed to read symbol info.", statusCode: StatusCodes.Status502BadGateway);
    }
});

app.MapGet("/symbols/{symbol}/tick", (string symbol, MtApi5Client mt) =>
{
    if (string.IsNullOrWhiteSpace(symbol)) return Results.BadRequest(new { detail = "Symbol is required." });

    mt.SymbolSelect(symbol, true);
    var tick = WaitForTick(mt, symbol);
    if (tick == null) return Results.NotFound(new { detail = $"Tick for {symbol} not found" });

    return Results.Json(new
    {
        data = new[]
        {
            new
            {
                time = tick.time.ToString("yyyy-MM-ddTHH:mm:ss"),
                bid = tick.bid,
                ask = tick.ask,
                last = tick.last,
                volume = tick.volume,
                time_msc = tick.time.ToString("yyyy-MM-ddTHH:mm:ss.fff000"),
                flags = 6,
                volume_real = tick.volume_real
            }
        },
        count = 1,
        format = "json"
    });
});

// Tick stream via WebSocket. Connect: ws://host:8080/stream/ticks/{symbol}
// MT5 must be in Market Watch for the symbol; this endpoint auto-adds it on connect
// and removes it when the last subscriber disconnects.
app.Map("/stream/ticks/{symbol}", async (string symbol, HttpContext ctx, MtApi5Client mt, SemaphoreSlim gate, ILoggerFactory loggerFactory) =>
{
    var logger = loggerFactory.CreateLogger("TickStream");
    if (string.IsNullOrWhiteSpace(symbol))
    {
        ctx.Response.StatusCode = 400;
        await ctx.Response.WriteAsJsonAsync(new { detail = "Symbol is required." });
        return;
    }
    if (!ctx.WebSockets.IsWebSocketRequest)
    {
        ctx.Response.StatusCode = 400;
        await ctx.Response.WriteAsJsonAsync(new { detail = "WebSocket required. Use ws://.../stream/ticks/{symbol}." });
        return;
    }
    if (mt.ConnectionState != Mt5ConnectionState.Connected)
    {
        ctx.Response.StatusCode = 503;
        await ctx.Response.WriteAsJsonAsync(new { detail = "MT5 is not connected." });
        return;
    }

    await gate.WaitAsync(ctx.RequestAborted);
    try
    {
        if (!mt.SymbolSelect(symbol, true))
        {
            ctx.Response.StatusCode = 404;
            await ctx.Response.WriteAsJsonAsync(new { detail = $"Symbol '{symbol}' not found." });
            return;
        }
    }
    finally
    {
        gate.Release();
    }

    var subs = MtConnectionService.TickSubscribers.GetOrAdd(symbol, _ => new ConcurrentDictionary<TickSubscriber, byte>());
    if (subs.Count >= MtConnectionService.MaxSubscribersPerSymbol)
    {
        ctx.Response.StatusCode = 429;
        await ctx.Response.WriteAsJsonAsync(new { detail = $"Too many subscribers for {symbol} (limit={MtConnectionService.MaxSubscribersPerSymbol})." });
        return;
    }

    using var ws = await ctx.WebSockets.AcceptWebSocketAsync();
    var subscriber = new WsSubscriber(ws);
    subs[subscriber] = 1;
    logger.LogInformation("Tick stream subscribed for {Symbol} via WS (subscribers={Count})", symbol, subs.Count);

    var buf = new byte[1024];
    try
    {
        while (ws.State == WebSocketState.Open && !ctx.RequestAborted.IsCancellationRequested)
        {
            var result = await ws.ReceiveAsync(buf, ctx.RequestAborted);
            if (result.MessageType == WebSocketMessageType.Close)
            {
                await ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "bye", CancellationToken.None);
                break;
            }
        }
    }
    catch (OperationCanceledException) { }
    catch (WebSocketException) { }
    finally
    {
        subs.TryRemove(subscriber, out _);
        MtConnectionService.TickSubscribers.TryRemove(symbol, out _);
        if (subs.IsEmpty)
        {
            try
            {
                if (mt.ConnectionState == Mt5ConnectionState.Connected)
                {
                    await gate.WaitAsync();
                    try { mt.SymbolSelect(symbol, false); }
                    finally { gate.Release(); }
                }
            }
            catch (Exception ex) { logger.LogWarning(ex, "Failed to remove {Symbol} from Market Watch", symbol); }
        }
        logger.LogInformation("Tick stream disconnected for {Symbol} via WS (remaining={Count})", symbol, subs.Count);
    }
});

// Tick stream via Server-Sent Events. Same semantics as /stream/ticks/{symbol},
// one-way push over HTTP for clients that can't open a WebSocket.
// ponytail: SSE = no receive loop, just keep the response open and let the broadcast
// loop (OnQuoteUpdate + heartbeat timer) push data frames.
app.MapGet("/stream/ticks-sse/{symbol}", async (string symbol, HttpContext ctx, MtApi5Client mt, SemaphoreSlim gate, ILoggerFactory loggerFactory) =>
{
    var logger = loggerFactory.CreateLogger("TickStream");
    if (string.IsNullOrWhiteSpace(symbol))
    {
        ctx.Response.StatusCode = 400;
        await ctx.Response.WriteAsJsonAsync(new { detail = "Symbol is required." });
        return;
    }
    if (mt.ConnectionState != Mt5ConnectionState.Connected)
    {
        ctx.Response.StatusCode = 503;
        await ctx.Response.WriteAsJsonAsync(new { detail = "MT5 is not connected." });
        return;
    }

    await gate.WaitAsync(ctx.RequestAborted);
    try
    {
        if (!mt.SymbolSelect(symbol, true))
        {
            ctx.Response.StatusCode = 404;
            await ctx.Response.WriteAsJsonAsync(new { detail = $"Symbol '{symbol}' not found." });
            return;
        }
    }
    finally
    {
        gate.Release();
    }

    var subs = MtConnectionService.TickSubscribers.GetOrAdd(symbol, _ => new ConcurrentDictionary<TickSubscriber, byte>());
    if (subs.Count >= MtConnectionService.MaxSubscribersPerSymbol)
    {
        ctx.Response.StatusCode = 429;
        await ctx.Response.WriteAsJsonAsync(new { detail = $"Too many subscribers for {symbol} (limit={MtConnectionService.MaxSubscribersPerSymbol})." });
        return;
    }

    ctx.Response.StatusCode = 200;
    ctx.Response.ContentType = "text/event-stream";
    ctx.Response.Headers.CacheControl = "no-cache";
    ctx.Response.Headers.Connection = "keep-alive";
    ctx.Response.Headers["X-Accel-Buffering"] = "no"; // disable nginx buffering

    var subscriber = new SseSubscriber(ctx.Response.Body);
    subs[subscriber] = 1;
    logger.LogInformation("Tick stream subscribed for {Symbol} via SSE (subscribers={Count})", symbol, subs.Count);

    try
    {
        // Initial comment to flush headers and confirm connection
        await ctx.Response.WriteAsync(": connected\n\n", ctx.RequestAborted);
        await ctx.Response.Body.FlushAsync(ctx.RequestAborted);

        // Hold the request open until client disconnects; ticks/heartbeats arrive via OnQuoteUpdate + timer.
        await Task.Delay(Timeout.Infinite, ctx.RequestAborted);
    }
    catch (OperationCanceledException) { }
    catch (Exception ex) { logger.LogDebug(ex, "SSE stream ended for {Symbol}", symbol); }
    finally
    {
        subs.TryRemove(subscriber, out _);
        MtConnectionService.TickSubscribers.TryRemove(symbol, out _);
        if (subs.IsEmpty)
        {
            try
            {
                if (mt.ConnectionState == Mt5ConnectionState.Connected)
                {
                    await gate.WaitAsync();
                    try { mt.SymbolSelect(symbol, false); }
                    finally { gate.Release(); }
                }
            }
            catch (Exception ex) { logger.LogWarning(ex, "Failed to remove {Symbol} from Market Watch", symbol); }
        }
        logger.LogInformation("Tick stream disconnected for {Symbol} via SSE (remaining={Count})", symbol, subs.Count);
    }
});

app.MapGet("/rates/from-pos", (string symbol, string timeframe, int start_pos, int count, MtApi5Client mt, ILoggerFactory loggerFactory) =>
{
    if (string.IsNullOrWhiteSpace(symbol)) return Results.BadRequest(new { detail = "Symbol is required." });
    if (!TryParseTimeframe(timeframe, out var tf)) return Results.BadRequest(new { detail = $"Unsupported timeframe '{timeframe}'." });
    if (start_pos < 0) return Results.BadRequest(new { detail = "start_pos must be greater than or equal to 0." });
    if (count <= 0 || count > 10000) return Results.BadRequest(new { detail = "count must be between 1 and 10000." });

    try
    {
        const int chunkSize = 1000;
        var allRates = new List<MqlRates>();
        int remaining = count;
        int currentPos = start_pos;

        while (remaining > 0)
        {
            int chunk = Math.Min(remaining, chunkSize);
            var result = mt.CopyRates(symbol, tf, currentPos, chunk, out MqlRates[]? rates);

            if (rates != null && rates.Length > 0)
            {
                allRates.AddRange(rates);
                currentPos += rates.Length;
                remaining -= rates.Length;
                if (rates.Length < chunk) break;
            }
            else
            {
                break;
            }
        }

        var data = allRates.Select(r => new
        {
            time = r.time.ToString("yyyy-MM-ddTHH:mm:ss"),
            r.open,
            r.high,
            r.low,
            r.close,
            tick_volume = r.tick_volume,
            r.spread,
            real_volume = r.real_volume
        }).ToArray();

        return Results.Ok(new { data, count = data.Length, format = "json" });
    }
    catch (Exception ex)
    {
        loggerFactory.CreateLogger("RatesEndpoint").LogError(ex, "Failed to read rates for {Symbol} {Timeframe}", symbol, timeframe);
        return Results.Problem("Failed to read rates.", statusCode: StatusCodes.Status502BadGateway);
    }
});

app.MapGet("/rates/from-date", (string symbol, string timeframe, string date_from, string date_to, MtApi5Client mt, ILoggerFactory loggerFactory) =>
{
    if (string.IsNullOrWhiteSpace(symbol)) return Results.BadRequest(new { detail = "Symbol is required." });
    if (!TryParseTimeframe(timeframe, out var tf)) return Results.BadRequest(new { detail = $"Unsupported timeframe '{timeframe}'." });
    if (!TryParseClientDate(date_from, out var fromDate)) return Results.BadRequest(new { detail = "date_from must be a valid ISO-8601 or yyyy-MM-dd value." });
    if (!TryParseClientDate(date_to, out var toDate)) return Results.BadRequest(new { detail = "date_to must be a valid ISO-8601 or yyyy-MM-dd value." });
    if (fromDate > toDate) return Results.BadRequest(new { detail = "date_from must be earlier than or equal to date_to." });

    try
    {
        // ponytail: Bars(from, to) is half-open [from, to). Same-day query would yield 0
        // without this nudge — bump toDate by one day to include the entire end day.
        var effectiveTo = (toDate.Date == fromDate.Date) ? toDate.Date.AddDays(1) : toDate;

        var total = mt.Bars(symbol, tf, fromDate, effectiveTo);
        if (total <= 0) return Results.Ok(new { data = Array.Empty<object>(), count = 0, format = "json" });
        if (total > 10000) return Results.BadRequest(new { detail = $"Date range covers {total} bars (max 10000). Narrow the range." });

        var result = mt.CopyRates(symbol, tf, total - 1, total, out MqlRates[]? rates);
        if (rates == null || rates.Length == 0) return Results.Ok(new { data = Array.Empty<object>(), count = 0, format = "json" });

        var data = rates.Select(r => new
        {
            time = r.time.ToString("yyyy-MM-ddTHH:mm:ss"),
            r.open,
            r.high,
            r.low,
            r.close,
            tick_volume = r.tick_volume,
            r.spread,
            real_volume = r.real_volume
        }).ToArray();
        return Results.Ok(new { data, count = data.Length, format = "json" });
    }
    catch (Exception ex)
    {
        loggerFactory.CreateLogger("RatesFromDateEndpoint").LogError(ex, "Failed to read rates for {Symbol} {Timeframe} {DateFrom}~{DateTo}", symbol, timeframe, date_from, date_to);
        return Results.Problem("Failed to read rates.", statusCode: StatusCodes.Status502BadGateway);
    }
});

app.MapGet("/positions", (string? symbol, MtApi5Client mt) =>
{
    var total = mt.PositionsTotal();
    var positions = new List<object>();
    for (int i = 0; i < total; i++)
    {
        var ticket = mt.PositionGetTicket(i);
        if (ticket == 0) continue;
        var posSymbol = mt.PositionGetString(ENUM_POSITION_PROPERTY_STRING.POSITION_SYMBOL);
        if (!string.IsNullOrWhiteSpace(symbol) && posSymbol != symbol) continue;
        positions.Add(new
        {
            ticket,
            symbol = posSymbol,
            type = (int)mt.PositionGetInteger(ENUM_POSITION_PROPERTY_INTEGER.POSITION_TYPE),
            volume = mt.PositionGetDouble(ENUM_POSITION_PROPERTY_DOUBLE.POSITION_VOLUME),
            price_open = mt.PositionGetDouble(ENUM_POSITION_PROPERTY_DOUBLE.POSITION_PRICE_OPEN),
            sl = mt.PositionGetDouble(ENUM_POSITION_PROPERTY_DOUBLE.POSITION_SL),
            tp = mt.PositionGetDouble(ENUM_POSITION_PROPERTY_DOUBLE.POSITION_TP),
            price_current = mt.PositionGetDouble(ENUM_POSITION_PROPERTY_DOUBLE.POSITION_PRICE_CURRENT),
            swap = mt.PositionGetDouble(ENUM_POSITION_PROPERTY_DOUBLE.POSITION_SWAP),
            profit = mt.PositionGetDouble(ENUM_POSITION_PROPERTY_DOUBLE.POSITION_PROFIT),
            comment = mt.PositionGetString(ENUM_POSITION_PROPERTY_STRING.POSITION_COMMENT),
            magic = (ulong)mt.PositionGetInteger(ENUM_POSITION_PROPERTY_INTEGER.POSITION_MAGIC)
        });
    }
    return Results.Ok(new { data = positions, count = positions.Count, format = "json" });
});

app.MapGet("/orders", (string? symbol, MtApi5Client mt) =>
{
    var total = mt.OrdersTotal();
    var orders = new List<object>();
    for (int i = 0; i < total; i++)
    {
        var ticket = mt.OrderGetTicket(i);
        if (ticket == 0) continue;
        var orderSymbol = mt.OrderGetString(ENUM_ORDER_PROPERTY_STRING.ORDER_SYMBOL);
        if (!string.IsNullOrWhiteSpace(symbol) && orderSymbol != symbol) continue;
        orders.Add(new
        {
            ticket,
            symbol = orderSymbol,
            type = (int)mt.OrderGetInteger(ENUM_ORDER_PROPERTY_INTEGER.ORDER_TYPE),
            volume_initial = mt.OrderGetDouble(ENUM_ORDER_PROPERTY_DOUBLE.ORDER_VOLUME_INITIAL),
            price_open = mt.OrderGetDouble(ENUM_ORDER_PROPERTY_DOUBLE.ORDER_PRICE_OPEN),
            sl = mt.OrderGetDouble(ENUM_ORDER_PROPERTY_DOUBLE.ORDER_SL),
            tp = mt.OrderGetDouble(ENUM_ORDER_PROPERTY_DOUBLE.ORDER_TP),
            magic = (ulong)mt.OrderGetInteger(ENUM_ORDER_PROPERTY_INTEGER.ORDER_MAGIC),
            comment = mt.OrderGetString(ENUM_ORDER_PROPERTY_STRING.ORDER_COMMENT)
        });
    }
    return Results.Ok(new { data = orders, count = orders.Count, format = "json" });
});

app.MapPost("/order/check", async (TradeRequestDto body, MtApi5Client mt, SemaphoreSlim gate) =>
{
    var validationError = ValidateTradeRequest(body);
    if (validationError != null) return Results.BadRequest(new { detail = validationError });

    body.type_filling = (uint)ResolveFillingMode(mt, body.symbol, body.type_filling ?? 0);
    var request = ToMqlTradeRequest(body);
    await gate.WaitAsync();
    try
    {
        mt.OrderCheck(request, out MqlTradeCheckResult? checkResult);
        if (checkResult == null) return Results.Ok(new { data = new { retcode = 0u, balance = 0.0, equity = 0.0, profit = 0.0, margin = 0.0, margin_free = 0.0, margin_level = 0.0, comment = "Check failed" }, count = 1, format = "json" });
        return Results.Ok(new { data = new { retcode = checkResult.Retcode, balance = checkResult.Balance, equity = checkResult.Equity, profit = checkResult.Profit, margin = checkResult.Margin, margin_free = checkResult.Margin_free, margin_level = checkResult.Margin_level, comment = checkResult.Comment ?? "" }, count = 1, format = "json" });
    }
    finally
    {
        gate.Release();
    }
});

app.MapPost("/order/send", async (TradeRequestBody body, MtApi5Client mt, SemaphoreSlim gate) =>
{
    var validationError = ValidateTradeRequest(body.request);
    if (validationError != null) return Results.BadRequest(new { detail = validationError });

    body.request.type_filling = (uint)ResolveFillingMode(mt, body.request.symbol, body.request.type_filling ?? 0);
    var request = ToMqlTradeRequest(body.request);
    await gate.WaitAsync();
    try
    {
        mt.OrderSend(request, out MqlTradeResult? result);
        if (result == null) return Results.Ok(new { data = new { retcode = 0u, order = 0ul, comment = "Send failed" }, count = 1, format = "json" });
        return Results.Ok(new { data = new { retcode = result.Retcode, order = result.Order, comment = result.Comment ?? "" }, count = 1, format = "json" });
    }
    finally
    {
        gate.Release();
    }
});

app.MapPost("/position/close", async (ClosePositionDto body, MtApi5Client mt, SemaphoreSlim gate) =>
{
    if (body == null || body.ticket == 0) return Results.BadRequest(new { detail = "ticket is required." });
    await gate.WaitAsync();
    try
    {
        bool ok;
        if (body.volume is > 0)
        {
            // ponytail: PositionClosePartial has no MqlTradeResult overload — return bool only.
            ok = mt.PositionClosePartial(body.ticket, body.volume.Value, body.deviation ?? 10);
        }
        else
        {
            mt.PositionClose(body.ticket, body.deviation ?? 10, out MqlTradeResult? result);
            if (result == null) return Results.Ok(new { data = new { retcode = 0u, order = 0ul, comment = "Close failed" }, count = 1, format = "json" });
            return Results.Ok(new { data = new { retcode = result.Retcode, order = result.Order, comment = result.Comment ?? "" }, count = 1, format = "json" });
        }
        return Results.Ok(new
        {
            data = new { retcode = ok ? 10009u : 10004u, order = body.ticket, comment = ok ? (body.volume is > 0 ? "Partial closed" : "Closed") : "Close failed" },
            count = 1,
            format = "json"
        });
    }
    finally
    {
        gate.Release();
    }
});

app.MapPost("/position/modify", async (ModifyPositionDto body, MtApi5Client mt, SemaphoreSlim gate) =>
{
    if (body == null || body.ticket == 0) return Results.BadRequest(new { detail = "ticket is required." });
    if (body.sl < 0 || body.tp < 0) return Results.BadRequest(new { detail = "sl/tp must be non-negative." });
    await gate.WaitAsync();
    try
    {
        // ponytail: MtApi5 PositionModify returns bool, no MqlTradeResult — pack into our uniform envelope.
        var ok = mt.PositionModify(body.ticket, body.sl, body.tp);
        return Results.Ok(new
        {
            data = new { retcode = ok ? 10009u : 10004u, order = body.ticket, comment = ok ? "Modified" : "Modify failed" },
            count = 1,
            format = "json"
        });
    }
    finally
    {
        gate.Release();
    }
});

app.MapPost("/order/cancel", async (OrderTicketDto body, MtApi5Client mt, SemaphoreSlim gate) =>
{
    if (body == null || body.ticket == 0) return Results.BadRequest(new { detail = "ticket is required." });
    await gate.WaitAsync();
    try
    {
        // ponytail: MtApi5 has no OrderDelete — reuse OrderSend with TRADE_ACTION_REMOVE.
        var req = new MqlTradeRequest
        {
            Action = ENUM_TRADE_REQUEST_ACTIONS.TRADE_ACTION_REMOVE,
            Order = body.ticket,
        };
        mt.OrderSend(req, out MqlTradeResult? result);
        if (result == null) return Results.Ok(new { data = new { retcode = 0u, order = 0ul, comment = "Cancel failed" }, count = 1, format = "json" });
        return Results.Ok(new { data = new { retcode = result.Retcode, order = result.Order, comment = result.Comment ?? "" }, count = 1, format = "json" });
    }
    finally
    {
        gate.Release();
    }
});

app.MapPost("/position/close-by", async (CloseByDto body, MtApi5Client mt, SemaphoreSlim gate) =>
{
    if (body == null || body.position == 0 || body.position_by == 0)
        return Results.BadRequest(new { detail = "position and position_by are required." });
    await gate.WaitAsync();
    try
    {
        // ponytail: TRADE_ACTION_CLOSE_BY lets MT5 net two opposite positions instead of
        // two separate market closes — saves one side of the spread.
        var req = new MqlTradeRequest
        {
            Action = ENUM_TRADE_REQUEST_ACTIONS.TRADE_ACTION_CLOSE_BY,
            Position = body.position,
            PositionBy = body.position_by,
        };
        mt.OrderSend(req, out MqlTradeResult? result);
        if (result == null) return Results.Ok(new { data = new { retcode = 0u, order = 0ul, comment = "Close-by failed" }, count = 1, format = "json" });
        return Results.Ok(new { data = new { retcode = result.Retcode, order = result.Order, comment = result.Comment ?? "" }, count = 1, format = "json" });
    }
    finally
    {
        gate.Release();
    }
});

app.MapPost("/positions/close-batch", async (BatchCloseDto body, MtApi5Client mt, SemaphoreSlim gate, ILoggerFactory loggerFactory) =>
{
    if (body == null || (string.IsNullOrWhiteSpace(body.symbol) && body.magic == null))
        return Results.BadRequest(new { detail = "At least one of `symbol` or `magic` is required." });

    var logger = loggerFactory.CreateLogger("BatchClose");
    var results = new List<object>();
    int closed = 0, failed = 0;
    // ponytail: hold the gate for the whole batch — one logical op, brief duration.
    // Clients wanting concurrent writes should not use batch close.
    await gate.WaitAsync();
    try
    {
        var total = mt.PositionsTotal();
        for (int i = 0; i < total; i++)
        {
            var ticket = mt.PositionGetTicket(i);
            if (ticket == 0) continue;
            var posSymbol = mt.PositionGetString(ENUM_POSITION_PROPERTY_STRING.POSITION_SYMBOL);
            if (!string.IsNullOrWhiteSpace(body.symbol) && posSymbol != body.symbol) continue;
            if (body.magic is ulong m && mt.PositionGetInteger(ENUM_POSITION_PROPERTY_INTEGER.POSITION_MAGIC) != (long)m) continue;

            mt.PositionClose(ticket, body.deviation ?? 10, out MqlTradeResult? result);
            if (result != null && result.Retcode == 10009)
            {
                closed++;
                results.Add(new { ticket, symbol = posSymbol, retcode = result.Retcode, comment = "closed" });
            }
            else
            {
                failed++;
                var comment = result?.Comment ?? "unknown";
                logger.LogWarning("Batch close failed for ticket {Ticket} ({Symbol}): {Comment}", ticket, posSymbol, comment);
                results.Add(new { ticket, symbol = posSymbol, retcode = result?.Retcode ?? 0u, comment });
            }
        }
        return Results.Ok(new { data = results, count = results.Count, closed, failed, format = "json" });
    }
    finally
    {
        gate.Release();
    }
});

app.MapPost("/order/modify", async (ModifyOrderDto body, MtApi5Client mt, SemaphoreSlim gate) =>
{
    if (body == null || body.ticket == 0) return Results.BadRequest(new { detail = "ticket is required." });
    if (body.price <= 0) return Results.BadRequest(new { detail = "price must be positive." });
    if (body.sl < 0 || body.tp < 0) return Results.BadRequest(new { detail = "sl/tp must be non-negative." });
    await gate.WaitAsync();
    try
    {
        var req = new MqlTradeRequest
        {
            Action = ENUM_TRADE_REQUEST_ACTIONS.TRADE_ACTION_MODIFY,
            Order = body.ticket,
            Price = body.price,
            Sl = body.sl,
            Tp = body.tp,
        };
        mt.OrderSend(req, out MqlTradeResult? result);
        if (result == null) return Results.Ok(new { data = new { retcode = 0u, order = 0ul, comment = "Modify failed" }, count = 1, format = "json" });
        return Results.Ok(new { data = new { retcode = result.Retcode, order = result.Order, comment = result.Comment ?? "" }, count = 1, format = "json" });
    }
    finally
    {
        gate.Release();
    }
});

app.MapGet("/history/deals", (string date_from, string date_to, string? symbol, MtApi5Client mt) =>
{
    if (!TryParseClientDate(date_from, out var fromDt) || !TryParseClientDate(date_to, out var toDt))
        return Results.BadRequest(new { detail = "date_from and date_to must be valid ISO-8601 or yyyy-MM-dd values." });
    if (fromDt > toDt)
        return Results.BadRequest(new { detail = "date_from must be earlier than or equal to date_to." });

    mt.HistorySelect(fromDt, toDt);
    var total = mt.HistoryDealsTotal();
    var dealList = new List<object>();
    for (int i = 0; i < total; i++)
    {
        var ticket = mt.HistoryDealGetTicket(i);
        if (ticket == 0) continue;
        var dealSymbol = mt.HistoryDealGetString(ticket, ENUM_DEAL_PROPERTY_STRING.DEAL_SYMBOL);
        if (!string.IsNullOrWhiteSpace(symbol) && dealSymbol != symbol) continue;
        var dealTime = MtTimeToDateTime(mt.HistoryDealGetInteger(ticket, ENUM_DEAL_PROPERTY_INTEGER.DEAL_TIME));
        dealList.Add(new
        {
            ticket,
            time = dealTime.ToString("yyyy-MM-ddTHH:mm:ss"),
            entry = (int)mt.HistoryDealGetInteger(ticket, ENUM_DEAL_PROPERTY_INTEGER.DEAL_ENTRY),
            magic = (ulong)mt.HistoryDealGetInteger(ticket, ENUM_DEAL_PROPERTY_INTEGER.DEAL_MAGIC),
            volume = mt.HistoryDealGetDouble(ticket, ENUM_DEAL_PROPERTY_DOUBLE.DEAL_VOLUME),
            price = mt.HistoryDealGetDouble(ticket, ENUM_DEAL_PROPERTY_DOUBLE.DEAL_PRICE),
            profit = mt.HistoryDealGetDouble(ticket, ENUM_DEAL_PROPERTY_DOUBLE.DEAL_PROFIT),
            commission = mt.HistoryDealGetDouble(ticket, ENUM_DEAL_PROPERTY_DOUBLE.DEAL_COMMISSION),
            swap = mt.HistoryDealGetDouble(ticket, ENUM_DEAL_PROPERTY_DOUBLE.DEAL_SWAP),
            symbol = dealSymbol,
            comment = mt.HistoryDealGetString(ticket, ENUM_DEAL_PROPERTY_STRING.DEAL_COMMENT) ?? ""
        });
    }
    return Results.Ok(new { data = dealList, count = dealList.Count, format = "json" });
});

app.MapGet("/gvar", (HttpContext context) =>
{
    var mt = context.RequestServices.GetRequiredService<MtApi5Client>();
    var total = mt.GlobalVariablesTotal();
    var vars = new List<object>();
    for (int i = 0; i < total; i++)
    {
        var name = mt.GlobalVariableName(i) ?? "";
        var value = mt.GlobalVariableGet(name);
        vars.Add(new { name, value });
    }
    return Results.Ok(new { data = vars, count = vars.Count, format = "json" });
});

app.MapGet("/gvar/{name}", (HttpContext context, string name) =>
{
    if (string.IsNullOrWhiteSpace(name)) return Results.BadRequest(new { detail = "Global variable name is required." });

    var mt = context.RequestServices.GetRequiredService<MtApi5Client>();
    if (!mt.GlobalVariableCheck(name))
        return Results.NotFound(new { detail = $"GlobalVariable '{name}' not found" });
    var value = mt.GlobalVariableGet(name);
    return Results.Ok(new { name, value });
});

app.MapPost("/gvar/{name}", async (HttpContext context, string name, SemaphoreSlim gate) =>
{
    if (string.IsNullOrWhiteSpace(name)) return Results.BadRequest(new { detail = "Global variable name is required." });

    var mt = context.RequestServices.GetRequiredService<MtApi5Client>();
    var body = await context.Request.ReadFromJsonAsync<GvarSetDto>();
    if (body == null || double.IsNaN(body.value) || double.IsInfinity(body.value)) return Results.BadRequest(new { detail = "Invalid body." });

    await gate.WaitAsync();
    try
    {
        mt.GlobalVariableSet(name, body.value);
        return Results.Ok(new { name, value = body.value });
    }
    finally
    {
        gate.Release();
    }
});

app.MapDelete("/gvar/{name}", async (HttpContext context, string name, SemaphoreSlim gate) =>
{
    if (string.IsNullOrWhiteSpace(name)) return Results.BadRequest(new { detail = "Global variable name is required." });

    var mt = context.RequestServices.GetRequiredService<MtApi5Client>();
    await gate.WaitAsync();
    try
    {
        if (!mt.GlobalVariableCheck(name))
            return Results.NotFound(new { detail = $"GlobalVariable '{name}' not found" });
        mt.GlobalVariableDel(name);
        return Results.Ok(new { deleted = name });
    }
    finally
    {
        gate.Release();
    }
});

app.Run();

DateTime MtTimeToDateTime(long mtTime)
{
    return new DateTime(1970, 1, 1).AddSeconds(mtTime);
}

bool TryParseTimeframe(string timeframe, out ENUM_TIMEFRAMES parsed)
{
    parsed = timeframe switch
    {
        "TIMEFRAME_M1" => ENUM_TIMEFRAMES.PERIOD_M1,
        "TIMEFRAME_M5" => ENUM_TIMEFRAMES.PERIOD_M5,
        "TIMEFRAME_M15" => ENUM_TIMEFRAMES.PERIOD_M15,
        "TIMEFRAME_M30" => ENUM_TIMEFRAMES.PERIOD_M30,
        "TIMEFRAME_H1" => ENUM_TIMEFRAMES.PERIOD_H1,
        "TIMEFRAME_H4" => ENUM_TIMEFRAMES.PERIOD_H4,
        "TIMEFRAME_D1" => ENUM_TIMEFRAMES.PERIOD_D1,
        _ => default
    };

    return timeframe is "TIMEFRAME_M1" or "TIMEFRAME_M5" or "TIMEFRAME_M15" or "TIMEFRAME_M30" or "TIMEFRAME_H1" or "TIMEFRAME_H4" or "TIMEFRAME_D1";
}

bool TryParseClientDate(string value, out DateTime parsed)
{
    return DateTime.TryParse(value, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out parsed)
        || DateTime.TryParseExact(value, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out parsed);
}

MqlTick? WaitForTick(MtApi5Client mt, string symbol, int timeoutMs = 3000)
{
    for (int i = 0; i < timeoutMs / 100; i++)
    {
        var tick = mt.SymbolInfoTick(symbol);
        if (tick != null && tick.bid > 0) return tick;
        Thread.Sleep(100);
    }
    return mt.SymbolInfoTick(symbol);
}

uint ResolveFillingMode(MtApi5Client mt, string symbol, uint requestedFilling)
{
    try
    {
        var modeFlags = (long)mt.SymbolInfoInteger(symbol, ENUM_SYMBOL_INFO_INTEGER.SYMBOL_FILLING_MODE);
        bool fokSupported = (modeFlags & 1) != 0;
        bool iocSupported = (modeFlags & 2) != 0;

        bool requestedSupported = requestedFilling switch
        {
            0 => fokSupported,
            1 => iocSupported,
            2 => true,
            _ => false
        };

        if (requestedSupported) return requestedFilling;

        if (iocSupported) return 1;
        if (fokSupported) return 0;
        return 2;
    }
    catch
    {
        return requestedFilling;
    }
}

string? ValidateTradeRequest(TradeRequestDto request)
{
    if (!Enum.IsDefined(typeof(ENUM_TRADE_REQUEST_ACTIONS), (int)request.action))
        return "action is invalid.";
    if (string.IsNullOrWhiteSpace(request.symbol))
        return "symbol is required.";
    if (request.volume is not null && (!double.IsFinite(request.volume.Value) || request.volume.Value <= 0))
        return "volume must be a positive number.";
    if (request.price is not null && (!double.IsFinite(request.price.Value) || request.price.Value < 0))
        return "price must be a non-negative number.";
    if (request.sl is not null && (!double.IsFinite(request.sl.Value) || request.sl.Value < 0))
        return "sl must be a non-negative number.";
    if (request.tp is not null && (!double.IsFinite(request.tp.Value) || request.tp.Value < 0))
        return "tp must be a non-negative number.";
    if (request.order_type is not null && !Enum.IsDefined(typeof(ENUM_ORDER_TYPE), (int)request.order_type.Value))
        return "order_type is invalid.";
    if (request.deviation is not null && request.deviation.Value > 100000)
        return "deviation is unreasonably large.";

    return null;
}

MqlTradeRequest ToMqlTradeRequest(TradeRequestDto r)
{
    return new MqlTradeRequest
    {
        Action = (ENUM_TRADE_REQUEST_ACTIONS)r.action,
        Symbol = r.symbol,
        Volume = r.volume ?? 0,
        Type = (ENUM_ORDER_TYPE)(r.order_type ?? 0),
        Price = r.price ?? 0,
        Sl = r.sl ?? 0,
        Tp = r.tp ?? 0,
        Magic = r.magic ?? 0,
        Comment = r.comment ?? "",
        Order = r.order ?? 0,
        Position = r.position ?? 0,
        Deviation = r.deviation ?? 0,
        Type_filling = (ENUM_ORDER_TYPE_FILLING)(r.type_filling ?? 0),
        Type_time = (ENUM_ORDER_TYPE_TIME)(r.type_time ?? 0),
    };
}

class TradeRequestDto
{
    public uint action { get; set; }
    public string symbol { get; set; } = "";
    public double? volume { get; set; }
    public uint? order_type { get; set; }
    public double? price { get; set; }
    public double? sl { get; set; }
    public double? tp { get; set; }
    public ulong? magic { get; set; }
    public string? comment { get; set; }
    public ulong? order { get; set; }
    public ulong? position { get; set; }
    public ulong? deviation { get; set; }
    public uint? type_filling { get; set; }   // 0=FOK, 1=IOC, 2=RETURN — 经纪商常要求显式指定
    public uint? type_time { get; set; }      // 0=GTC, 1=DAY, 2=SPECIFIED, 3=SPECIFIED_DAY
}

class TradeRequestBody
{
    public TradeRequestDto request { get; set; } = new();
}

class GvarSetDto
{
    public double value { get; set; }
}

class ClosePositionDto
{
    public ulong ticket { get; set; }
    public double? volume { get; set; }   // null/0 = 全平；>0 = 部分平仓
    public ulong? deviation { get; set; }
}

class ModifyPositionDto
{
    public ulong ticket { get; set; }
    public double sl { get; set; }
    public double tp { get; set; }
}

class OrderTicketDto
{
    public ulong ticket { get; set; }
}

class ModifyOrderDto
{
    public ulong ticket { get; set; }
    public double price { get; set; }
    public double sl { get; set; }
    public double tp { get; set; }
}

class CloseByDto
{
    public ulong position { get; set; }
    public ulong position_by { get; set; }
}

class BatchCloseDto
{
    public string? symbol { get; set; }
    public ulong? magic { get; set; }
    public ulong? deviation { get; set; }
}

abstract class TickSubscriber
{
    public abstract ValueTask SendAsync(ReadOnlyMemory<byte> payload);
    public abstract bool IsAlive { get; }
}

sealed class WsSubscriber : TickSubscriber
{
    readonly WebSocket _ws;
    public WsSubscriber(WebSocket ws) => _ws = ws;
    public override bool IsAlive => _ws.State == WebSocketState.Open;
    public override ValueTask SendAsync(ReadOnlyMemory<byte> payload) =>
        _ws.SendAsync(payload, WebSocketMessageType.Text, true, CancellationToken.None);
}

sealed class SseSubscriber : TickSubscriber
{
    readonly Stream _stream;
    static readonly byte[] Prefix = Encoding.UTF8.GetBytes("data: ");
    static readonly byte[] Suffix = Encoding.UTF8.GetBytes("\n\n");
    public SseSubscriber(Stream stream) => _stream = stream;
    public override bool IsAlive => _stream.CanWrite;
    public override async ValueTask SendAsync(ReadOnlyMemory<byte> payload)
    {
        await _stream.WriteAsync(Prefix);
        await _stream.WriteAsync(payload);
        await _stream.WriteAsync(Suffix);
        await _stream.FlushAsync();
    }
}

class MtConnectionService : BackgroundService
{
    // Tick subscribers, keyed by symbol name. Each value is the set of connected
    // client sinks (WebSocket or SSE) listening to that symbol's tick stream.
    public static readonly ConcurrentDictionary<string, ConcurrentDictionary<TickSubscriber, byte>> TickSubscribers = new();
    public const int MaxSubscribersPerSymbol = 50;

    private readonly MtApi5Client _client;
    private readonly ILogger<MtConnectionService> _logger;
    private readonly TimeSpan _connectTimeout;
    private const int Port = 8228;
    private static readonly TimeSpan HeartbeatInterval = TimeSpan.FromSeconds(30);

    private static readonly JsonSerializerSettings JsonSettings = new()
    {
        DateFormatString = "yyyy-MM-ddTHH:mm:ss",
        Formatting = Formatting.None
    };

    public MtConnectionService(MtApi5Client client, ILogger<MtConnectionService> logger)
    {
        _client = client;
        _logger = logger;
        _connectTimeout = TimeSpan.FromSeconds(15);
        _client.QuoteUpdate += OnQuoteUpdate;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            if (_client.ConnectionState != Mt5ConnectionState.Connected)
            {
                var firstConnect = _client.ConnectionState == Mt5ConnectionState.Disconnected;
                _logger.LogWarning(firstConnect
                    ? "Connecting to MT5 via MtApi5 on port {Port}..."
                    : "MT5 disconnected, attempting reconnect on port {Port}...", Port);

                var connected = await TryConnectAsync(stoppingToken);
                if (!connected)
                {
                    _logger.LogError("MT5 is not connected. Ensure MtApi5 EA is loaded and listening on port {Port}.", Port);
                    await Task.Delay(TimeSpan.FromSeconds(5), stoppingToken);
                    continue;
                }

                _logger.LogInformation(firstConnect
                    ? "MT5 Bridge ready on http://localhost:8080"
                    : "MT5 reconnected.");
            }

            await Task.Delay(TimeSpan.FromSeconds(30), stoppingToken);
        }
    }

    private async Task<bool> TryConnectAsync(CancellationToken stoppingToken)
    {
        if (_client.ConnectionState == Mt5ConnectionState.Connected)
        {
            return true;
        }

        var tcs = new TaskCompletionSource<Mt5ConnectionState>(TaskCreationOptions.RunContinuationsAsynchronously);
        EventHandler<Mt5ConnectionEventArgs>? handler = null;
        handler = (_, e) =>
        {
            _logger.LogInformation("MT5 Connection: {Status}", e.Status);
            if (e.Status == Mt5ConnectionState.Connected || e.Status == Mt5ConnectionState.Failed || e.Status == Mt5ConnectionState.Disconnected)
            {
                tcs.TrySetResult(e.Status);
            }
        };

        _client.ConnectionStateChanged += handler;
        try
        {
            _client.BeginConnect(Port);
            using var timeoutCts = CancellationTokenSource.CreateLinkedTokenSource(stoppingToken);
            timeoutCts.CancelAfter(_connectTimeout);
            using var registration = timeoutCts.Token.Register(() => tcs.TrySetCanceled(timeoutCts.Token));
            var status = await tcs.Task;
            return status == Mt5ConnectionState.Connected;
        }
        catch (OperationCanceledException) when (!stoppingToken.IsCancellationRequested)
        {
            _logger.LogWarning("Timed out waiting {TimeoutSeconds}s for MT5 connection state change.", _connectTimeout.TotalSeconds);
            return false;
        }
        finally
        {
            _client.ConnectionStateChanged -= handler;
        }
    }

    private void OnQuoteUpdate(object? sender, Mt5QuoteEventArgs e)
    {
        if (!MtConnectionService.TickSubscribers.TryGetValue(e.Quote.Instrument, out var subs)) return;
        var payload = JsonConvert.SerializeObject(new
        {
            type = "tick",
            symbol = e.Quote.Instrument,
            time = e.Quote.Time,
            bid = e.Quote.Bid,
            ask = e.Quote.Ask,
            last = e.Quote.Last,
            volume = e.Quote.Volume,
            time_msc = e.Quote.Time.ToString("yyyy-MM-ddTHH:mm:ss.fff000"),
            flags = 6
        }, JsonSettings);
        var bytes = Encoding.UTF8.GetBytes(payload);
        // ponytail: fire-and-forget. Slow clients get dropped by SendAsync fault; cleanup happens on disconnect.
        foreach (var sub in subs.Keys)
        {
            if (sub.IsAlive) _ = sub.SendAsync(bytes);
        }
    }

    // ponytail: periodic heartbeat so clients behind NAT/firewall can detect liveness
    // even on low-liquidity symbols with no ticks for minutes.
    private static readonly byte[] HeartbeatPayload = Encoding.UTF8.GetBytes(
        JsonConvert.SerializeObject(new { type = "heartbeat", time = DateTime.UtcNow }));

    private static void BroadcastHeartbeat(object? _)
    {
        foreach (var subs in TickSubscribers.Values)
        {
            foreach (var sub in subs.Keys)
            {
                if (sub.IsAlive) _ = sub.SendAsync(HeartbeatPayload);
            }
        }
    }

    private readonly Timer _heartbeat = new(BroadcastHeartbeat, null, HeartbeatInterval, HeartbeatInterval);

    public override async Task StopAsync(CancellationToken cancellationToken)
    {
        await _heartbeat.DisposeAsync();
        await base.StopAsync(cancellationToken);
    }
}