acdream/tests/AcDream.App.Tests/Rendering/RetailPViewPassExecutorTests.cs

using System.Reflection;
using AcDream.App.Composition;
using AcDream.App.Rendering;
using AcDream.App.Rendering.Sky;
using AcDream.App.Rendering.Walk;
using AcDream.App.Tests.Architecture;

namespace AcDream.App.Tests.Rendering;

public sealed class RetailPViewPassExecutorTests
{
    [Fact]
    public void Extracted_contracts_retain_no_window_callbacks_or_visibility_owner()
    {
        Assert.DoesNotContain(
            typeof(RetailPViewFrameInput).GetProperties(),
            property => typeof(Delegate).IsAssignableFrom(property.PropertyType));

        FieldInfo[] fields = typeof(RetailPViewPassExecutor).GetFields(
            BindingFlags.Instance | BindingFlags.NonPublic);
        Assert.DoesNotContain(fields, field => field.FieldType == typeof(GameWindow));
        Assert.DoesNotContain(fields, field => field.FieldType == typeof(CellVisibility));
        Assert.DoesNotContain(fields, field => field.FieldType == typeof(RetailPViewFrameInput));
        Assert.DoesNotContain(fields, field => field.FieldType == typeof(RetailPViewFrameResult));
        Assert.DoesNotContain(fields, field => field.FieldType == typeof(ClipFrameAssembly));
        Assert.DoesNotContain(
            fields,
            field => typeof(Delegate).IsAssignableFrom(field.FieldType));
    }

    [Fact]
    public void Concrete_executor_accumulates_walk_terrain_batch_timing()
    {
        // S3 chunk 3 fix round 1 (F3): the walk leaf no longer brackets
        // itself with Begin()/Complete() (that stopwatch-restart pair would
        // push one timing SAMPLE per batch, not one per frame) — it times
        // itself with a raw Stopwatch.GetTimestamp() delta and hands the
        // elapsed ticks to AccumulateWalkBatch, which only accumulates.
        MethodInfo landscape = typeof(RetailPViewPassExecutor).GetMethod(
            "DrawWalkLandCellBatch",
            BindingFlags.Instance | BindingFlags.NonPublic)!;
        IReadOnlyList<CompiledCall> landscapeCalls = CompiledCallGraph.Read(landscape);
        int terrainDraw = RequiredCallIndex(
            landscapeCalls,
            typeof(TerrainModernRenderer),
            nameof(TerrainModernRenderer.DrawLandCells));
        int accumulate = RequiredCallIndex(
            landscapeCalls,
            typeof(TerrainDrawDiagnosticsController),
            nameof(TerrainDrawDiagnosticsController.AccumulateWalkBatch));

        Assert.True(terrainDraw < accumulate);
        Assert.DoesNotContain(
            landscapeCalls,
            call => call.Target.DeclaringType == typeof(TerrainDrawDiagnosticsController)
                && call.Target.Name == nameof(TerrainDrawDiagnosticsController.Begin));
        Assert.DoesNotContain(
            landscapeCalls,
            call => call.Target.DeclaringType == typeof(TerrainDrawDiagnosticsController)
                && call.Target.Name == nameof(TerrainDrawDiagnosticsController.Complete));
    }

    [Fact]
    public void Concrete_executor_pushes_the_walk_terrain_frame_sample_at_replay_end()
    {
        // S3 chunk 3 fix round 1 (F3): DrawWalkDrivenStatics is the ONE call
        // site of driver.Replay in production — CompleteWalkTerrainFrame
        // must run immediately after it, so the frame's sample is pushed
        // exactly once, at "the end of the walk replay".
        MethodInfo drawWalkDrivenStatics = typeof(RetailPViewRenderer).GetMethod(
            "DrawWalkDrivenStatics",
            BindingFlags.Instance | BindingFlags.NonPublic)!;
        IReadOnlyList<CompiledCall> calls = CompiledCallGraph.Read(drawWalkDrivenStatics);
        int replay = RequiredCallIndex(
            calls,
            typeof(AcDream.App.Rendering.Walk.WalkFrameDriver),
            nameof(AcDream.App.Rendering.Walk.WalkFrameDriver.Replay));
        int completeWalkFrame = RequiredCallIndex(
            calls,
            typeof(RetailPViewPassExecutor),
            nameof(RetailPViewPassExecutor.CompleteWalkTerrainFrame));

        Assert.True(replay < completeWalkFrame);
    }

    [Fact]
    public void Frame_composition_constructs_one_walk_executor()
    {
        MethodInfo compose = typeof(FrameRootCompositionPhase).GetMethod(
            "ComposeCore",
            BindingFlags.Instance | BindingFlags.NonPublic)!;
        IReadOnlyList<CompiledCall> calls = CompiledCallGraph.Read(compose);

        int executor = RequiredCallIndex(
            calls,
            typeof(RetailPViewPassExecutor),
            ".ctor");
        int renderer = RequiredCallIndex(
            calls,
            typeof(WorldScenePViewRenderer),
            ".ctor");

        Assert.True(executor < renderer);
        Assert.Single(
            calls,
            call => call.Target.DeclaringType == typeof(RetailPViewPassExecutor)
                && call.Target.Name == ".ctor");
        Assert.Single(
            calls,
            call => call.Target.DeclaringType == typeof(WorldScenePViewRenderer)
                && call.Target.Name == ".ctor");
    }

    /// <summary>
    /// S3 chunk 1 fix round 2 (§11.6 H1): the weather MESH draw + its OC
    /// print moved OUT of the per-slice loop into
    /// <see cref="RetailPViewPassExecutor.DrawWeatherOnce"/>
    /// (that method's own doc comment has the full decomp citation).
    /// <see cref="RetailPViewPassExecutor.DrawLandscapeSliceLate"/> must no
    /// longer call either <see cref="SkyRenderer.RenderWeather"/> or
    /// <see cref="WalkTranscriptDump"/>'s OC print — only the per-slice
    /// rain PARTICLE emitters (<c>ParticleRenderer.Draw</c>) stay here.
    /// MUTATION: re-inlining either call back into this method makes the
    /// corresponding <c>Assert.DoesNotContain</c> fail.
    /// </summary>
    [Fact]
    public void DrawLandscapeSliceLate_NoLongerDrawsOrPrintsTheWeatherPass()
    {
        MethodInfo method = typeof(RetailPViewPassExecutor).GetMethod(
            nameof(RetailPViewPassExecutor.DrawLandscapeSliceLate),
            BindingFlags.Instance | BindingFlags.Public)!;
        IReadOnlyList<CompiledCall> calls = CompiledCallGraph.Read(method);

        Assert.DoesNotContain(
            calls,
            call => call.Target.DeclaringType == typeof(SkyRenderer)
                && call.Target.Name == nameof(SkyRenderer.RenderWeather));
        Assert.DoesNotContain(
            calls,
            call => call.Target.DeclaringType == typeof(WalkTranscriptDump)
                && call.Target.Name == "PrintObjectCellTurn");
    }

    /// <summary>
    /// S3 chunk 1 fix round 2 (§11.6 H1): the new call site itself — exactly
    /// one <see cref="SkyRenderer.RenderWeather"/> draw and exactly one OC
    /// print per invocation (retail draws the weather pass exactly once per
    /// frame; this method is the ONE call site production now uses — see
    /// <see cref="DrawLandscapeDynamicsPhase_CallsDrawWeatherOnceExactlyOnceAfterTheSliceLoop"/>).
    /// MUTATION: deleting either call makes the matching
    /// <c>Assert.Single</c> fail (zero matches instead of one).
    /// </summary>
    [Fact]
    public void DrawWeatherOnce_DrawsTheWeatherMeshAndPrintsExactlyOnce()
    {
        MethodInfo method = typeof(RetailPViewPassExecutor).GetMethod(
            nameof(RetailPViewPassExecutor.DrawWeatherOnce),
            BindingFlags.Instance | BindingFlags.Public)!;
        IReadOnlyList<CompiledCall> calls = CompiledCallGraph.Read(method);

        Assert.Single(
            calls,
            call => call.Target.DeclaringType == typeof(SkyRenderer)
                && call.Target.Name == nameof(SkyRenderer.RenderWeather));
        Assert.Single(
            calls,
            call => call.Target.DeclaringType == typeof(WalkTranscriptDump)
                && call.Target.Name == "PrintObjectCellTurn");
    }

    /// <summary>
    /// S3 chunk 1 fix round 2 (§11.6 H1): the actual wiring fix — production
    /// must call <c>DrawWeatherOnce</c> exactly ONCE, positioned AFTER the
    /// (single, in-loop) <c>DrawLandscapeSliceLate</c> call site. A
    /// <c>foreach</c> loop compiles to ONE call instruction regardless of
    /// how many <c>OutsideViewSlices</c> it iterates at runtime — an
    /// interior root's 2-4 exit views would otherwise still print 2-4 OC
    /// lines even after <see cref="DrawLandscapeSliceLate_NoLongerDrawsOrPrintsTheWeatherPass"/>
    /// passes, if <c>DrawWeatherOnce</c> were called FROM INSIDE that same
    /// loop instead of after it. IL offsets (not list position) prove
    /// source order for this straight-line method. MUTATION: moving the
    /// <c>DrawWeatherOnce</c> call back inside the <c>foreach</c> (or before
    /// the loop) makes the offset-ordering assertion fail; adding a second
    /// call site makes <c>Assert.Single</c> fail.
    /// </summary>
    [Fact]
    public void DrawLandscapeDynamicsPhase_CallsDrawWeatherOnceExactlyOnceAfterTheSliceLoop()
    {
        MethodInfo method = typeof(RetailPViewRenderer).GetMethod(
            "DrawLandscapeDynamicsPhase",
            BindingFlags.Instance | BindingFlags.NonPublic)!;
        IReadOnlyList<CompiledCall> calls = CompiledCallGraph.Read(method);

        CompiledCall sliceLate = Assert.Single(
            calls,
            call => call.Target.DeclaringType == typeof(RetailPViewPassExecutor)
                && call.Target.Name == nameof(RetailPViewPassExecutor.DrawLandscapeSliceLate));
        CompiledCall weatherOnce = Assert.Single(
            calls,
            call => call.Target.DeclaringType == typeof(RetailPViewPassExecutor)
                && call.Target.Name == nameof(RetailPViewPassExecutor.DrawWeatherOnce));

        Assert.True(
            sliceLate.Offset < weatherOnce.Offset,
            "DrawWeatherOnce must be called AFTER the per-slice loop, not from inside it.");
    }

    /// <summary>
    /// S3 chunk 1 fix round 2 (§11.6 H1): <see
    /// cref="RetailPViewPassExecutor.ShouldDrawWeatherOnce"/> is
    /// <see cref="DrawWeatherOnce_DrawsTheWeatherMeshAndPrintsExactlyOnce"/>'s
    /// gate, extracted as a pure predicate so this suite can pin "no OC line
    /// while the player stands indoors" without a live GL/DAT
    /// <see cref="SkyRenderer"/> — combined with the two structural tests
    /// above (moved out of the loop; drawn/printed exactly once per call),
    /// this proves both halves of the spec's pin: an outdoor root (or an
    /// interior root with several exit-view slices) prints exactly one OC
    /// line, and an indoor player prints none. Retail's own check:
    /// <c>SmartBox::is_player_outside</c> @0x00451e80,
    /// <c>(player objcell_id &amp; 0xFFFF) &lt; 0x100</c>. MUTATION: negating
    /// the <c>&lt; 0x100</c> comparison (or dropping either bool AND) makes
    /// one of the four rows below fail.
    /// </summary>
    [Theory]
    [InlineData(true, true, 0xF4180003u, true)]    // outdoor root, player outside a land cell -> draws
    [InlineData(true, true, 0xA9B40100u, false)]   // player indoors (local id >= 0x100) -> no draw
    [InlineData(false, true, 0xF4180003u, false)]  // RenderSky off -> no draw
    [InlineData(true, false, 0xF4180003u, false)]  // RenderWeather off -> no draw
    public void ShouldDrawWeatherOnce_MatchesRetailIsPlayerOutsideGate(
        bool renderSky, bool renderWeather, uint playerCellId, bool expected)
    {
        Assert.Equal(
            expected,
            RetailPViewPassExecutor.ShouldDrawWeatherOnce(renderSky, renderWeather, playerCellId));
    }

    private static int RequiredCallIndex(
        IReadOnlyList<CompiledCall> calls,
        Type declaringType,
        string methodName)
    {
        int index = CompiledCallGraph.IndexOf(calls, declaringType, methodName);
        Assert.True(
            index >= 0,
            $"Expected call to {declaringType.Name}.{methodName}.");
        return index;
    }
}