#!/usr/bin/env python3
"""Sequential, restart-safe launcher for the complete A6000 81-cell matrix."""
import argparse
import os
import subprocess
import sys


ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, ROOT)
from experiments.crossover_hardware import physical_gpu_report
from experiments.resnet_crossover_r2 import selector_report as resnet_selector
from experiments.transformer_crossover_t2 import (
    selector_report as transformer_selector,
)


def run(command, cwd, environment, dry_run):
    rendered = " ".join(command)
    print(f"[{cwd}] {rendered}", flush=True)
    if not dry_run:
        subprocess.run(command, cwd=cwd, env=environment, check=True)


def require_file(path, label):
    if not os.path.isfile(path):
        raise RuntimeError(f"{label} is not frozen in this run packet: {path}")


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--plain-root", required=True)
    parser.add_argument("--plain-python", required=True)
    parser.add_argument(
        "--family",
        choices=("all", "plain", "resnet", "transformer"),
        default="all",
    )
    parser.add_argument("--dry-run", action="store_true")
    args = parser.parse_args()

    plain_root = os.path.abspath(args.plain_root)
    plain_python = os.path.abspath(args.plain_python)
    require_file(plain_python, "plain-CNN Python executable")
    require_file(
        os.path.join(plain_root, "crossover_grid.py"),
        "patched plain-CNN runner",
    )
    gpu = physical_gpu_report("a6000", args.dry_run)
    print(f"hardware lock: {gpu}", flush=True)

    environment = os.environ.copy()
    environment["SDIL_HARDWARE_PROFILE"] = "a6000"
    environment["SDIL_MAIN_ROOT"] = ROOT
    families = (
        ("plain", "resnet", "transformer")
        if args.family == "all" else (args.family,)
    )

    plain_audit = os.path.join(plain_root, "runs", "plain-p2-audit.json")
    if "plain" in families:
        run(
            [
                plain_python,
                "tests/local_rules_smoke.py",
            ],
            plain_root,
            environment,
            args.dry_run,
        )
        run(
            [
                plain_python,
                "crossover_grid.py",
                "--stage", "p2",
                "--hardware-profile", "a6000",
            ],
            plain_root,
            environment,
            args.dry_run,
        )
        run(
            [
                plain_python,
                "analyze_p2.py",
                "--output", plain_audit,
            ],
            plain_root,
            environment,
            args.dry_run,
        )

    resnet_selector_path = os.path.join(
        ROOT, "results", "resnet_crossover", "p1_selector.json"
    )
    if "resnet" in families:
        require_file(resnet_selector_path, "complete ResNet P1 selector")
        if not args.dry_run:
            resnet_selector(resnet_selector_path)
        run(
            [
                sys.executable,
                "experiments/resnet_crossover_smoke.py",
            ],
            ROOT,
            environment,
            args.dry_run,
        )
        run(
            [
                sys.executable,
                "experiments/resnet_crossover_r2.py",
                "--hardware-profile", "a6000",
            ],
            ROOT,
            environment,
            args.dry_run,
        )
        run(
            [
                sys.executable,
                "experiments/analyze_resnet_crossover_r2.py",
            ],
            ROOT,
            environment,
            args.dry_run,
        )

    transformer_selector_path = os.path.join(
        ROOT, "results", "transformer_crossover", "p1_selector.json"
    )
    if "transformer" in families:
        require_file(
            transformer_selector_path, "complete Transformer T1 selector"
        )
        if not args.dry_run:
            transformer_selector(transformer_selector_path)
        run(
            [
                sys.executable,
                "experiments/transformer_feedback_smoke.py",
            ],
            ROOT,
            environment,
            args.dry_run,
        )
        run(
            [
                sys.executable,
                "experiments/transformer_crossover_t2.py",
                "--hardware-profile", "a6000",
            ],
            ROOT,
            environment,
            args.dry_run,
        )
        run(
            [
                sys.executable,
                "experiments/analyze_transformer_crossover_t2.py",
            ],
            ROOT,
            environment,
            args.dry_run,
        )

    if args.family == "all":
        require_file(plain_audit, "complete plain-CNN P2 audit")
        run(
            [
                sys.executable,
                "experiments/analyze_crossover_81.py",
                "--plain", plain_audit,
            ],
            ROOT,
            environment,
            args.dry_run,
        )


if __name__ == "__main__":
    main()