# Author: Simon-Pierre Boucher — simon-pierre.boucher@uqo.ca
"""`av` command-line interface. Every command is a thin wrapper around a numbered script in scripts/
(loaded lazily by file path so that missing scripts fail with a clear message) or around the
experiments package."""
from __future__ import annotations

import importlib.util
import sys
from pathlib import Path
from typing import Optional

import typer

from .config import ROOT

app = typer.Typer(name="av", help="Agentic valuation (UQO WP 26): data, baselines, agents, evaluation, paper.", no_args_is_help=True, add_completion=False)
SCRIPTS = ROOT / "scripts"

# command -> script name pattern (scripts/NN_<name>.py). Numbers are not fixed here on purpose.
SCRIPT_FOR = {
    "synth": "synthetic",
    "build": "build_analytic",
    "splits": "splits",
    "features": "features",
    "geo": "geo",
    "train": "train_baselines",
    "run-arm": "run_arm",
    "evaluate": "evaluate",
    "tables": "tables",
    "paper": "paper",
}


def _find_script(name: str) -> Path | None:
    hits = sorted(SCRIPTS.glob(f"[0-9][0-9]_{name}*.py"))
    return hits[0] if hits else None


def _call_script(cmd: str, argv: list[str]) -> None:
    name = SCRIPT_FOR[cmd]
    path = _find_script(name)
    if path is None:
        typer.echo(f"[av {cmd}] scripts/NN_{name}.py does not exist yet (expected a numbered script in {SCRIPTS}).", err=True)
        raise typer.Exit(code=2)
    spec = importlib.util.spec_from_file_location(f"av_script_{name}", path)
    assert spec and spec.loader
    mod = importlib.util.module_from_spec(spec)
    sys.modules[spec.name] = mod
    spec.loader.exec_module(mod)
    if not hasattr(mod, "main"):
        typer.echo(f"[av {cmd}] {path.name} has no main(argv) function", err=True)
        raise typer.Exit(code=2)
    rc = mod.main(argv)
    if isinstance(rc, int) and rc != 0:
        raise typer.Exit(code=rc)


def _passthrough(cmd: str):
    def _cmd(ctx: typer.Context) -> None:
        _call_script(cmd, list(ctx.args))

    _cmd.__name__ = cmd.replace("-", "_")
    return _cmd


for _c, _help in (
    ("build", "Build data/processed/analytic.parquet from the raw snapshot (scripts/01_build_analytic.py)."),
    ("splits", "Chronological / spatial splits (scripts/02_splits.py)."),
    ("features", "As-of feature matrix and comparable retrieval (scripts/NN_features.py)."),
    ("geo", "Geospatial layers (scripts/NN_geo.py)."),
    ("train", "Fit baselines A–D on train, tune on validation (scripts/NN_train_baselines.py)."),
    ("evaluate", "Metrics, calibration, stratification, clustered inference (scripts/NN_evaluate.py)."),
    ("tables", "LaTeX tables and figures from results/ (scripts/NN_tables.py)."),
    ("paper", "Build the PDF (scripts/NN_paper.py)."),
):
    app.command(name=_c, help=_help + " Extra arguments are passed through.", context_settings={"allow_extra_args": True, "ignore_unknown_options": True})(_passthrough(_c))


@app.command(help="Generate the clearly labelled synthetic dataset (data/synthetic/).")
def synth(n: int = typer.Option(20000, help="number of synthetic transactions")) -> None:
    if _find_script(SCRIPT_FOR["synth"]) is not None:
        _call_script("synth", ["--n", str(n)])
        return
    from .data.synthetic import write_default

    df = write_default(n)
    typer.echo(f"synthetic: {df.shape} rows -> data/synthetic/synthetic_transactions.parquet")


@app.command(name="run-arm", help="Run one LLM arm (E–J) on a subsample; mock unless --live and keys are present.")
def run_arm(
    arm: str = typer.Option("F_independent", help="treatments.yaml arm id: E_single_llm, F_independent, G_debate, H_debate_skeptic, I_placebo, J_cost_matched"),
    rounds: Optional[int] = typer.Option(None, help="debate rounds (G/H/I); G defaults to 2 if omitted"),
    committee: str = typer.Option("all_anthropic", help="all_anthropic | all_openai | mixed_random"),
    split: str = typer.Option("validation"),
    n: int = typer.Option(24, help="number of properties"),
    live: bool = typer.Option(False, "--live", help="call the vendors (requires keys); otherwise the mock provider"),
    tier: Optional[str] = typer.Option(None, help="mid | small (configs/models.yaml cost_matched_pairs)"),
    run_id: Optional[str] = typer.Option(None, "--run-id"),
    synthetic: bool = typer.Option(False, "--synthetic", help="use data/synthetic/ instead of data/processed/"),
    effort: Optional[str] = typer.Option(None, help="reasoning effort passed to the providers"),
    concurrency: int = typer.Option(4, help="properties valued concurrently"),
    seed: Optional[int] = typer.Option(None),
) -> None:
    argv = ["--arm", arm, "--committee", committee, "--split", split, "--n", str(n), "--concurrency", str(concurrency)]
    if rounds is not None:
        argv += ["--rounds", str(rounds)]
    if live:
        argv.append("--live")
    if tier:
        argv += ["--tier", tier]
    if run_id:
        argv += ["--run-id", run_id]
    if synthetic:
        argv.append("--synthetic")
    if effort:
        argv += ["--effort", effort]
    if seed is not None:
        argv += ["--seed", str(seed)]
    _call_script("run-arm", argv)


@app.command(name="providers-check", help="List vendor models through the official SDKs and check configs/models.yaml ids.")
def providers_check() -> None:
    from .experiments.providers_check import check, print_report

    rep = check()
    print_report(rep)
    if not rep["all_configured_found"]:
        raise typer.Exit(code=1)


@app.command(help="Write results/freeze.json (prompt/config/code/model hashes) or --check it against the current code.")
def freeze(check: bool = typer.Option(False, "--check", help="compare the current state with results/freeze.json")) -> None:
    from .experiments.freeze import check_freeze, write_freeze

    if check:
        diffs = check_freeze()
        if diffs:
            typer.echo("PROTOCOL DEVIATION — items changed since the freeze:\n  " + "\n  ".join(diffs))
            raise typer.Exit(code=1)
        typer.echo("freeze OK: prompts, configs, code and model ids unchanged")
        return
    p = write_freeze()
    typer.echo(f"freeze written: {p}")


if __name__ == "__main__":
    app()