using System;
using System.IO;
using System.Numerics;
using DatReaderWriter;
using DatReaderWriter.DBObjs;
using DatReaderWriter.Options;
using AcDream.Core.Physics;
using Xunit;
using Xunit.Abstractions;
using Env = System.Environment;
using Plane = System.Numerics.Plane;

namespace AcDream.Core.Tests.Physics;

/// <summary>
/// #137 corridor-seam replay (2026-07-06) — dat-backed reproduction of the
/// Facility Hub phantom hit (launch-175-verify2.log:42858): running +X down
/// the corridor, crossing 0x8A02016E → 0x8A02017A at x≈85.25, the live
/// client recorded `ok=True hit=yes n=(−1.00,0.03,−0.03)` with full advance,
/// persisted the sliding normal, and every later forward resolve absorbed to
/// zero (`ok=False hit=no`).
///
/// <para>
/// Dat facts pinned by <see cref="Issue137CorridorSeamInspectionTests"/>:
/// neither corridor cell (nor any portal-adjacent neighbor) has a physics
/// polygon whose plane matches that normal near the hit point — the recorded
/// normal is SYNTHETIC (the negated movement direction), which is exactly
/// what slide_sphere's opposing-normals branch records. Retail
/// (<c>CSphere::slide_sphere</c> 0x00537440 @0x0053762c) returns
/// COLLIDED_TS from that branch; our port returned OK — letting the step
/// complete with full advance and the synthetic normal persisted.
/// </para>
///
/// <para>
/// This replay drives the real engine over the real dat cells with the
/// live-log positions and player dimensions, and pins: the seam crossing
/// must complete WITHOUT persisting a sliding normal, and continued forward
/// running must keep advancing (no absorbing wedge).
/// </para>
/// </summary>
public class Issue137CorridorSeamReplayTests
{
    private readonly ITestOutputHelper _out;
    public Issue137CorridorSeamReplayTests(ITestOutputHelper output) => _out = output;

    private const uint SeamCellWest = 0x8A02016Eu;
    private const uint SeamCellEast = 0x8A02017Au;

    private static string? FindDatDir()
    {
        var datDir = Env.GetEnvironmentVariable("ACDREAM_DAT_DIR")
            ?? Path.Combine(Env.GetFolderPath(Env.SpecialFolder.UserProfile),
                            "Documents", "Asheron's Call");
        return Directory.Exists(datDir) ? datDir : null;
    }

    /// <summary>
    /// Hydrate the two seam cells + every portal-adjacent neighbor into a
    /// PhysicsEngine, exactly as the streaming path does (CacheCellStruct
    /// with the dat world transform).
    /// </summary>
    private static PhysicsEngine BuildCorridorEngine(DatCollection dats)
    {
        var engine = new PhysicsEngine();
        engine.DataCache = new PhysicsDataCache();

        var toLoad = new System.Collections.Generic.HashSet<uint> { SeamCellWest, SeamCellEast };
        foreach (var seed in new[] { SeamCellWest, SeamCellEast })
        {
            var seedCell = dats.Get<EnvCell>(seed);
            Assert.NotNull(seedCell);
            foreach (var p in seedCell!.CellPortals)
                toLoad.Add(0x8A020000u | p.OtherCellId);
        }

        // Expand three portal rings — the live collision cell array reaches
        // cells three hops out (0x8A020166, the under-ramp room whose ceiling
        // is the ramp slab's underside, is ring-3 in the 2026-07-06
        // seam-shake trace; with only two rings the offline flood can never
        // add it and the shake does not reproduce).
        for (int ring = 0; ring < 3; ring++)
        {
            foreach (var known in new System.Collections.Generic.List<uint>(toLoad))
            {
                var cell = dats.Get<EnvCell>(known);
                if (cell is null) continue;
                foreach (var p in cell.CellPortals)
                    toLoad.Add(0x8A020000u | p.OtherCellId);
            }
        }

        foreach (var cellId in toLoad)
        {
            var envCell = dats.Get<EnvCell>(cellId);
            if (envCell is null) continue;
            var environment = dats.Get<DatReaderWriter.DBObjs.Environment>(0x0D000000u | envCell.EnvironmentId);
            if (environment is null) continue;
            if (!environment.Cells.TryGetValue(envCell.CellStructure, out var cs)) continue;

            var rot = new Quaternion(
                envCell.Position.Orientation.X, envCell.Position.Orientation.Y,
                envCell.Position.Orientation.Z, envCell.Position.Orientation.W);
            var world = Matrix4x4.CreateFromQuaternion(rot)
                      * Matrix4x4.CreateTranslation(
                            envCell.Position.Origin.X, envCell.Position.Origin.Y, envCell.Position.Origin.Z);

            engine.DataCache.CacheCellStruct(cellId, envCell, cs!, world);
        }

        return engine;
    }

    private static PhysicsBody GroundedBody()
    {
        var body = new PhysicsBody();
        body.ContactPlaneValid = true;
        // Corridor floor at world z = −6 → n·p + d = 0 with n = +Z, d = 6.
        body.ContactPlane      = new Plane(Vector3.UnitZ, 6f);
        body.TransientState   |= TransientStateFlags.Contact | TransientStateFlags.OnWalkable;
        // The live session carried a walkable polygon (walkable=True on every
        // [resolve] line) — seed the corridor floor slab so the transition's
        // SetWalkable path runs like live.
        body.WalkablePolygonValid = true;
        body.WalkablePlane        = new Plane(Vector3.UnitZ, 6f);
        body.WalkableUp           = Vector3.UnitZ;
        body.WalkableVertices     = new[]
        {
            new Vector3(75f, -41.67f, -6f),
            new Vector3(85f, -41.67f, -6f),
            new Vector3(85f, -38.33f, -6f),
            new Vector3(75f, -38.33f, -6f),
        };
        return body;
    }

    private ResolveResult Resolve(PhysicsEngine engine, PhysicsBody body,
        Vector3 from, Vector3 to, uint cellId)
        => engine.ResolveWithTransition(
            currentPos:     from,
            targetPos:      to,
            cellId:         cellId,
            sphereRadius:   0.48f,   // human player, PlayerMovementController:885
            sphereHeight:   1.2f,    // human player, PlayerMovementController:886
            stepUpHeight:   0.4f,    // PlayerMovementController defaults
            stepDownHeight: 0.4f,
            isOnGround:     true,
            body:           body,
            moverFlags:     ObjectInfoState.IsPlayer | ObjectInfoState.EdgeSlide);

    /// <summary>
    /// 2026-07-06 seam-shake repro, snapshot-exact (probe session
    /// launch-137-seam-probes.log + resolve-137-seam-capture.jsonl tick 4101,
    /// repeated ×46): running WEST across the x=75 boundary
    /// (0x8A02016E → 0x8A020165, the ramp cell) from (75.287, −40.035, −6)
    /// toward (74.685, −39.988, −6), the resolve blocks with the SYNTHETIC
    /// reversed-movement normal (0.997, −0.078, −0.002) and out==in — every
    /// frame — the "shaking at the seam" report.
    ///
    /// <para>
    /// Probe-traced chain: the foot sphere (tangent to the floor) crosses
    /// onto 0165's ramp floor; the ramp slab is double-faced and the
    /// UNDERSIDE face (poly 0, n=(−0.03,0,−1)) grazes the sphere within the
    /// hit threshold → recorded as a foot near-miss → neg-poly step-up
    /// dispatch with a downward normal → the nested step-up's walkable probe
    /// rejects the exactly-tangent ramp floor ([walkable-nearest]
    /// gap=−0.0000 overlapsSphere=False) → StepUpSlide →
    /// slide_sphere(downward normal vs up-facing contact plane) → the
    /// opposing-normals branch → Collided → revert. Repeat.
    /// </para>
    /// </summary>
    [Fact(Skip = "#137 seam shake — deterministic RED repro; the post-step-up check-pos restore clobbers the lifted position (P2 stale-snapshot class). Un-skip with the fix.")]
    public void SeamShake_WestBoundary_SnapshotExact_Advances()
    {
        var datDir = FindDatDir();
        if (datDir is null)
        {
            _out.WriteLine("SKIP: dat directory not found");
            return;
        }

        using var dats = new DatCollection(datDir, DatAccessType.Read);
        var engine = BuildCorridorEngine(dats);

        // Body seeded EXACTLY from the capture's bodyBefore (tick 4101).
        var body = new PhysicsBody();
        body.ContactPlaneValid   = true;
        body.ContactPlane        = new Plane(Vector3.UnitZ, 6f);
        body.ContactPlaneCellId  = SeamCellWest;
        body.TransientState     |= TransientStateFlags.Contact | TransientStateFlags.OnWalkable;
        body.WalkablePolygonValid = true;
        body.WalkablePlane        = new Plane(Vector3.UnitZ, 6f);
        body.WalkableUp           = Vector3.UnitZ;
        body.WalkableVertices     = new[]
        {
            new Vector3(75f,       -38.33333f, -6f),
            new Vector3(75f,       -41.66667f, -6f),
            new Vector3(78.33333f, -41.66667f, -6f),
            new Vector3(78.33333f, -38.33333f, -6f),
        };

        var from = new Vector3(75.28674f, -40.03537f, -6f);
        var to   = new Vector3(74.6854f,  -39.988018f, -6f);

        // Emit the same step-level probes the live session logged so the
        // offline trace can be line-diffed against launch-137-seam-probes.log
        // — the first divergent line names the state the replay is missing.
        var probeBuffer = new System.IO.StringWriter();
        var prevOut = Console.Out;
        ResolveResult r1;
        try
        {
            Console.SetOut(probeBuffer);
            PhysicsDiagnostics.ProbeStepWalkEnabled  = true;
            PhysicsDiagnostics.ProbePushBackEnabled  = true;
            PhysicsDiagnostics.ProbeIndoorBspEnabled = true;

            r1 = engine.ResolveWithTransition(
                currentPos:     from,
                targetPos:      to,
                cellId:         SeamCellWest,
                sphereRadius:   0.48f,
                sphereHeight:   1.2f,
                stepUpHeight:   0.6f,    // live Setup values from the capture
                stepDownHeight: 1.5f,
                isOnGround:     true,
                body:           body,
                moverFlags:     ObjectInfoState.IsPlayer | ObjectInfoState.EdgeSlide);
        }
        finally
        {
            PhysicsDiagnostics.ProbeStepWalkEnabled  = false;
            PhysicsDiagnostics.ProbePushBackEnabled  = false;
            PhysicsDiagnostics.ProbeIndoorBspEnabled = false;
            Console.SetOut(prevOut);
        }
        _out.WriteLine(probeBuffer.ToString());

        _out.WriteLine($"r1: ok={r1.Ok} out=({r1.Position.X:F3},{r1.Position.Y:F3},{r1.Position.Z:F3}) " +
                       $"cell=0x{r1.CellId:X8} hit={r1.CollisionNormalValid} " +
                       $"n=({r1.CollisionNormal.X:F2},{r1.CollisionNormal.Y:F2},{r1.CollisionNormal.Z:F2}) " +
                       $"bodySliding={body.TransientState.HasFlag(TransientStateFlags.Sliding)}");

        Assert.True(r1.Position.X < from.X - 0.3f,
            $"The westward boundary crossing onto the ramp must advance " +
            $"({from.X:F3} → {r1.Position.X:F3}, target {to.X:F3}); zero " +
            $"advance with the reversed-movement normal = the seam shake.");
    }

    /// <summary>
    /// 2026-07-06 gate session repro (launch-137-corridor-gate.log): standing
    /// at (84.851, −39.764, −6.000) — the foot sphere already straddling the
    /// x=85 cell boundary by 0.33 m — the first move attempt toward
    /// (85.453, −39.782) blocked with the synthetic reversed-movement normal
    /// (−1.00, 0.03, −0.02), out==in, cp lost (cp=none), and repeated every
    /// frame (the "shaking at the seam" report). The deeper straddle start is
    /// what the original replay frame (84.638 → 85.253) didn't cover.
    /// </summary>
    [Fact(Skip = "#137 seam shake — deterministic RED repro; the post-step-up check-pos restore clobbers the lifted position (P2 stale-snapshot class). Un-skip with the fix.")]
    public void SeamCrossing_FromDeepStraddleStart_Advances()
    {
        var datDir = FindDatDir();
        if (datDir is null)
        {
            _out.WriteLine("SKIP: dat directory not found");
            return;
        }

        using var dats = new DatCollection(datDir, DatAccessType.Read);
        var engine = BuildCorridorEngine(dats);
        var body   = GroundedBody();

        var from = new Vector3(84.851f, -39.764f, -6.000f);
        var to   = new Vector3(85.453f, -39.782f, -6.000f);

        var r1 = Resolve(engine, body, from, to, SeamCellWest);
        _out.WriteLine($"r1: ok={r1.Ok} out=({r1.Position.X:F3},{r1.Position.Y:F3},{r1.Position.Z:F3}) " +
                       $"cell=0x{r1.CellId:X8} hit={r1.CollisionNormalValid} " +
                       $"n=({r1.CollisionNormal.X:F2},{r1.CollisionNormal.Y:F2},{r1.CollisionNormal.Z:F2}) " +
                       $"bodySliding={body.TransientState.HasFlag(TransientStateFlags.Sliding)} " +
                       $"bodyCpValid={body.ContactPlaneValid}");

        Assert.True(r1.Position.X > from.X + 0.2f,
            $"The straddling-start seam crossing must advance " +
            $"({from.X:F3} → {r1.Position.X:F3}); zero advance with a " +
            $"reversed-movement normal = the 2026-07-06 seam shake.");
    }

    [Fact(Skip = "#137 seam shake — deterministic RED repro; the post-step-up check-pos restore clobbers the lifted position (P2 stale-snapshot class). Un-skip with the fix.")]
    public void SeamCrossing_DoesNotPersistSyntheticSlidingNormal_AndRunContinues()
    {
        var datDir = FindDatDir();
        if (datDir is null)
        {
            _out.WriteLine("SKIP: dat directory not found");
            return;
        }

        using var dats = new DatCollection(datDir, DatAccessType.Read);
        var engine = BuildCorridorEngine(dats);
        var body   = GroundedBody();

        // ── The live hit frame verbatim (launch-175-verify2.log:42858) ──
        var from = new Vector3(84.638f, -39.758f, -6.000f);
        var to   = new Vector3(85.253f, -39.776f, -6.000f);

        var r1 = Resolve(engine, body, from, to, SeamCellWest);
        _out.WriteLine($"r1: ok={r1.Ok} out=({r1.Position.X:F3},{r1.Position.Y:F3},{r1.Position.Z:F3}) " +
                       $"cell=0x{r1.CellId:X8} hit={r1.CollisionNormalValid} " +
                       $"n=({r1.CollisionNormal.X:F2},{r1.CollisionNormal.Y:F2},{r1.CollisionNormal.Z:F2}) " +
                       $"bodySliding={body.TransientState.HasFlag(TransientStateFlags.Sliding)} " +
                       $"slidingN=({body.SlidingNormal.X:F2},{body.SlidingNormal.Y:F2},{body.SlidingNormal.Z:F2})");

        // The corridor is straight and open: the crossing must not leave the
        // body carrying a sliding normal (there is no wall to slide on —
        // Issue137CorridorSeamInspectionTests proved no polygon matches the
        // live-recorded normal; retail's slide_sphere opposing branch returns
        // COLLIDED and its validate handling never lets a synthetic
        // reversed-movement normal survive a clean corridor run).
        Assert.False(body.TransientState.HasFlag(TransientStateFlags.Sliding),
            "Crossing the open corridor seam must not persist a sliding " +
            "normal — the live wedge's entry state (#137 mechanism 2).");

        // ── Keep running +X (the live session's held-W frames) ──────────
        var pos  = r1.Position;
        var cell = r1.CellId;
        for (int i = 0; i < 6; i++)
        {
            var step = new Vector3(0.13f, -0.004f, 0f);   // ~run speed per tick, same heading
            var r = Resolve(engine, body, pos, pos + step, cell);
            _out.WriteLine($"r{i + 2}: ok={r.Ok} out=({r.Position.X:F3},{r.Position.Y:F3},{r.Position.Z:F3}) " +
                           $"cell=0x{r.CellId:X8} hit={r.CollisionNormalValid} " +
                           $"bodySliding={body.TransientState.HasFlag(TransientStateFlags.Sliding)}");
            Assert.True(r.Position.X > pos.X + 0.05f,
                $"Forward run must keep advancing through the open corridor " +
                $"(frame {i + 2}: {pos.X:F3} → {r.Position.X:F3}) — zero advance " +
                $"= the #137 absorbing wedge.");
            pos  = r.Position;
            cell = r.CellId;
        }
    }
}