"""Replay the proven Fast Lane corpus through GenerationPlan.v1 in shadow mode."""

from __future__ import annotations

import json
from pathlib import Path

from src.domain.app_blocks.fast_lane_runtime_proof import _declared_plan
from src.domain.app_blocks.presentation_coverage import load_presentation_coverage
from src.domain.codegen.generation_plan_shadow import (
    ShadowReplayCase,
    render_shadow_replay_markdown,
    replay_generation_plans,
)
from src.domain.projects.discovery_schemas import (
    DiscoveryResult,
    DiscoverySpec,
    ProductDefinition,
)

ROOT = Path(__file__).resolve().parents[1]
PROOF_PATH = ROOT / "docs/audits/fixtures/fast_lane_runtime_proof.json"
OUTPUT_PATH = ROOT / "docs/coverage/GENERATION_PLAN_SHADOW_REPLAY.md"


def build_cases() -> list[ShadowReplayCase]:
    proof = json.loads(PROOF_PATH.read_text(encoding="utf-8"))
    if proof.get("status") != "runtime_proven" or proof.get("runtime_proven") != 25:
        raise RuntimeError("The 25-application runtime proof fixture is not green")
    applications = {
        item.id: item for item in load_presentation_coverage().declared_applications
    }
    cases: list[ShadowReplayCase] = []
    for row in proof["applications"]:
        application = applications[row["application_id"]]
        summary = application.notes or application.id
        discovery = DiscoveryResult(
            decision="ready",
            message="Runtime proof replay",
            spec=DiscoverySpec(
                product=ProductDefinition(
                    name=application.id,
                    purpose=summary,
                    first_build_goal="Runtime proof",
                )
            ),
            project_type="nuxt_app",
            product_name=application.id,
            summary=summary,
            specification="Runtime proof",
        )
        cases.append(
            ShadowReplayCase(
                application_id=application.id,
                discovery=discovery,
                app_block_plan=_declared_plan(application),
                expected_blocks=frozenset(row["required_blocks"]),
                expected_feature_packs=frozenset(application.packs),
            )
        )
    return cases


def main() -> int:
    report = replay_generation_plans(build_cases())
    OUTPUT_PATH.write_text(render_shadow_replay_markdown(report), encoding="utf-8")
    print(
        f"generation plan shadow replay applications={report.applications} "
        f"compiled={report.compiled} catalog_valid={report.catalog_valid} "
        f"equivalent={report.equivalent} mismatches={report.semantic_mismatches}"
    )
    return 0 if report.passed else 1


if __name__ == "__main__":
    raise SystemExit(main())