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

using System.Globalization;
using System.Text.RegularExpressions;

namespace AcDream.App.Tests.Rendering.Walk;

/// <summary>
/// S3 chunk 1 (§11.2 B2): small, read-only parsers for the OH capture
/// family's two companion logs — the PARTS log
/// (<c>tools/walk-oracle/oh/oh-capture-parts.cdb.template</c>: PD/DM) and
/// the ALPHA-DEPTH log
/// (<c>tools/walk-oracle/oh/oh-capture-alpha-depth.cdb.template</c>: AM/FL/
/// PM/PC), both dumped from the SAME <c>docs/research/2026-09-01-overhaul/
/// oh-capture/</c> directory as the walk log <see cref="WalkOracleTrace"/>
/// already parses. These are records only — no validator, no canonical
/// JSONL, no new tool ([[feedback-evidence-infrastructure-sink]]) — a later
/// chunk/S4 names the first real consumer and pins specific values then.
/// </summary>
public static class WalkOraclePartsTrace
{
    /// <summary>Parses a PARTS log (<c>&lt;pose&gt;.parts.log</c>). Same
    /// F/P framing and truncated-last-frame drop rule as
    /// <see cref="WalkOracleTrace.Parse"/> — the harness detaches at the
    /// frame marker, so the final "F n" never records its own PD/DM lines.</summary>
    public static IReadOnlyList<WalkOraclePartsFrame> Parse(IEnumerable<string> lines)
    {
        var frames = new List<WalkOraclePartsFrame>();
        List<WalkOraclePartDraw>? partDraws = null;
        List<WalkOracleMeshDraw>? meshDraws = null;
        int currentNumber = 0;

        foreach (string line in lines)
        {
            Match frameMatch = FramePattern.Match(line);
            if (frameMatch.Success)
            {
                if (partDraws is not null)
                {
                    frames.Add(new WalkOraclePartsFrame(currentNumber, partDraws, meshDraws!));
                }
                currentNumber = int.Parse(
                    frameMatch.Groups[1].Value, CultureInfo.InvariantCulture);
                partDraws = new List<WalkOraclePartDraw>();
                meshDraws = new List<WalkOracleMeshDraw>();
                continue;
            }
            if (partDraws is null)
                continue;

            Match pd = PartDrawPattern.Match(line);
            if (pd.Success)
            {
                partDraws.Add(new WalkOraclePartDraw(
                    ParseHex(pd.Groups[1].Value),
                    ParseHex(pd.Groups[2].Value),
                    pd.Groups[3].Value != "0",
                    ParseHex(pd.Groups[4].Value)));
                continue;
            }
            Match dm = MeshDrawPattern.Match(line);
            if (dm.Success)
            {
                meshDraws!.Add(new WalkOracleMeshDraw(
                    ParseHex(dm.Groups[1].Value),
                    ParseHex(dm.Groups[2].Value),
                    dm.Groups[3].Value != "0",
                    int.Parse(dm.Groups[4].Value, CultureInfo.InvariantCulture),
                    ParseHex(dm.Groups[5].Value)));
                continue;
            }
            // Anything else (the "P …" pose line included — parts fixtures
            // carry no pose consumer today) is ignored, matching
            // WalkOracleTrace's own "cdb chrome" tolerance.
        }

        return frames;
    }

    public static IReadOnlyList<WalkOraclePartsFrame> Load(string root, string fixtureName)
        => Parse(File.ReadLines(FixturePath(root, fixtureName, ".parts.log")));

    private static string FixturePath(string root, string fixtureName, string suffix)
    {
        string repoRoot = WalkOracleTraceRepoRoot.Find();
        return Path.Combine(
            repoRoot, Path.Combine(root.Split('/')), fixtureName + suffix);
    }

    private static uint ParseHex(string hex)
        => uint.Parse(hex, NumberStyles.HexNumber, CultureInfo.InvariantCulture);

    private static readonly Regex FramePattern = new(@"^F (\d+)\s*$", RegexOptions.Compiled);

    // PD gfx=<hex8> did=<hex8> force=<0|1> cell=<hex8>
    private static readonly Regex PartDrawPattern = new(
        @"^PD gfx=([0-9a-f]{8}) did=([0-9a-f]{8}) force=(\d) cell=([0-9a-f]{8})\s*$",
        RegexOptions.Compiled);

    // DM gfx=<hex8> did=<hex8> force=<0|1> bound=<0|1|2> cell=<hex8>
    private static readonly Regex MeshDrawPattern = new(
        @"^DM gfx=([0-9a-f]{8}) did=([0-9a-f]{8}) force=(\d) bound=(\d) cell=([0-9a-f]{8})\s*$",
        RegexOptions.Compiled);
}

/// <summary>One <c>CPhysicsPart::Draw</c> @0x0050D7A0 entry (PD line).</summary>
public sealed record WalkOraclePartDraw(uint Gfx, uint DataId, bool Force, uint Cell);

/// <summary>One <c>RenderDeviceD3D::DrawMeshInternal</c> @0x0059F360 entry
/// (DM line). <paramref name="Bound"/> is retail's BoundingType (0=OUTSIDE,
/// 1=PARTIALLY_INSIDE, 2=ENTIRELY_INSIDE).</summary>
public sealed record WalkOracleMeshDraw(uint Gfx, uint DataId, bool Force, int Bound, uint Cell);

public sealed record WalkOraclePartsFrame(
    int Number,
    IReadOnlyList<WalkOraclePartDraw> PartDraws,
    IReadOnlyList<WalkOracleMeshDraw> MeshDraws);

/// <summary>
/// S3 chunk 1 (§11.2 B2): parses an ALPHA-DEPTH log
/// (<c>&lt;pose&gt;.alphadepth.log</c>). Same F/P framing and
/// truncated-last-frame drop rule as <see cref="WalkOracleTrace.Parse"/>.
/// </summary>
public static class WalkOracleAlphaDepthTrace
{
    public static IReadOnlyList<WalkOracleAlphaDepthFrame> Parse(IEnumerable<string> lines)
    {
        var frames = new List<WalkOracleAlphaDepthFrame>();
        List<WalkOracleAlphaMeshAdd>? meshAdds = null;
        List<WalkOracleAlphaFlush>? flushes = null;
        List<WalkOraclePortalPolyDraw>? portalPolyDraws = null;
        List<WalkOracleDrawCellsSample>? drawCellsSamples = null;
        int currentNumber = 0;

        foreach (string line in lines)
        {
            Match frameMatch = FramePattern.Match(line);
            if (frameMatch.Success)
            {
                if (meshAdds is not null)
                {
                    frames.Add(new WalkOracleAlphaDepthFrame(
                        currentNumber, meshAdds, flushes!, portalPolyDraws!, drawCellsSamples!));
                }
                currentNumber = int.Parse(
                    frameMatch.Groups[1].Value, CultureInfo.InvariantCulture);
                meshAdds = new List<WalkOracleAlphaMeshAdd>();
                flushes = new List<WalkOracleAlphaFlush>();
                portalPolyDraws = new List<WalkOraclePortalPolyDraw>();
                drawCellsSamples = new List<WalkOracleDrawCellsSample>();
                continue;
            }
            if (meshAdds is null)
                continue;

            Match am = MeshAddPattern.Match(line);
            if (am.Success)
            {
                meshAdds.Add(new WalkOracleAlphaMeshAdd(
                    ParseHex(am.Groups[1].Value),
                    int.Parse(am.Groups[2].Value, CultureInfo.InvariantCulture),
                    ParseHex(am.Groups[3].Value),
                    am.Groups[4].Value != "0",
                    am.Groups[5].Value != "0",
                    int.Parse(am.Groups[6].Value, CultureInfo.InvariantCulture)));
                continue;
            }
            Match fl = FlushPattern.Match(line);
            if (fl.Success)
            {
                flushes!.Add(new WalkOracleAlphaFlush(
                    ParseHex(fl.Groups[1].Value), ParseHex(fl.Groups[2].Value)));
                continue;
            }
            Match pm = PortalPolyPattern.Match(line);
            if (pm.Success)
            {
                portalPolyDraws!.Add(new WalkOraclePortalPolyDraw(
                    ParseHex(pm.Groups[1].Value),
                    int.Parse(pm.Groups[2].Value, CultureInfo.InvariantCulture),
                    int.Parse(pm.Groups[3].Value, NumberStyles.HexNumber, CultureInfo.InvariantCulture)));
                continue;
            }
            Match pc = DrawCellsSamplePattern.Match(line);
            if (pc.Success)
            {
                drawCellsSamples!.Add(new WalkOracleDrawCellsSample(
                    int.Parse(pc.Groups[1].Value, CultureInfo.InvariantCulture),
                    int.Parse(pc.Groups[2].Value, NumberStyles.HexNumber, CultureInfo.InvariantCulture),
                    pc.Groups[3].Value != "0"));
                continue;
            }
        }

        return frames;
    }

    public static IReadOnlyList<WalkOracleAlphaDepthFrame> Load(string root, string fixtureName)
        => Parse(File.ReadLines(Path.Combine(
            WalkOracleTraceRepoRoot.Find(),
            Path.Combine(root.Split('/')),
            fixtureName + ".alphadepth.log")));

    private static uint ParseHex(string hex)
        => uint.Parse(hex, NumberStyles.HexNumber, CultureInfo.InvariantCulture);

    private static readonly Regex FramePattern = new(@"^F (\d+)\s*$", RegexOptions.Compiled);

    // AM mesh=<hex8> surf=<n> csurf=<hex8> new=<0|1> clip=<0|1> listSel=<n>
    private static readonly Regex MeshAddPattern = new(
        @"^AM mesh=([0-9a-f]{8}) surf=(\d+) csurf=([0-9a-f]{8}) new=(\d) clip=(\d) listSel=(\d+)\s*$",
        RegexOptions.Compiled);

    // FL thresh=<hex8> ret=<hex8>
    private static readonly Regex FlushPattern = new(
        @"^FL thresh=([0-9a-f]{8}) ret=([0-9a-f]{8})\s*$", RegexOptions.Compiled);

    // PM poly=<hex8> mode=<n> counterBefore=<hex4>
    private static readonly Regex PortalPolyPattern = new(
        @"^PM poly=([0-9a-f]{8}) mode=(\d) counterBefore=([0-9a-f]{4})\s*$",
        RegexOptions.Compiled);

    // PC ov=<n> counter=<hex4> fc=<0|1>
    private static readonly Regex DrawCellsSamplePattern = new(
        @"^PC ov=(\d+) counter=([0-9a-f]{4}) fc=(\d)\s*$", RegexOptions.Compiled);
}

/// <summary>One <c>D3DPolyRender::AddMeshToAlphaList</c> @0x0059C230 entry
/// (AM line). <paramref name="ListSelector"/> 0 selects the ALPHA list,
/// nonzero the CLIP list.</summary>
public sealed record WalkOracleAlphaMeshAdd(
    uint Mesh, int Surface, uint ClipSurface, bool New, bool Clip, int ListSelector);

/// <summary>One <c>D3DPolyRender::FlushAlphaList</c> @0x0059D2E0 entry (FL
/// line). <paramref name="ThresholdBits"/> is the raw IEEE-754 bits of the
/// threshold float argument.</summary>
public sealed record WalkOracleAlphaFlush(uint ThresholdBits, uint ReturnAddress);

/// <summary>One <c>D3DPolyRender::DrawPortalPolyInternal</c> @0x0059BC90
/// entry (PM line). <paramref name="Mode"/> 0 = true-depth/exit-seal,
/// nonzero = far-Z/building punch.</summary>
public sealed record WalkOraclePortalPolyDraw(uint Poly, int Mode, int CounterBefore);

/// <summary>One <c>PView::DrawCells</c> @0x005A4840 entry, sampled for the
/// persistent <c>portalsDrawnCount</c> depth-lifecycle state machine (PC
/// line) — same breakpoint address as the walk log's DC line, but this is a
/// SEPARATE capture that does not also record the cell roster.</summary>
public sealed record WalkOracleDrawCellsSample(int OutsideViewCount, int Counter, bool ForceClear);

public sealed record WalkOracleAlphaDepthFrame(
    int Number,
    IReadOnlyList<WalkOracleAlphaMeshAdd> MeshAdds,
    IReadOnlyList<WalkOracleAlphaFlush> Flushes,
    IReadOnlyList<WalkOraclePortalPolyDraw> PortalPolyDraws,
    IReadOnlyList<WalkOracleDrawCellsSample> DrawCellsSamples);

/// <summary>Shared repo-root finder — the SAME walk-up-to-<c>AcDream.slnx</c>
/// logic <see cref="WalkOracleTrace"/> already has privately; factored out
/// so the parts/alpha-depth parsers don't duplicate it a second and third
/// time.</summary>
internal static class WalkOracleTraceRepoRoot
{
    internal static string Find()
    {
        DirectoryInfo? dir = new(AppContext.BaseDirectory);
        while (dir is not null)
        {
            if (File.Exists(Path.Combine(dir.FullName, "AcDream.slnx")))
                return dir.FullName;
            dir = dir.Parent;
        }
        throw new InvalidOperationException(
            "AcDream.slnx not found above the test base directory; walk-oracle fixtures unavailable.");
    }
}