using System.Buffers.Binary;
using System.Threading;
using Ananta.SDK.Network;
using Ananta.SDK.Rpc;
using Ananta.Server.Protocol.Client4229938;
using SceneMethods = Ananta.Server.RpcTypes.Client4229938.Methods.GameScene;

namespace Ananta.Server.Handlers.Game;

/// <summary>
/// 移动命令的回执观测 —— <c>AskReportLogicAgentCommandSuccess2</c>(67057559)、
/// <c>AskReportLogicAgentCommandFail</c>(67193144)、<c>AskReportLogicAgentCommandData2</c>(67780469)、
/// <c>AskAgentPoiActionDone</c>(67016793)。
///
/// 移植自捐赠端 DremkaPS（2026-09-24）。他们这几条端点的价值写得很直白：
/// <c>SyncLogicAgentCommand</c> 对服务端是 fire-and-forget —— 客户端装了这条命令、还是拿到就丢了，
/// 在出站日志里长得<b>一模一样</b>。这几条是客户端的回答，有了它们，「行人还是不走」才能细分成
/// 「客户端收了 12 条一条没跑」还是「每一条进来就被拒了」—— 两种完全不同的故障，
/// 修法也完全相反。这正是服务端侧 stall 看门狗（规则 45）缺的那只眼睛。
///
/// ⛑⛑ 三条本服的取舍：
/// 1. <b>只观测，不改判定</b>。回执计数先落进 <c>AmbientPed</c>，但不参与
///    <c>StepFailCount</c> 的回收判据 —— 那套判据是实测调过的，先把数据看清楚再动。
///    日志里同时打出 <c>stepFail=</c>，两者的相关性肉眼就能对上。
/// 2. <b>只认我们自己的人</b>。捐赠端提醒过：ambient crowd 和客户端自己的场景行人也走这几条
///    notify，所以这里按 agentId 在 <c>AmbientState.Peds</c> 里查，查不到就直接返回。
/// 3. <b>POI 不重放</b>。捐赠端的 <c>AskAgentPoiActionDone</c> 会把同一个 POI 再放回去，
///    但本服根本不下发任何 POI action（Handlers / RpcTypes 里没有 POI 载荷），重放无从谈起；
///    而他们自己也写了客户端「350 ms 内上报 31 条」，没有闸门的重放就是一场包风暴。
///    这里只记观测日志。
/// </summary>
internal sealed partial class GameRouter
{
    // 规则 110：周期性/重复性事件不要「只打前 N 条」—— 那会让节奏类排查看到的全是假象。
    // 一律「前 N 条 + 之后每 M 条」，并且日志带 count，让「连续性」本身肉眼可验。
    private const int AckLogFirst = 10;
    private const int AckLogEvery = 50;

    /// <summary>
    /// ⛑⛑⛑ agentId 在 body 里的起点 —— <b>两条不一样</b>，而且<b>跟捐赠端给的契约都不一样</b>。
    ///
    /// 实测取自 <c>logs/unknown-methods.log</c>（2026-09-23 18:56，3.8 万条 Fail 全是 16 字节）：
    /// <code>
    /// Success2 (67057559) bytes=14  FF 02 | 1A00BE5306862F73 | A8000000
    ///                               ↑标记  ↑u64 agentId       ↑int commandId
    /// Fail     (67193144) bytes=16         0600BE5306862F73 | C6000000 | 00000000
    ///                                      ↑u64 agentId       ↑int commandId ↑尾部还有 4 字节
    /// </code>
    /// 校验：agentId 按 LE 读出来是 0x732F860653BE00xx ≈ 8.29e18，正好落在规则 23 的
    /// 行人号段 8_300e15 上 —— 说明这两个偏移是对的，也能确认这些回执确实是我们自己的人发的。
    ///
    /// 捐赠端把这两条当成同一个 12 字节布局（u64 + int，无标记），在 4229938 下<b>是错的</b>：
    /// Success2 少算了 2 字节前缀，Fail 少算了 4 字节尾巴。这正是规则 22 说的
    /// 「手写契约以实际 wire 为准，别信抄来的表」—— 所以这里干脆不碰契约，直接按偏移读。
    /// </summary>
    private const int SuccessAckAgentOffset = 2;
    private const int FailAckAgentOffset = 0;

    private static int s_ackReports;
    private static int s_ackUndecodable;
    private static int s_poiDone;

    [Handler(MethodId.AskReportLogicAgentCommandSuccess2, HandlerPacketKind.Notify)]
    private Task AgentCommandSuccess(Connection conn, UxRpcMessage msg)
    {
        // Success2 的 agentId 从第 2 字节起（前面 FF 02 是 nullable 标记 + dispatch tag）。
        if (!TryReadCommandAck(msg.Body, SuccessAckAgentOffset, out var agentId, out var commandId))
        {
            NoteUndecodable(conn, "Success2", msg.Body.Length);
            return Task.CompletedTask;
        }

        var ped = FindAmbientPed(conn.Session, agentId);
        if (ped is null)
            return Task.CompletedTask;

        int acks, fails, count;
        lock (AmbientState(conn.Session).SyncRoot)
        {
            ped.CommandAcks++;
            ped.LastAckCommandId = commandId;
            acks = ped.CommandAcks;
            fails = ped.CommandFails;
        }
        count = acks + fails;

        LogAck(conn, "ack", agentId, commandId, acks, fails, count, ped);
        return Task.CompletedTask;
    }

    [Handler(MethodId.AskReportLogicAgentCommandFail, HandlerPacketKind.Notify)]
    private Task AgentCommandFail(Connection conn, UxRpcMessage msg)
    {
        // Fail 的 body 没有前置标记，agentId 从第 0 字节起。
        if (!TryReadCommandAck(msg.Body, FailAckAgentOffset, out var agentId, out var commandId))
        {
            NoteUndecodable(conn, "Fail", msg.Body.Length);
            return Task.CompletedTask;
        }

        var ped = FindAmbientPed(conn.Session, agentId);
        if (ped is null)
            return Task.CompletedTask;

        int acks, fails, count;
        lock (AmbientState(conn.Session).SyncRoot)
        {
            ped.CommandFails++;
            ped.LastAckCommandId = commandId;
            acks = ped.CommandAcks;
            fails = ped.CommandFails;
        }
        count = acks + fails;

        LogAck(conn, "fail", agentId, commandId, acks, fails, count, ped);
        return Task.CompletedTask;
    }

    /// <summary>
    /// <c>AskReportLogicAgentCommandData2</c> 是 per-agent 的状态 / 层报告。只记条数与关键字段：
    /// 它回答的是「客户端到底有没有在跑这台状态机」，不需要逐条解析 <c>Data</c>。
    /// </summary>
    [Handler(MethodId.AskReportLogicAgentCommandData2, HandlerPacketKind.Notify)]
    private Task AgentCommandReport(Connection conn, UxRpcMessage msg)
    {
        var n = Interlocked.Increment(ref s_ackReports);
        if (n > AckLogFirst && n % AckLogEvery != 0)
            return Task.CompletedTask;

        var args = msg.TryGetArgs<SceneMethods.LogicAgentCommandReportData>(out var decoded) ? decoded : null;
        conn.Log.Info(args is null
            ? $"[CMD-ACK] report count={n} undecodable bytes={msg.Body.Length}"
            : $"[CMD-ACK] report count={n} agent={args.AgentId} type={args.Type} "
              + $"layer={args.Layer}/{args.StateLayer} data={(args.Data?.Count ?? 0)}B");
        return Task.CompletedTask;
    }

    /// <summary>
    /// <c>AskAgentPoiActionDone</c>：观测 only（理由见文件头第 3 条）。
    /// </summary>
    [Handler(MethodId.AskAgentPoiActionDone, HandlerPacketKind.Notify)]
    private Task AgentPoiActionDone(Connection conn, UxRpcMessage msg)
    {
        var n = Interlocked.Increment(ref s_poiDone);
        if (n > AckLogFirst && n % AckLogEvery != 0)
            return Task.CompletedTask;

        var args = msg.TryGetArgs<SceneMethods.AskAgentPoiActionDone>(out var decoded) ? decoded : null;
        conn.Log.Info(args is null
            ? $"[CMD-ACK] poi-done count={n} undecodable bytes={msg.Body.Length}"
            : $"[CMD-ACK] poi-done count={n} agent={args.agentId} poi={args.poiActionId} (no replay: server sends no POI)");
        return Task.CompletedTask;
    }

    // ------------------------------------------------------------------ helpers

    /// <summary>
    /// 按实测偏移读回执里的 (agentId, commandId)。agentId 固定 8 字节 LE，commandId 紧跟其后 4 字节 LE。
    /// 长度不够就返回 false —— 宁可记一条 undecodable，也不要读半个字段当真值。
    /// </summary>
    private static bool TryReadCommandAck(byte[] body, int agentOffset, out ulong agentId, out int commandId)
    {
        agentId = 0;
        commandId = 0;
        if (body is null || body.Length < agentOffset + 12)
            return false;

        agentId = BinaryPrimitives.ReadUInt64LittleEndian(body.AsSpan(agentOffset));
        commandId = BinaryPrimitives.ReadInt32LittleEndian(body.AsSpan(agentOffset + 8));
        return true;
    }

    private static AmbientPed? FindAmbientPed(TcpSession session, ulong agentId)
    {
        if (agentId == 0)
            return null;

        var state = AmbientState(session);
        lock (state.SyncRoot)
        {
            foreach (var ped in state.Peds)
            {
                if (ped.Id == agentId)
                    return ped;
            }
        }
        return null;
    }

    private static void LogAck(Connection conn, string kind, ulong agentId, int commandId,
        int acks, int fails, int count, AmbientPed ped)
    {
        if (count > AckLogFirst && count % AckLogEvery != 0)
            return;

        // stepFail 一并打出：服务端自己算的卡死计数与客户端回执的相关性，一眼就能对上。
        conn.Log.Info($"[CMD-ACK] {kind} agent={agentId} cmd={commandId} acks={acks} fails={fails} "
                      + $"count={count} stepFail={ped.StepFailCount} walking={ped.Walking}");
    }

    private static void NoteUndecodable(Connection conn, string kind, int bytes)
    {
        var n = Interlocked.Increment(ref s_ackUndecodable);
        if (n > AckLogFirst && n % AckLogEvery != 0)
            return;

        conn.Log.Warn($"[CMD-ACK] {kind} body did not decode ({bytes}B) count={n}");
    }
}