acdream/tests/AcDream.App.Tests/Rendering/Walk/WalkTraceConformanceTests.cs

using AcDream.App.Tests.Rendering;
using AcDream.App.Rendering.Walk;
using DatReaderWriter;
using DatReaderWriter.Options;

namespace AcDream.App.Tests.Rendering.Walk;

/// <summary>
/// FW1's conformance gate, first slice: replay pose-stamped oracle
/// fixtures through the ported walk and require the identical event
/// sequence. The projection-light interior fixtures gate first
/// (docs/research/2026-08-30-fw-walk-oracle/README.md, posed round);
/// the outdoor/landscape fixtures join as the landscape world build
/// lands.
/// </summary>
[Trait("Lane", "InstalledDat")]
public sealed class WalkTraceConformanceTests
{
    private sealed class Recorder : IWalkEventSink
    {
        public readonly List<WalkEvent> Events = new();
        public void Emit(in WalkEvent walkEvent) => Events.Add(walkEvent);
    }

    private static DatCollection OpenDats()
    {
        string? datDir = CornerFloodReplayTests.ResolveDatDir();
        if (datDir is null)
        {
            Assert.Fail("Lane=InstalledDat requires an installed retail DAT directory; see docs/release-gate.md.");
        }
        return new DatCollection(datDir!, DatAccessType.Read);
    }

    [Fact]
    public void Street_outdoor_first_frame_diff()
    {
        // The first landscape-involving conformance case: diff-first (the
        // assert prints both signatures on mismatch for adjudication).
        IReadOnlyList<WalkOracleFrame> frames =
            WalkOracleTrace.Load("posed/holtburg-street-outdoor");
        Assert.NotEmpty(frames);
        using DatCollection dats = OpenDats();
        WalkOracleFrame frame = frames[1];   // frame 2: pose settled (marker timing)
        Assert.NotNull(frame.Pose);
        WalkLandscapeDatBuilder.BuiltWorld world =
            WalkLandscapeDatBuilder.Build(dats, frame.Pose!.CellId, frame.Pose.Origin);
        var ctx = new WalkTraceReplayContext(frame.Pose, world.Cells)
        {
            Buildings = world.Buildings,
        };
        var walk = new RetailFrameWalk();
        var recorder = new Recorder();

        walk.WalkFrame(frame.Pose.CellId, null, world.Landscape, ctx, recorder);

        string expected = WalkTraceReplayContext.Signature(frame);
        string actual = WalkTraceReplayContext.Signature(recorder.Events);
        Assert.True(
            expected == actual,
            $"walk diverged from retail\nEXPECTED: {expected}\nACTUAL:   {actual}");
    }

    [Fact]
    public void Doorway_still_first_frame_diff()
    {
        // Interior flood adjudication: DI + DC(ov=2, n=3) + the landscape
        // through two exit views — tests the flood depth in isolation from
        // the building look-in machinery.
        IReadOnlyList<WalkOracleFrame> frames =
            WalkOracleTrace.Load("posed/holtburg-doorway-still");
        Assert.NotEmpty(frames);
        using DatCollection dats = OpenDats();
        WalkOracleFrame frame = frames[1];
        Assert.NotNull(frame.Pose);
        WalkLandscapeDatBuilder.BuiltWorld world =
            WalkLandscapeDatBuilder.Build(dats, frame.Pose!.CellId, frame.Pose.Origin);
        var ctx = new WalkTraceReplayContext(frame.Pose, world.Cells)
        {
            Buildings = world.Buildings,
        };
        WalkCell camera = Assert.Contains(frame.Pose.CellId, world.Cells);
        var walk = new RetailFrameWalk();
        var recorder = new Recorder();

        walk.WalkFrame(frame.Pose.CellId, camera, world.Landscape, ctx, recorder);

        string expected = WalkTraceReplayContext.Signature(frame);
        string actual = WalkTraceReplayContext.Signature(recorder.Events);
        Assert.True(
            expected == actual,
            $"walk diverged from retail\nEXPECTED: {expected}\nACTUAL:   {actual}");
    }

    [Theory]
    [InlineData("posed/terrace-center")]
    [InlineData("posed/terrace-edge")]
    [InlineData("posed/cathedral-arrival")]
    public void Still_fixture_first_frame_reproduces_exactly(string fixture)
    {
        IReadOnlyList<WalkOracleFrame> frames = WalkOracleTrace.Load(fixture);
        Assert.NotEmpty(frames);
        using DatCollection dats = OpenDats();
        WalkOracleFrame frame = frames[1];
        Assert.NotNull(frame.Pose);
        WalkLandscapeDatBuilder.BuiltWorld world =
            WalkLandscapeDatBuilder.Build(dats, frame.Pose!.CellId, frame.Pose.Origin);
        var ctx = new WalkTraceReplayContext(frame.Pose, world.Cells)
        {
            Buildings = world.Buildings,
        };
        WalkCell? camera = (frame.Pose.CellId & 0xFFFFu) >= 0x100
            ? Assert.Contains(frame.Pose.CellId, world.Cells)
            : null;
        var walk = new RetailFrameWalk();
        var recorder = new Recorder();

        walk.WalkFrame(frame.Pose.CellId, camera, world.Landscape, ctx, recorder);

        string expected = WalkTraceReplayContext.Signature(frame);
        string actual = WalkTraceReplayContext.Signature(recorder.Events);
        Assert.True(
            expected == actual,
            $"walk diverged from retail ({fixture})\nEXPECTED: {expected}\nACTUAL:   {actual}");
    }

    [Theory(Skip = "FW1 moving tail (2026-08-30 v2): six still fixtures frame-exact; "
        + "the moving four diverge at punch-edge frames under BOTH adjacent poses "
        + "(walkout/transitions F2 - retail punches 001e from deeper in the "
        + "cottage; walkabout F9; foundry-entry F67). FALSIFIED: pose-lag "
        + "pairing, gate polarity swaps (raw+flipped-gates broke 3 still "
        + "fixtures - reverted). Next: znear (CY d guess 0.1), per-view punch "
        + "ordering inside DrawMesh, and exit-view precision at edge angles.")]
    [InlineData("posed/holtburg-walkout")]
    [InlineData("posed/holtburg-transitions")]
    [InlineData("posed/holtburg-walkabout")]
    [InlineData("posed/foundry-entry")]
    public void Moving_fixture_reproduces_every_pairable_frame(string fixture)
    {
        // Marker timing: the pose stamped at frame N+1 is the camera state
        // frame N drew with (fixture README) — pair events(N) with
        // pose(N+1). One walk + one landscape carry state across frames,
        // reproducing retail's cross-frame caches (the stale cell-order
        // quirk included).
        IReadOnlyList<WalkOracleFrame> frames = WalkOracleTrace.Load(fixture);
        Assert.True(frames.Count >= 3);
        using DatCollection dats = OpenDats();
        WalkOraclePose anchor = frames[1].Pose!;
        WalkLandscapeDatBuilder.BuiltWorld world =
            WalkLandscapeDatBuilder.Build(dats, anchor.CellId, anchor.Origin);
        var walk = new RetailFrameWalk();

        for (int n = 1; n < frames.Count - 1; n++)
        {
            WalkOracleFrame frame = frames[n];
            string expected = WalkTraceReplayContext.Signature(frame);
            // The marker dumps the PREVIOUS frame's camera, so frame N's
            // true camera state lies between pose(N) and pose(N+1) — a
            // capture artifact, not a port ambiguity. A frame passes when
            // the replay matches under either adjacent pose.
            string? firstActual = null;
            bool matched = false;
            foreach (WalkOraclePose pose in new[] { frames[n + 1].Pose!, frame.Pose! })
            {
                Assert.NotNull(pose);
                WalkLandscapeDatBuilder.SetViewer(world.Landscape, pose.CellId, pose.Origin);
                var ctx = new WalkTraceReplayContext(pose, world.Cells)
                {
                    Buildings = world.Buildings,
                };
                WalkCell? camera = null;
                if ((pose.CellId & 0xFFFFu) >= 0x100)
                {
                    Assert.True(
                        world.Cells.TryGetValue(pose.CellId, out camera),
                        $"frame {frame.Number}: interior camera cell {pose.CellId:x8} not loaded");
                }
                var recorder = new Recorder();
                walk.WalkFrame(pose.CellId, camera, world.Landscape, ctx, recorder);
                string actual = WalkTraceReplayContext.Signature(recorder.Events);
                firstActual ??= actual;
                if (actual == expected)
                {
                    matched = true;
                    break;
                }
            }
            Assert.True(
                matched,
                $"frame {frame.Number} diverged under both adjacent poses ({fixture})\n"
                + $"EXPECTED: {expected}\nACTUAL:   {firstActual}");
        }
    }

    [Fact]
    public void Foundry_deep_reproduces_every_complete_frame_exactly()
    {
        IReadOnlyList<WalkOracleFrame> frames = WalkOracleTrace.Load("posed/foundry-deep");
        Assert.NotEmpty(frames);
        using DatCollection dats = OpenDats();
        Dictionary<uint, WalkCell> cells =
            WalkWorldDatAdapter.BuildInteriorCells(dats, 0xA9B40000u);
        var landscape = new WalkLandscape { MidWidth = 1, Blocks = new WalkLandBlock?[1] };

        foreach (WalkOracleFrame frame in frames)
        {
            Assert.NotNull(frame.Pose);
            WalkCell camera = Assert.Contains(frame.Pose!.CellId, cells);
            var ctx = new WalkTraceReplayContext(frame.Pose, cells);
            var walk = new RetailFrameWalk();
            var recorder = new Recorder();

            walk.WalkFrame(frame.Pose.CellId, camera, landscape, ctx, recorder);

            Assert.Equal(
                WalkTraceReplayContext.Signature(frame),
                WalkTraceReplayContext.Signature(recorder.Events));
        }
    }
}