using System.Runtime.CompilerServices;
using Ananta.SDK.Network;
using Ananta.SDK.Rpc;
using Ananta.SDK.Serialization;
using Ananta.Server.ClientData.Client4229938;
using Ananta.Server.Handlers;
using Ananta.Server.Protocol.Client4229938;
using Ananta.Server.RpcTypes.Client4229938;
using Auto = Ananta.Server.RpcTypes.Client4229938.Auto;
using GameMethods = Ananta.Server.RpcTypes.Client4229938.Methods.Game;
using SceneMethods = Ananta.Server.RpcTypes.Client4229938.Methods.GameScene;

namespace Ananta.Server.Handlers.Game;

internal sealed partial class GameRouter
{
    private const uint LixiSpirit4229938 = 15021021;
    private const uint PoliceRootNid4229938 = 10;
    private const string PoliceGateSessionKey4229938 = "lixi-police-gate";
    private const string PolicePreparedMessage4229938 = "PolicePrepared";
    private static long s_policeSupportId = 0x320000000000;
    private static readonly ConditionalWeakTable<TcpSession, PoliceRuntime4229938> PoliceRuntimes = new();
    private sealed class PoliceRuntime4229938
    {
        internal readonly SemaphoreSlim Gate = new(1, 1);
        internal readonly Dictionary<ulong, (Vec3 Position, uint Template)> Npcs = new();
        internal readonly List<ulong> Support = [];
        internal readonly Dictionary<uint, uint> Cooldowns = new();
        internal bool RootSent;
        internal int Generation = -1;
        internal uint NextNode = 0x20000, Child, LastSection;
        internal bool HasSection;
        internal DateTime EntryStartedUtc;
        internal ulong Agent, Owner;
        internal long Serial;
        internal string? PrepareNonce;
        internal ulong PrepareTarget, PrepareOwner;
        internal DateTime PrepareDeadline;
        internal readonly Dictionary<ulong, PolicePassenger4229938> Passengers = new();
        internal PolicePassenger4229938? PendingBoarding;
        internal bool Alighting;
        internal uint LastInteraction;
        internal readonly HashSet<ulong> PausedEscorts = new();
        internal ulong Detained;
        internal ulong PendingPrison;
        internal string? PrisonTimelineToken;
        internal ulong PrisonTimelineOwner;
        internal bool PrisonInteractionEnded, PrisonTimelineEnded;
        internal long PrisonCorrectionAt;
    }

    private static bool LixiReady(WorldEntryState? state) => state is
        { Ready: true, ActiveSpiritTemplateId: LixiSpirit4229938, PendingSwitchTemplateId: 0, PendingTeleportId: 0 }
        && state.ActiveSpiritUnitId != 0;

    // Lua-generated SpiritPoliceJobInfo uses Int32 collections internally, whereas
    // SyncPoliceDispatchInfos uses an Int7 dictionary at the method boundary.
    [UxContract] private sealed class PoliceDispatch4229938
    {
        public uint Id;
        public uint NextAvailableTime;
        public bool IsTemp = false;
        public uint TempEventId = 0;
        public uint TodayArrestSupportTimes = 0;
    }
    [UxContract] private sealed class PoliceService4229938
    {
        public uint DispatchTimes = 0, PatrolTimes = 0, ArrestTimes = 0, FineCount = 0;
        [UxCollection(Count = UxCountEncoding.Int32)] public List<uint> TotalDrops = [];
        public uint LastUpdateTime = 0, CarFineCount = 0;
    }
    [UxContract] private sealed class PoliceDuty4229938
    {
        public uint DailyViolationCount = 0, LeaveDueTime = 0, LastViolationUpdateTime = 0;
        public PoliceService4229938 ServiceData = new(), WeeklyServiceData = new();
        [UxCollection(Count = UxCountEncoding.Int32)] public Dictionary<uint, uint> ViolationCdInfos = new();
    }
    [UxContract] private sealed class PoliceJob4229938
    {
        [UxCollection(Count = UxCountEncoding.Int32, ValueObjectEncoding = UxObjectEncoding.Complex)]
        public Dictionary<uint, PoliceDispatch4229938> DispatchInfos = new();
        // No fabricated criminal records/rewards. Empty lists have the same wire
        // framing regardless of element type; populate only with exact DTOs later.
        [UxCollection(Count = UxCountEncoding.Int32)] public List<uint> ViolationInfos = [], CaseInfos = [];
        public PoliceDuty4229938 DutyBasicInfo = new();
        [UxCollection(Count = UxCountEncoding.Int32)] public List<ulong> EscortedNpcs = [];
        public PoliceFakeFile4229938 PoliceFakeFileInfo = new();
        [UxCollection(Count = UxCountEncoding.Int32)] public Dictionary<uint, uint> PeriodInvalidVehicleFine2CountDict = new();
        public uint NextPeriodUpdateTime = 0;
    }
    [UxContract] private sealed class PoliceFakeFile4229938
    {
        [UxCollection(Count = UxCountEncoding.Int32)] public Dictionary<uint, uint> UnlockFileInfoDict = new();
        [UxCollection(Count = UxCountEncoding.Int32)] public List<uint> HistoryClueAgentInfoList = [];
    }
    [UxContract(Inline = true)] private sealed class PoliceJobSync4229938
    { public uint SpiritId = LixiSpirit4229938; public PoliceJob4229938 Info = new(); }
    [UxContract(Inline = true)] private sealed class PoliceDispatchSync4229938
    {
        public uint SpiritId = LixiSpirit4229938;
        [UxCollection(Count = UxCountEncoding.Int7, ValueObjectEncoding = UxObjectEncoding.Complex)]
        public Dictionary<uint, PoliceDispatch4229938> Infos = new();
    }

    private static Dictionary<uint, PoliceDispatch4229938> PoliceDispatches(PoliceRuntime4229938 r)
        => new uint[] { 2, 4 }.ToDictionary(id => id, id => new PoliceDispatch4229938
        { Id = id, NextAvailableTime = r.Cooldowns.GetValueOrDefault(id) });

    private static async Task PublishLixiPolice4229938(TcpSession session, uint spiritId)
    {
        if (spiritId != LixiSpirit4229938) return;
        var state = GetStateIfExists(session);
        if (state is null || !state.Ready || state.ActiveSpiritTemplateId != spiritId
            || state.ActiveSpiritUnitId == 0 || state.PendingTeleportId != 0) return;
        var r = PoliceRuntimes.GetValue(session, _ => new());
        await r.Gate.WaitAsync(session.ClosedToken);
        try
        {
            // The role/scene may have changed while waiting behind support cleanup.
            if (!state.Ready || state.ActiveSpiritTemplateId != spiritId || state.ActiveSpiritUnitId == 0
                || state.PendingTeleportId != 0
                || (state.PendingSwitchTemplateId != 0 && state.PendingSwitchTemplateId != spiritId)) return;
            if (r.Generation != state.WorldEntryControlGeneration)
            { r.Detained = 0; r.PendingPrison = 0; r.PrisonCorrectionAt = 0; r.RootSent = false; r.Child = 0; r.Agent = 0; r.Npcs.Clear(); r.Passengers.Clear(); r.PausedEscorts.Clear(); r.PendingBoarding = null; r.Alighting = false; r.LastInteraction = 0; r.Generation = state.WorldEntryControlGeneration; }
            await session.NotifyAsync(MethodId.SyncSpiritPoliceJobInfo, UxSerializer.Serialize(new PoliceJobSync4229938
            { Info = new PoliceJob4229938 { DispatchInfos = PoliceDispatches(r) } }), session.ClosedToken);
            // Police APP's license vehicle button uses ApplyCarManager's owned
            // fleet, filtered by VehicleType.PoliceCar; dispatch entries are NOT cars.
            await session.NotifyAsync(MethodId.SyncAllUnlockedVehicles,
                UxSerializer.Serialize(VehicleOwnershipSnapshot(GetVehicleRuntimeState(session))), session.ClosedToken);
            if (!r.RootSent)
            {
                // SNpcBtnQuery requires PoliceJobManager.HasPoliceJob, not merely
                // S002 + exam data. Login intentionally seeds jobless characters.
                // Refresh ONLY the controlled Lixi after CurrentSpirit/duty hydration:
                // SyncSpiritJobInfo emits JOB_CHANGE_EVENT and recomputes the native
                // gate against the current actor (the pre-control switch event may
                // still see the previous actor). Keep the authored level-1 policy.
                var jobInfo = RuntimePayloadFactory.SpiritJobInfo4229938(spiritId);
                await SendLixiPoliceCareer4229938(session);
                await SendStoryAsync(session, StoryS002Codec4229938.Root(PoliceRootNid4229938));
                r.RootSent = true;
                await SendPoliceButtons4229938(session, r.Npcs.Keys.ToArray(), state.ActiveSpiritUnitId, true);
                session.Log.Info($"[LIXI-POLICE] F bootstrap active={spiritId}/{state.ActiveSpiritUnitId} generation={r.Generation} job={jobInfo.CurrentJob} level=1 order=duty,job,S002");
            }
            else
            {
                // S002 is scene-owned, not hero-owned. Reuse it when switching
                // back to Lixi; refresh eligibility/buttons for the current hero.
                await SendLixiPoliceCareer4229938(session);
                await SendPoliceButtons4229938(session, r.Npcs.Keys.ToArray(), state.ActiveSpiritUnitId, true);
            }
            await SendPolicePrisonButtons4229938(session, r, true);
            session.Log.Info("[LIXI-POLICE] S002 root and duty data published; dispatch=2,4; job level unchanged");
        }
        finally { r.Gate.Release(); }
    }

    private static async Task RegisterPoliceNpc4229938(TcpSession session, ulong id, uint template, Vec3 position)
    {
        var state = GetStateIfExists(session);
        if (state is null) return;
        var r = PoliceRuntimes.GetValue(session, _ => new());
        await r.Gate.WaitAsync(session.ClosedToken);
        try
        {
            if (r.Generation != state.WorldEntryControlGeneration)
            { r.Detained = 0; r.PendingPrison = 0; r.PrisonCorrectionAt = 0; r.Npcs.Clear(); r.Passengers.Clear(); r.PausedEscorts.Clear(); r.PendingBoarding = null; r.Alighting = false; r.LastInteraction = 0; r.Generation = state.WorldEntryControlGeneration; r.RootSent = false; r.Child = 0; r.Agent = 0; }
            r.Npcs[id] = (position, template);
        }
        finally { r.Gate.Release(); }
        // A session may enter directly as Lixi without the character-switch
        // publisher running. The native S002 root owns SNpcBtnQuery (the F UI).
        // Restore the current actor's level-1 career and police runtime together.
        // No other character's careers or buffs are replayed.
        if (LixiReady(state) && !r.RootSent)
            await PublishLixiPolice4229938(session, LixiSpirit4229938);
        await SendPoliceExamData4229938(session, id);
    }

    // AgentCharacterComponent is separate from AgentPoliceExamData. The native ID
    // panel unconditionally reads module.Component.Portrait. A missing component
    // throws before the close/continue callback is installed (Player.log 23:07:24).
    // 4000 is an existing NpcInformationPortraitConfig row, a neutral display tag
    // for our generated test NPCs; this does not invent crimes or grant rewards.
    internal static byte[] PoliceCharacterPacket4229938(ulong id)
        => new UxWriter().U64(id).U8(255).U32(4000).ToArray();

    private static Task SendPoliceCharacter4229938(TcpSession session, ulong id)
        => session.NotifyAsync(MethodId.SyncAgentCharacter, PoliceCharacterPacket4229938(id), session.ClosedToken);

    private static async Task SendPoliceExamData4229938(TcpSession session, ulong id)
    {
        // Replayed by the bounded post-spawn pass because SyncAgentCharacter
        // discards updates if the native agent has not finished loading yet.
        await SendPoliceCharacter4229938(session, id);
        // AgentPoliceExamData { FineTimes, Fines<int7,uint,bool> }.
        var w = new UxWriter(); w.U64(id); w.U8(255); w.U32(0); w.U8(255); w.Int7(0);
        await session.NotifyAsync(MethodId.SyncAgentPoliceExamData, w.ToArray(), session.ClosedToken);
    }

    private static Task SendLixiPoliceCareer4229938(TcpSession session)
    {
        var jobInfo = RuntimePayloadFactory.SpiritJobInfo4229938(LixiSpirit4229938);
        return session.NotifyAsync(MethodId.SyncSpiritJobInfo,
            UxSerializer.Serialize(new GameMethods.SyncSpiritJobInfo4229938
            {
                spiritId = LixiSpirit4229938,
                spiritJobs = jobInfo.AvailableJobs,
                currentJob = jobInfo.CurrentJob,
            }), session.ClosedToken);
    }

    private static async Task RefreshPoliceNpcInitializationPass4229938(TcpSession session, ulong[] ids, int generation)
    {
        var state = GetStateIfExists(session);
        if (state is null || !state.Ready || state.WorldEntryControlGeneration != generation
            || state.PendingTeleportId != 0 || !PoliceRuntimes.TryGetValue(session, out var r)) return;
        await r.Gate.WaitAsync(session.ClosedToken);
        try
        {
            // Recheck after the await: recall, teleport and character switching
            // can invalidate the state while this pass is waiting on the gate.
            if (!state.Ready || state.WorldEntryControlGeneration != generation
                || state.PendingTeleportId != 0 || r.Generation != generation) return;
            var tracked = ids.Distinct().Where(r.Npcs.ContainsKey).ToArray();
            if (tracked.Length == 0) return;
            foreach (var id in tracked)
                if (r.Child == 0 || r.Agent != id)
                    await SendPoliceExamData4229938(session, id);

            // RootSent records a server send, NOT completion of asynchronous
            // client actor loading. Exam data alone never updates HasPoliceJob.
            // Replay the current Lixi's level-1 JOB_CHANGE_EVENT after spawning,
            // without resetting duty/cooldowns, S002, POI, AI or an open panel.
            if (!LixiReady(state) || !r.RootSent || r.Child != 0) return;
            await SendLixiPoliceCareer4229938(session);
            await SendPoliceButtons4229938(session, tracked, state.ActiveSpiritUnitId, true);
            session.Log.Info($"[LIXI-POLICE] F post-spawn refresh active={state.ActiveSpiritUnitId} generation={generation} npcs={tracked.Length} job=301 level=1; client F visibility unconfirmed");
        }
        finally { r.Gate.Release(); }
    }

    private static async Task RefreshSpawnedPoliceNpcs4229938(TcpSession session, ulong[] ids, int generation)
    {
        // Client OnSyncExamineData drops updates before the asynchronous full
        // model exists. Two finite retries cover that handoff; never replay POI
        // or reset battle state after the player has started an interaction.
        try
        {
            foreach (var delay in new[] { 750, 1250 })
            {
                await Task.Delay(delay, session.ClosedToken);
                await RefreshPoliceNpcInitializationPass4229938(session, ids, generation);
            }
        }
        catch (OperationCanceledException) when (session.ClosedToken.IsCancellationRequested) { }
        catch (Exception ex) { session.Log.Info($"[LIXI-POLICE] NPC initialization retry stopped: {ex.Message}"); }
    }

    // Native SInteract.OnEnable uses ServerInitiate to construct its own
    // SPreInteractExam, instead of relying on the F-button's preparatory node.
    // Keep the GM nearest-target fallback on the known test model. Explicit F
    // requests can also target registered action NPCs and functional shopkeepers.
    internal static Task<(bool Ok, string Message)> ControlPoliceExam4229938(TcpSession session, bool start)
        => ControlPoliceTarget4229938(session, start, 0);

    private static async Task<(bool Ok, string Message)> ControlPoliceTarget4229938(TcpSession session, bool start, ulong requestedTarget)
    {
        var state = GetStateIfExists(session);
        if (state is null || !PoliceRuntimes.TryGetValue(session, out var r))
            return (false, "请先切换里希，并生成测试动作 NPC 4065053。");
        if (start && !LixiReady(state)) return (false, "请在场景加载完成后切换里希，等待切人/传送结束。");
        var generation = state.WorldEntryControlGeneration;
        var owner = state.ActiveSpiritUnitId;
        await r.Gate.WaitAsync(session.ClosedToken);
        try
        {
            if (!state.Ready || state.WorldEntryControlGeneration != generation || r.Generation != generation)
                return (false, "场景已变化，请在当前场景重新生成测试 NPC。");
            if (!start)
            {
                r.PrepareNonce = null;
                if (r.Child == 0) return (true, "当前没有服务端登记的盘查。");
                await ClosePoliceInteraction4229938(session, r, "GM cancelled");
                return (true, "已结束本次原生盘查；未召回支援或删除 NPC。");
            }
            if (!LixiReady(state) || state.ActiveSpiritUnitId != owner
                || !state.HasLastReportedPlayerTransform)
                return (false, "角色状态已变化，请使用里希在地面移动一下后重试。");
            if (GetVehicleRuntimeState(session).CurrentVehicleId != 0)
                return (false, "请先下车，再发起盘查。");
            if (r.Child != 0)
            {
                if (PoliceEntryRetryAllowed4229938(r))
                    await ClosePoliceInteraction4229938(session, r, "explicit retry of unresponsive exam entry");
                else return (true, "已有盘查正在进行；若尚未出现界面，请等待 10 秒后再次点击重试。");
            }
            if (r.PrepareNonce != null && DateTime.UtcNow < r.PrepareDeadline)
                return (true, "正在等待客户端原生盘查数据初始化回执，请稍候；可点结束盘查取消。");
            r.PrepareNonce = null;
            var p = state.LastReportedPlayerPosition;
            if (!float.IsFinite(p.X) || !float.IsFinite(p.Y) || !float.IsFinite(p.Z))
                return (false, "角色坐标无效，请移动后重试。");
            ulong target = 0;
            float nearest = 6 * 6;
            foreach (var (id, npc) in r.Npcs)
            {
                if (id == r.Detained) continue;
                // The GM fallback keeps its known test model; the independent F
                // button must examine exactly the registered NPC that was clicked.
                // ⛑⛑ 测试模板只能是 4065053：AgentConfig.json 的 ExamType=2。
                //   客户端原生 SNpcBtnQuery / PoliceJobUtils 对 ExamType!=2 的模板
                //   不授予盘查资格 ⇒ 面板能靠服务端硬推 S002 打开，但按键不挂
                //   原生流程（点了无反应），且菜单里不会给「押送上车」。
                //   反例：42031099（摩天轮售票员）ExamType=0，2026-10-02 实测就是这个症状。
                //   见 GameAdminBridge.SpawnPoliceTestNpcAsync 的注释。
                if (requestedTarget == 0 ? npc.Template != 4065053 : id != requestedTarget) continue;
                // This explicit F callback is already bound to a locally nearby
                // registered passenger. Map cars may have no server transform,
                // and a driven car's latest report can lag behind the local seat.
                // Do not extend this exception to GM nearest-target selection.
                if (requestedTarget == id && r.Passengers.ContainsKey(id))
                { target = id; break; }
                var targetPosition = PoliceTargetPosition4229938(session, r, id, npc.Position);
                float d2 = MathF.Pow(p.X - targetPosition.X, 2) + MathF.Pow(p.Y - targetPosition.Y, 2) + MathF.Pow(p.Z - targetPosition.Z, 2);
                if (!float.IsFinite(d2) || d2 > nearest || (d2 == nearest && target != 0 && id > target)) continue;
                nearest = d2; target = id;
            }
            if (target == 0) return (false, requestedTarget == 0
                ? "6 米内没有已登记的测试 NPC 4065053。请生成一个，等待模型加载后靠近；距离按服务端登记位置计算。"
                : "该 NPC 不在 6 米范围内，或已卸载/不属于本次生成。请靠近当前动作 NPC 或店员再试。");
            if (r.Passengers.ContainsKey(target))
            {
                await ReleasePolicePassenger4229938(session, r, target, besidePlayer: true);
                r.PausedEscorts.Add(target);
            }
            if (r.PausedEscorts.Contains(target))
            {
                // TemporaryLeave (18) preserves the native arrested state.
                // Starting an exam here cannot satisfy its native gates. Resume
                // through SPreInteractEscort; SEscortInteract opens the HUD itself.
                if (!r.RootSent)
                {
                    await SendStoryAsync(session, StoryS002Codec4229938.Root(PoliceRootNid4229938));
                    r.RootSent = true;
                }
                r.Child = ++r.NextNode; r.Agent = target; r.HasSection = false; r.LastInteraction = 0;
                r.EntryStartedUtc = DateTime.UtcNow;
                await SendStoryAsync(session, StoryS002Codec4229938.Interaction(r.Child, target,
                    start: false, escort: true, serverInitiate: true));
                session.Log.Info($"[LIXI-POLICE] resume escort agent={target} nid={r.Child}; awaiting native interaction 19");
                return (true, "已请求原生继续押送；靠近完成后由客户端恢复押送按键。");
            }
            if (!session.Items.TryGetValue(PoliceGateSessionKey4229938, out var gateValue)
                || gateValue is not TcpSession gate || gate.ClosedToken.IsCancellationRequested)
                return (false, "原生盘查初始化需要当前登录的 Gate 连接，请重新登录后再试；未启动空数据盘查。");
            // Only repair the missing story root after validating a target. Do not
            // replay job/duty initialization or reset the shared story ACK stream.
            if (!r.RootSent)
            {
                await SendStoryAsync(session, StoryS002Codec4229938.Root(PoliceRootNid4229938));
                r.RootSent = true;
            }
            await SendPoliceExamData4229938(session, target);
            r.PrepareNonce = Guid.NewGuid().ToString("N");
            r.PrepareTarget = target; r.PrepareOwner = owner;
            r.PrepareDeadline = DateTime.UtcNow.AddSeconds(10);
            var nonce = r.PrepareNonce;
            try
            {
                var w = new UxWriter(); w.UxString(PolicePrepareScript4229938(target, owner, nonce));
                await gate.NotifyAsync(MethodId.SyncDoToLuaMaster, w.ToArray(), session.ClosedToken);
            }
            catch { r.PrepareNonce = null; throw; }
            _ = ExpirePolicePrepare4229938(session, r, nonce);
            session.Log.Info($"[LIXI-POLICE] native prepare requested agent={target} generation={generation} via=Gate; awaiting data-ready receipt before S002");
            return (true, $"已请求为 NPC {target} 初始化原生盘查数据，客户端确认后才启动靠近和菜单。不需要按 F；无反应可查看 LIXI-POLICE 回执/超时日志。");
        }
        finally { r.Gate.Release(); }
    }

    // 4229938 MasterToClientImpl.SyncDoToLuaMaster (0x1281DDE0) calls the
    // built-in gCsToLuaHandler.GmRunLua, registered on Gate (0x14883B90).
    // Invoke the ORIGINAL PrepareData_Story, as S002PlayerNet.EnterExam does;
    // no replacement functions, persistent hooks, assets or client files.
    // GmUtils.ParseUlongToLua (0x14677AC0) uses ulong.new(low32, high32):
    // a decimal Lua number would round our 8300000000000000001 IDs.
    internal static string PolicePrepareScript4229938(ulong target, ulong owner, string nonce)
    {
        if (nonce.Length != 32 || nonce.Any(c => !char.IsAsciiHexDigit(c)))
            throw new ArgumentException("Invalid preparation nonce", nameof(nonce));
        static string U64(ulong id) => FormattableString.Invariant($"ulong.new({(uint)id}, {id >> 32})");
        static string Receipt(string text)
        {
            // Non-reliable SetMessageCommand + StringPayload; no ACK reset.
            var w = new UxWriter(); w.U8(255); w.Int7(1); w.U8(4);
            w.U32(PoliceRootNid4229938); w.UxString(PolicePreparedMessage4229938);
            w.U8(42); w.UxString(text); w.I64(0); w.Bool(false);
            return string.Join(",", w.ToArray());
        }
        return $$"""
            local ok, result = pcall(function()
                local player = gCS.MyPlayerManager.PlayerUnit
                local npc = gCS.SceneDataMgr.GetUnit({{U64(target)}})
                if not player or player.Pid ~= {{U64(owner)}} or not npc then return false end
                gPoliceJobManager:PrepareData_Story(npc.Pid)
                local data = gPoliceJobManager.examineMgr.enterExamData
                return data ~= nil and data.npcUnit == npc
            end)
            local bytes
            if ok and result then bytes = { {{Receipt(nonce + ":ok")}} }
            else
                print_error("[LIXI-POLICE] native prepare failed: " .. tostring(result))
                bytes = { {{Receipt(nonce + ":failed")}} }
            end
            gClientToGameSceneDelegate:Notify(67130745, function(writer)
                for i = 1, #bytes do writer:WriteByte(bytes[i]) end
            end)
            """;
    }

    private static async Task ExpirePolicePrepare4229938(TcpSession session, PoliceRuntime4229938 r, string nonce)
    {
        try
        {
            await Task.Delay(TimeSpan.FromSeconds(10), session.ClosedToken);
            await r.Gate.WaitAsync(session.ClosedToken);
            try
            {
                if (r.PrepareNonce != nonce) return;
                r.PrepareNonce = null;
                session.Log.Warn("[LIXI-POLICE] native prepare timed out; no S002 exam started. Check client GmRunLua/PrepareData_Story errors; retry is allowed.");
            }
            finally { r.Gate.Release(); }
        }
        catch (OperationCanceledException) when (session.ClosedToken.IsCancellationRequested) { }
        catch (Exception ex) { session.Log.Warn($"[LIXI-POLICE] prepare timeout cleanup: {ex.Message}"); }
    }

    // Cooperative reaction rows from PoliceExamReactionConfig. These are not a
    // simulation of guilt or fine adjudication: no money/rewards are invented.
    internal static uint PoliceReaction4229938(uint interaction) => interaction switch
    {
        1 => 1001, 2 => 2001, 3 => 3001, 4 => 4001, 5 => 5001, 6 => 6001,
        7 => 7001, 8 => 8001, 9 => 9001, 10 => 10001,
        11 or 12 => 12003, // No server evidence ledger: refuse ticket rather than award false success.
        13 => 13001, 14 => 14001, 15 => 15001, 16 => 16001, 17 => 17001,
        // 20001 Exit=EscortToVehicle(9) selects SEscortToVehicleInteract with
        // the client's requested VehicleId/SeatIndex. 15002 is Detach, NOT boarding.
        18 => 18001, 19 => 19001, 20 => 20001, 21 => 21001, 22 => 22001, 23 => 23001, 24 => 24001,
        30 => 30001, // EscortToWardCfg: native SEscortToWard + body-type timeline.
        _ => 15002, // Unsupported transport/case operation exits safely.
    };

    private static bool PoliceEscortVehicleRequestValid4229938(TcpSession session, PoliceStoryPayload4229938 request)
    {
        if (request.VehicleId == 0 || request.SeatIndex is < 0 or >= 16) return false;
        var vehicles = GetVehicleRuntimeState(session);
        lock (vehicles.SyncRoot)
        {
            // Map vehicles need not have a server spawn record. Preserve their
            // native selected target, but validate known GM/owned vehicles.
            if (!vehicles.Vehicles.TryGetValue(request.VehicleId, out var vehicle)) return true;
            byte seat = (byte)request.SeatIndex;
            return vehicle.Interactable && seat < vehicle.SeatCount
                && !vehicle.SeatOccupants.ContainsKey(seat) && !vehicle.SeatReservations.ContainsKey(seat);
        }
    }

    // Called with the police gate held. Deleting only this interaction invokes
    // native OnDisable cleanup without deleting the NPC, police root or support.
    private static bool PoliceEntryRetryAllowed4229938(PoliceRuntime4229938 r)
        => r.Child != 0 && !r.HasSection && r.LastInteraction == 0
            && !r.Alighting && r.PendingBoarding is null && r.PendingPrison == 0
            && !r.Passengers.ContainsKey(r.Agent) && !r.PausedEscorts.Contains(r.Agent)
            && r.EntryStartedUtc != default && DateTime.UtcNow - r.EntryStartedUtc >= TimeSpan.FromSeconds(10);

    private static async Task ClosePoliceInteraction4229938(TcpSession session, PoliceRuntime4229938 r, string reason)
    {
        if (r.Child == 0) return;
        await PoliceAlightVisualHeight4229938(session, r.Agent, restore: true);
        await PoliceBoardingFacing4229938(session, r, restore: true);
        await PoliceOfficerBoardingPosition4229938(session, r, 0, restore: true);
        if (r.LastInteraction is 19 or 20)
        {
            // Cancellation/role switching can end the paired action without
            // Clearance. Native OnDisable removes Escort, but keeps the arrest.
            r.PausedEscorts.Add(r.Agent);
            RememberPoliceEscortPosition4229938(session, r);
        }
        await SendStoryAsync(session, StoryS011Codec4229938.BuildDeleteNode(r.Child));
        CancelPoliceSeatReservation4229938(session, r);
        if (r.Alighting && r.Passengers.TryGetValue(r.Agent, out var restorePassenger))
        {
            // Successful native completion clears Alighting before Close. A
            // cancellation/timeout must restore, not evict, the seated passenger.
            await SendPolicePassengerBinding4229938(session, restorePassenger, board: true);
            session.Log.Info($"[LIXI-POLICE] alight rollback agent={r.Agent} vehicle={restorePassenger.Vehicle} seat={restorePassenger.Seat}");
        }
        session.Log.Info($"[LIXI-POLICE] exam closed agent={r.Agent} nid={r.Child} reason={reason}");
        r.Child = 0; r.Agent = 0; r.HasSection = false; r.LastSection = 0; r.Alighting = false; r.LastInteraction = 0; r.PendingPrison = 0;
        r.PrisonTimelineToken = null; r.PrisonTimelineOwner = 0; r.PrisonInteractionEnded = false; r.PrisonTimelineEnded = false;
        r.EntryStartedUtc = default;
    }

    private static async Task RecoverStalledPoliceBoarding4229938(TcpSession session, uint child, uint section, int generation, ulong owner)
    {
        if (!PoliceRuntimes.TryGetValue(session, out var r)) return;
        await r.Gate.WaitAsync(session.ClosedToken);
        try
        {
            var state = GetStateIfExists(session);
            if (!LixiReady(state) || state!.WorldEntryControlGeneration != generation || r.Generation != generation
                || state.ActiveSpiritUnitId != owner || r.Child != child || !r.HasSection || r.LastSection != section) return;
            await ClosePoliceInteraction4229938(session, r, "boarding-timeout; native cleanup, no forced teleport or reward");
        }
        finally { r.Gate.Release(); }
    }

    private static async Task WatchPoliceBoarding4229938(TcpSession session, uint child, uint section, int generation, ulong owner)
    {
        try
        {
            // A boarding transition is finite; ordinary ID/menu reading has no
            // timer. Stale timers cannot close a newer interaction/role/scene.
            await Task.Delay(TimeSpan.FromSeconds(20), session.ClosedToken);
            await RecoverStalledPoliceBoarding4229938(session, child, section, generation, owner);
        }
        catch (OperationCanceledException) when (session.ClosedToken.IsCancellationRequested) { }
        catch (Exception ex) { session.Log.Warn($"[LIXI-POLICE] boarding recovery failed: {ex.Message}"); }
    }

    private static async Task<bool> HandlePoliceStory4229938(TcpSession session, StoryClientCommand4229938 cmd)
    {
        if (cmd.Nid != PoliceRootNid4229938 && cmd.Nid < 0x20000) return false;
        if (cmd.Nid == PoliceRootNid4229938 && cmd.Name == "PolicePrisonTimelineEnd")
        {
            await HandlePolicePrisonTimelineEnd4229938(session, cmd.PayloadString);
            return true;
        }
        if (cmd.Nid == PoliceRootNid4229938 && cmd.Name == "PolicePrisonRequest")
        {
            // Same authoritative validation as GM; a position button is not
            // permission to arrest an arbitrary target or act across the map.
            var result = await ControlPolicePrison4229938(session, cmd.PayloadString ?? "");
            session.Log.Info($"[LIXI-PRISON] F request ok={result.Ok}: {result.Message}");
            // A rejected F previously produced no in-game feedback at all, so the
            // player could not tell which precondition failed. Reuse the shared
            // player message channel already used by taxi/autodrive/delivery.
            if (!result.Ok) await DeliveryText4229938(session, result.Message);
            return true;
        }
        // Enter before taking r.Gate: the preparation handshake owns that gate.
        if (cmd.Nid == PoliceRootNid4229938 && cmd.Name == "PoliceFRequest")
        {
            if (ulong.TryParse(cmd.PayloadString, System.Globalization.NumberStyles.None,
                System.Globalization.CultureInfo.InvariantCulture, out var target) && target != 0)
            {
                var result = await ControlPoliceTarget4229938(session, true, target);
                session.Log.Info($"[LIXI-POLICE] F request target={target} ok={result.Ok}: {result.Message}");
            }
            return true;
        }
        var r = PoliceRuntimes.GetValue(session, _ => new());
        await r.Gate.WaitAsync(session.ClosedToken);
        try
        {
            if (cmd.Nid != PoliceRootNid4229938 && (cmd.Nid <= 0x20000 || cmd.Nid > r.NextNode)) return false;
            var state = GetStateIfExists(session);
            if (!LixiReady(state) || !r.RootSent || r.Generation != state!.WorldEntryControlGeneration) return true;
            if (cmd.Nid == PoliceRootNid4229938 && cmd.Name == PolicePreparedMessage4229938)
            {
                var nonce = r.PrepareNonce;
                if (nonce == null || (cmd.PayloadString != nonce + ":ok" && cmd.PayloadString != nonce + ":failed")) return true;
                r.PrepareNonce = null;
                (Vec3 Position, uint Template) npc = default;
                var target = r.PrepareTarget;
                var p = state.LastReportedPlayerPosition;
                if (cmd.PayloadString != nonce + ":ok" || DateTime.UtcNow >= r.PrepareDeadline
                    || state.ActiveSpiritUnitId != r.PrepareOwner || !state.HasLastReportedPlayerTransform
                    || r.Child != 0 || !r.Npcs.TryGetValue(target, out npc)
                    || GetVehicleRuntimeState(session).CurrentVehicleId != 0)
                { session.Log.Warn("[LIXI-POLICE] native prepare failed or state changed; no exam started"); return true; }
                float d2 = MathF.Pow(p.X - npc.Position.X, 2) + MathF.Pow(p.Y - npc.Position.Y, 2) + MathF.Pow(p.Z - npc.Position.Z, 2);
                if (!float.IsFinite(d2) || d2 > 36) return true;
                r.Child = ++r.NextNode; r.Agent = target; r.HasSection = false; r.LastInteraction = 0;
                r.EntryStartedUtc = DateTime.UtcNow;
                await SendStoryAsync(session, StoryS002Codec4229938.Interaction(r.Child, target, start: true, serverInitiate: true));
                session.Log.Info($"[LIXI-POLICE] native prepare confirmed agent={target}; S002 started nid={r.Child} wire=s002-prepared-r3; awaiting menu Interaction");
                return true;
            }
            if (cmd.Nid == PoliceRootNid4229938 && cmd.Name == StoryS002Codec4229938.NpcInteract && cmd.Police is { } enter)
            {
                if (enter.AgentId == r.Detained && r.Detained != 0) return true;
                if (enter.Tag is not (StoryS002Codec4229938.EnterExamRequestTag
                    or StoryS002Codec4229938.EscortFromVehicleRequestTag
                    or StoryS002Codec4229938.EscortRequestTag) || !r.Npcs.TryGetValue(enter.AgentId, out var npc))
                { session.Log.Warn($"[LIXI-POLICE] untracked/unsupported target={enter.AgentId} tag={enter.Tag}"); return true; }
                bool fromVehicle = enter.Tag == StoryS002Codec4229938.EscortFromVehicleRequestTag;
                bool seated = r.Passengers.ContainsKey(enter.AgentId);
                var p = state.HasLastReportedPlayerTransform ? state.LastReportedPlayerPosition : state.WorldEntryCreateHeroPosition;
                var targetPosition = PoliceTargetPosition4229938(session, r, enter.AgentId, npc.Position);
                float d2 = MathF.Pow(p.X - targetPosition.X, 2) + MathF.Pow(p.Y - targetPosition.Y, 2) + MathF.Pow(p.Z - targetPosition.Z, 2);
                if (fromVehicle != seated)
                {
                    session.Log.Warn($"[LIXI-POLICE] native entry seat mismatch agent={enter.AgentId} tag={enter.Tag} fromVehicle={fromVehicle} seated={seated}; request not started");
                    return true;
                }
                // A known passenger has already been resolved from the local
                // seat by native EscortFromRequest (wire mark20). A stale pose must not strand
                // that local preinteraction waiting for a story response.
                if (!fromVehicle && (!float.IsFinite(d2) || d2 > 35 * 35))
                {
                    session.Log.Warn($"[LIXI-POLICE] native entry out of range agent={enter.AgentId} tag={enter.Tag} distance2={d2}");
                    return true;
                }
                if (r.Agent == enter.AgentId && r.Child != 0
                    && (enter.Tag != StoryS002Codec4229938.EnterExamRequestTag || !PoliceEntryRetryAllowed4229938(r))) return true;
                if (r.Child != 0) await ClosePoliceInteraction4229938(session, r, "replaced");
                // Spawn-time data may have arrived before the client model loaded.
                // Hydrate the selected NPC again on the same game connection,
                // before its interaction node is enabled. Do not replay job/root.
                if (enter.Tag == StoryS002Codec4229938.EnterExamRequestTag)
                    await SendPoliceExamData4229938(session, enter.AgentId);
                r.PrepareNonce = null;
                r.Child = ++r.NextNode; r.Agent = enter.AgentId; r.HasSection = false; r.LastInteraction = 0;
                r.EntryStartedUtc = DateTime.UtcNow;
                r.Alighting = fromVehicle;
                if (fromVehicle && r.Passengers.TryGetValue(r.Agent, out var alightPassenger))
                {
                    await BeginPoliceAlightVisualHeight4229938(session, r.Child, r.Agent, alightPassenger.Vehicle);
                    await PreparePoliceAlighting4229938(session, alightPassenger);
                }
                if (fromVehicle && r.Passengers.TryGetValue(r.Agent, out var tracePassenger))
                    _ = TracePoliceVehicleAnimation4229938(session, r.Child, r.Agent,
                        tracePassenger.Vehicle, tracePassenger.Seat, boarding: false);
                await SendStoryAsync(session, StoryS002Codec4229938.Interaction(r.Child, r.Agent, enter.StartInteract,
                    fromVehicle || enter.Tag == StoryS002Codec4229938.EscortRequestTag));
                if (r.Alighting)
                    _ = WatchPoliceAlighting4229938(session, r.Child, r.Generation, state.ActiveSpiritUnitId);
                session.Log.Info($"[LIXI-POLICE] F interaction agent={r.Agent} template={npc.Template} nid={r.Child} tag={enter.Tag} fromVehicle={fromVehicle} wire=escort-entry-r7");
                return true;
            }
            if (cmd.Nid != r.Child || r.Child == 0) return true;
            if (cmd.Name == StoryS002Codec4229938.InteractEnd && cmd.PayloadBool == true)
            {
                // The client has finished its authored boarding animation. Delete
                // that animation's story first, then persist the seat attachment.
                var boarding = r.PendingBoarding;
                var finishedAgent = r.Agent;
                // Config names, not assumed keyboard letters: 17 Clearance
                // (Exit2, clears arrest), 18 TemporaryLeave (Exit4, keeps arrest).
                if (r.LastInteraction is 17 or 18) RememberPoliceEscortPosition4229938(session, r);
                if (r.LastInteraction == 18) r.PausedEscorts.Add(finishedAgent);
                else if (r.LastInteraction == 17) r.PausedEscorts.Remove(finishedAgent);
                bool prisonFinished = r.PendingPrison == finishedAgent && r.LastInteraction == 30;
                if (prisonFinished)
                {
                    r.PrisonInteractionEnded = true;
                    await TryCompleteNativePolicePrison4229938(session, r, state);
                    return true; // Native timeline, not InteractEnd, owns the end boundary.
                }
                await ClosePoliceInteraction4229938(session, r, "client-InteractEnd");
                if (boarding != null) await CommitPolicePassenger4229938(session, r, boarding);
                else if (r.Npcs.ContainsKey(finishedAgent))
                    // ★★ 2026-10-02 18:1x：19 = 拘捕/押送开始。押送中**主动摘掉**我们注入的假 F 按钮
                    //   （`AddBtn`/`RemoveBtnByType` 会让客户端原生按钮列表失效，见 PoliceButtons.cs 注释），
                    //   把 NPC 头顶还给客户端原生菜单 ⇒ 「靠近警车按 X 押送上车」才有机会出现。
                    //   暂离(18)/放行(17)维持原行为（照常挂按钮）。
                    await SendPoliceButtons4229938(session, [finishedAgent], state.ActiveSpiritUnitId,
                        add: r.LastInteraction != 19);
            }
            else if (cmd.Name == StoryS002Codec4229938.InteractionMessage && cmd.Police is { Tag: 24 } request)
            {
                if (r.HasSection && request.SectionId <= r.LastSection) return true;
                if (request.InteractionId == 20 && !ReservePoliceSeat4229938(session, r, request))
                {
                    session.Log.Warn($"[LIXI-POLICE] invalid boarding target vehicle={request.VehicleId} seat={request.SeatIndex}; ending interaction safely");
                    await ClosePoliceInteraction4229938(session, r, "invalid-boarding-target");
                    return true;
                }
                // A request after the native SPreInteractEscortFromVehicle has
                // prepared means its get-out animation finished. Do not detach
                // before that node has resolved the passenger and seat.
                if ((r.Alighting && request.InteractionId == 19) || request.InteractionId == 21)
                {
                    await ReleasePolicePassenger4229938(session, r, r.Agent, besidePlayer: true);
                    r.Alighting = false;
                }
                if (request.InteractionId == 19)
                {
                    r.PausedEscorts.Remove(r.Agent);
                    RememberPoliceEscortPosition4229938(session, r);
                }
                // Send before the ID-check reaction starts its animation. Unlike
                // resetting exam data, this preserves existing examination progress.
                if (request.InteractionId == 3) await SendPoliceCharacter4229938(session, r.Agent);
                uint reaction = PoliceReaction4229938(request.InteractionId);
                if (request.InteractionId == 30)
                {
                    // Native Police_Prison sends EscortToWardCfg (30). Do not
                    // delete the paired escort or move the NPC until its timeline
                    // reports InteractEnd. Previously the unknown-ID fallback
                    // replied 15002 (Detach), leaving both actors in a bad pose.
                    bool valid = r.LastInteraction == 19 && r.Detained == 0
                        && r.PendingPrison == 0 && !r.Passengers.ContainsKey(r.Agent)
                        && r.Npcs.ContainsKey(r.Agent) && state.HasLastReportedPlayerTransform
                        && PolicePrisonNativeNear4229938(state.LastReportedPlayerPosition);
                    if (valid)
                    {
                        r.PendingPrison = r.Agent;
                        r.PrisonTimelineToken = Guid.NewGuid().ToString("N");
                        r.PrisonTimelineOwner = state.ActiveSpiritUnitId;
                        r.PrisonInteractionEnded = false; r.PrisonTimelineEnded = false;
                        await PreparePolicePrisonAnimation4229938(session, state.ActiveSpiritUnitId, r.Agent, r.PrisonTimelineToken);
                    }
                    else
                    {
                        reaction = 15002;
                        session.Log.Warn($"[LIXI-PRISON] rejected native ward request npc={r.Agent} last={r.LastInteraction} detained={r.Detained}");
                    }
                }
                if (request.InteractionId == 20)
                {
                    await PreparePoliceOfficerBoarding4229938(session, r, state.ActiveSpiritUnitId);
                    await PoliceOfficerBoardingPosition4229938(session, r, state.ActiveSpiritUnitId);
                    await PoliceBoardingFacing4229938(session, r, restore: false);
                }
                await SendStoryAsync(session, StoryS002Codec4229938.Reaction(r.Child, request.SectionId, reaction));
                if (request.InteractionId == 20)
                    _ = TracePoliceVehicleAnimation4229938(session, r.Child, r.Agent,
                        request.VehicleId, request.SeatIndex, boarding: true);
                r.HasSection = true; r.LastSection = request.SectionId; r.LastInteraction = request.InteractionId;
                if (request.InteractionId == 20)
                    _ = WatchPoliceBoarding4229938(session, r.Child, r.LastSection, r.Generation, state.ActiveSpiritUnitId);
                if (request.InteractionId == 30 && r.PendingPrison == r.Agent)
                    _ = WatchPolicePrison4229938(session, r.Child, r.Agent, r.Generation, state.ActiveSpiritUnitId);
                session.Log.Info($"[LIXI-POLICE] agent={r.Agent} interaction={request.InteractionId} section={request.SectionId} reaction={reaction} vehicle={request.VehicleId} seat={request.SeatIndex} wire=escort-lifecycle-r6");
            }
            else if (cmd.Name == StoryS002Codec4229938.ClientMessage)
                session.Log.Info($"[LIXI-POLICE] client event agent={r.Agent} name={cmd.PayloadString}");
            return true;
        }
        finally { r.Gate.Release(); }
    }

    internal static async Task StopLixiPolice4229938(TcpSession session, bool sceneChange = false, bool supportOnly = false)
    {
        if (!PoliceRuntimes.TryGetValue(session, out var r)) return;
        await r.Gate.WaitAsync(session.ClosedToken);
        try
        {
            if (supportOnly) return;
            if (r.Child != 0) await ClosePoliceInteraction4229938(session, r, "role/scene cleanup");
            foreach (var id in r.Passengers.Keys.ToArray())
                await ReleasePolicePassenger4229938(session, r, id, besidePlayer: !sceneChange);
            await SendPoliceButtons4229938(session, r.Npcs.Keys.ToArray(), 0, false);
            await SendPolicePrisonButtons4229938(session, r, false);
            r.PrepareNonce = null;
            if (r.Child != 0) await SendStoryAsync(session, StoryS011Codec4229938.BuildDeleteNode(r.Child));
            // SPreInteract.OnDisable looks up the unique S002 root before it
            // clears HasPreInteract, IsPoliceInteracting and playerPoliceStage.
            // Keep that scene-owned root alive on role changes; deleting both
            // together caused the observed native null-reference/locked F state.
            if (sceneChange && r.RootSent)
                await SendStoryAsync(session, StoryS011Codec4229938.BuildDeleteNode(PoliceRootNid4229938));
            r.Child = 0; r.Agent = 0;
            if (sceneChange) { r.Detained = 0; r.PendingPrison = 0; r.PrisonCorrectionAt = 0; r.RootSent = false; r.Npcs.Clear(); r.PausedEscorts.Clear(); r.Generation = -1; }
        }
        finally { r.Gate.Release(); }
    }
}