from __future__ import annotations

import argparse
import json
import uuid
from dataclasses import replace
from pathlib import Path
from typing import Any

from .agentic import run_agentic_cases, scenario_set, scenarios
from .agentic_report import summarize_agentic_trials
from .api import OpenAIClient
from .boundary import probe_context_boundary
from .context import build_context_case, expand_context_config
from .holdout import derive_holdout_config
from .model_card import render_benchmark_block, update_model_card, validate_post_publish_run
from .provenance import make_run_manifest, write_manifest
from .quality import generate_quality_cases
from .release import sanitize_manifest, sanitize_result_row, scan_public_tree
from .runner import api_key_from_env, run_cases
from .summary import summarize_results
from .tokenizer import TransformersTokenizer
from .tools import generate_tool_cases
from .util import read_json, read_jsonl, write_json, write_jsonl
from .vision import generate_vision_cases


def _variants(path: Path | None, label: str | None = None) -> list[dict[str, Any]]:
    if path is not None and label is not None:
        raise ValueError("--label and --variants are mutually exclusive")
    if path is None:
        return [{"label": label or "default", "request_overrides": {}}]
    value = read_json(path)
    if not isinstance(value, list) or not value:
        raise ValueError("Variant file must contain a non-empty JSON array")
    return value


def _client(args: argparse.Namespace) -> OpenAIClient:
    return OpenAIClient(
        base_url=args.base_url,
        api_key=api_key_from_env(args.api_key_env),
        timeout_s=args.timeout,
    )


def plan_context(args: argparse.Namespace) -> None:
    config = read_json(args.config)
    specs = expand_context_config(config)
    value = {
        "schema_version": "1.0",
        "suite_id": config["suite_id"],
        "cases": len(specs),
        "total_requested_prompt_tokens": sum(item.target_tokens for item in specs),
        "by_matrix": {},
        "specs": [item.__dict__ | {"case_id": item.case_id} for item in specs],
    }
    for spec in specs:
        value["by_matrix"][spec.matrix] = value["by_matrix"].get(spec.matrix, 0) + 1
    write_json(args.output, value)


def _tokenizer(args: argparse.Namespace) -> TransformersTokenizer:
    return TransformersTokenizer(
        args.tokenizer,
        enable_thinking=args.thinking == "on",
        reasoning_effort=args.reasoning_effort,
        preserve_thinking=True,
    )


def _reasoning_request_overrides(args: argparse.Namespace) -> dict[str, Any]:
    value: dict[str, Any] = {"thinking": {"enabled": args.thinking == "on"}}
    if args.reasoning_effort:
        value["reasoning_effort"] = args.reasoning_effort
    return value


def _record_evaluated_artifact(manifest: dict[str, Any], args: argparse.Namespace) -> None:
    repo_id = getattr(args, "hf_repo", None)
    revision = getattr(args, "hf_revision", None)
    benchmark_revision = getattr(args, "benchmark_revision", None)
    if bool(repo_id) != bool(revision):
        raise ValueError("--hf-repo and --hf-revision must be supplied together")
    if repo_id and not benchmark_revision:
        raise ValueError("--benchmark-revision is required for a post-publication run")
    if repo_id:
        manifest["evaluated_artifact"] = {"repo_id": repo_id, "revision": revision}
        manifest["benchmark_source"] = {
            "repo_id": "Shiftedx/shiftedx-bench",
            "revision": benchmark_revision,
        }


def _validate_context_variant_profile(args: argparse.Namespace, variants: list[dict[str, Any]]) -> None:
    declared = {
        bool((variant.get("request_overrides", {}).get("thinking") or {}).get("enabled"))
        for variant in variants
        if "thinking" in (variant.get("request_overrides") or {})
    }
    if len(declared) > 1:
        raise ValueError("All variants in one exact-token context run must use the same thinking mode")
    if declared and declared != {args.thinking == "on"}:
        raise ValueError("--thinking must match the variant file so local and server templates are identical")


def inspect_context(args: argparse.Namespace) -> None:
    config = read_json(args.config)
    specs = expand_context_config(config)
    selected = next((item for item in specs if item.case_id == args.case_id), None)
    if selected is None:
        raise ValueError(f"Unknown case identifier: {args.case_id}")
    tokenizer = _tokenizer(args)
    case = build_context_case(selected, tokenizer)
    value = case.to_dict(include_expected=True)
    if not args.include_prompt:
        value["messages"] = [{"role": item["role"], "content": "<omitted>"} for item in case.messages]
    write_json(args.output, value)


def run_context(args: argparse.Namespace) -> None:
    config = read_json(args.config)
    specs = expand_context_config(config)
    if args.matrix:
        specs = [item for item in specs if item.matrix == args.matrix]
    if args.limit is not None:
        specs = specs[: args.limit]
    tokenizer = _tokenizer(args)
    variants = _variants(args.variants, args.label)
    _validate_context_variant_profile(args, variants)
    run_id = str(uuid.uuid4())
    manifest = make_run_manifest(
        run_id=run_id,
        suite_id=config["suite_id"],
        model=args.model,
        config_path=args.config,
        tokenizer_fingerprint=tokenizer.fingerprint,
        variants=variants,
    )
    manifest["planned_cases"] = len(specs)
    manifest["requested_prompt_tokens"] = sum(item.target_tokens for item in specs)
    _record_evaluated_artifact(manifest, args)
    write_manifest(args.output.with_suffix(".manifest.json"), manifest)
    reasoning_overrides = _reasoning_request_overrides(args)
    cases = (
        replace(build_context_case(spec, tokenizer), request_overrides=reasoning_overrides)
        for spec in specs
    )
    run_cases(
        cases,
        client=_client(args),
        model=args.model,
        output_path=args.output,
        variants=variants,
        run_id=run_id,
        stream=args.stream,
    )


def run_suite(args: argparse.Namespace) -> None:
    config = read_json(args.config)
    variants = _variants(args.variants, args.label)
    if args.suite == "quality":
        cases = generate_quality_cases(config["quality"]["seeds"], config["quality"].get("families"))
        suite_id = "shiftedx-quality-v1"
    elif args.suite == "tools":
        cases = generate_tool_cases(config["tools"]["seeds"])
        suite_id = "shiftedx-tools-v1"
    elif args.suite == "vision":
        cases = generate_vision_cases(args.output.parent / "vision-fixtures", config["vision"]["seeds"])
        suite_id = "shiftedx-vision-v1"
    elif args.suite == "agentic":
        if len(variants) != 1:
            raise ValueError("Agentic runner currently accepts one request variant per invocation")
        request_overrides = dict(variants[0].get("request_overrides") or {})
        thinking = getattr(args, "thinking", None)
        reasoning_effort = getattr(args, "reasoning_effort", None)
        if thinking is not None:
            request_overrides["thinking"] = {"enabled": thinking == "on"}
        if reasoning_effort is not None:
            request_overrides["reasoning_effort"] = reasoning_effort
        variants = [{**variants[0], "request_overrides": request_overrides}]
        agentic_set = getattr(args, "agentic_set", "core")
        selected = scenario_set(agentic_set)
        case_id = getattr(args, "case_id", None)
        if case_id is not None:
            selected = [item for item in selected if item.case_id == case_id]
            if not selected:
                raise ValueError(f"Unknown case identifier for {agentic_set}: {case_id}")
        if args.limit is not None:
            selected = selected[: args.limit]
        run_id = str(uuid.uuid4())
        manifest = make_run_manifest(
            run_id=run_id, suite_id="shiftedx-agentic-v1", model=args.model,
            config_path=args.config, tokenizer_fingerprint=None, variants=variants,
        )
        manifest["planned_cases"] = len(selected)
        manifest["agentic_control_profile"] = getattr(args, "agentic_control_profile", "baseline")
        manifest["agentic_set"] = agentic_set
        _record_evaluated_artifact(manifest, args)
        write_manifest(args.output.with_suffix(".manifest.json"), manifest)
        run_agentic_cases(
            client=_client(args), model=args.model, output_path=args.output,
            request_overrides=variants[0].get("request_overrides") or {},
            variant_label=str(variants[0]["label"]),
            limit=args.limit,
            run_id=run_id,
            control_profile=getattr(args, "agentic_control_profile", "baseline"),
            agentic_set=agentic_set,
            case_id=case_id,
        )
        return
    else:
        raise ValueError(args.suite)
    if args.limit is not None:
        cases = cases[: args.limit]
    run_id = str(uuid.uuid4())
    manifest = make_run_manifest(
        run_id=run_id, suite_id=suite_id, model=args.model, config_path=args.config,
        tokenizer_fingerprint=None, variants=variants,
    )
    _record_evaluated_artifact(manifest, args)
    write_manifest(args.output.with_suffix(".manifest.json"), manifest)
    run_cases(
        cases,
        client=_client(args), model=args.model, output_path=args.output,
        variants=variants, run_id=run_id, stream=args.stream,
    )


def summarize(args: argparse.Namespace) -> None:
    rows = []
    for path in args.inputs:
        rows.extend(read_jsonl(path))
    write_json(
        args.output,
        summarize_results(rows, args.effective_threshold, baseline_variant=args.baseline),
    )


def summarize_agentic(args: argparse.Namespace) -> None:
    rows = []
    for path in args.inputs:
        rows.extend(read_jsonl(path))
    write_json(args.output, summarize_agentic_trials(rows))


def export_public_results(args: argparse.Namespace) -> None:
    rows = []
    for path in args.inputs:
        rows.extend(read_jsonl(path))
    write_jsonl(args.output, (sanitize_result_row(row) for row in rows))
    if args.manifest is not None:
        if args.manifest_output is None:
            raise ValueError("--manifest-output is required with --manifest")
        write_json(args.manifest_output, sanitize_manifest(read_json(args.manifest)))
    elif args.manifest_output is not None:
        raise ValueError("--manifest is required with --manifest-output")


def _bundled_config(name: str) -> Path:
    path = Path(__file__).resolve().parents[2] / "configs" / name
    if not path.exists():
        raise FileNotFoundError(
            f"Bundled config not found at {path}; pass an explicit config path from the source repository"
        )
    return path


def run_quant_gate(args: argparse.Namespace) -> None:
    args.output_dir.mkdir(parents=True, exist_ok=True)
    context_config = args.context_config or _bundled_config("context-quant-gate-v1.json")
    suite_config = args.suite_config or _bundled_config("suites-quant-gate-v1.json")
    common = {
        "base_url": args.base_url,
        "model": args.model,
        "hf_repo": args.hf_repo,
        "hf_revision": args.hf_revision,
        "benchmark_revision": args.benchmark_revision,
        "api_key_env": args.api_key_env,
        "timeout": args.timeout,
        "variants": None,
        "label": args.label,
        "stream": True,
    }
    run_context(
        argparse.Namespace(
            **common,
            output=args.output_dir / "context.jsonl",
            config=context_config,
            tokenizer=args.tokenizer,
            thinking=args.thinking,
            reasoning_effort=args.reasoning_effort,
            matrix=None,
            limit=None,
        )
    )
    suite_settings = read_json(suite_config)
    outputs = [args.output_dir / "context.jsonl"]
    suites = ["quality", "tools", "agentic"]
    if args.profile == "vision":
        suites.append("vision")
    for suite in suites:
        output = args.output_dir / f"{suite}.jsonl"
        run_suite(
            argparse.Namespace(
                **common,
                output=output,
                config=suite_config,
                suite=suite,
                limit=suite_settings.get("agentic_limit") if suite == "agentic" else None,
            )
        )
        outputs.append(output)
    rows = []
    for path in outputs:
        rows.extend(read_jsonl(path))
    write_json(
        args.output_dir / "summary.json",
        summarize_results(rows, baseline_variant=args.label),
    )


def render_model_card(args: argparse.Namespace) -> None:
    rows, benchmark_version = validate_post_publish_run(
        args.run_dir,
        variant=args.variant,
        profile=args.profile,
        model_repo=args.model_repo,
        model_revision=args.model_revision,
        benchmark_revision=args.benchmark_revision,
    )
    block = render_benchmark_block(
        rows,
        variant=args.variant,
        model_repo=args.model_repo,
        model_revision=args.model_revision,
        benchmark_revision=args.benchmark_revision,
        benchmark_version=benchmark_version,
        host=args.host,
        runtime=args.runtime,
        kv_cache=args.kv_cache,
        mtp_depth=args.mtp_depth,
        max_window_status=args.max_window_status,
    )
    args.output.parent.mkdir(parents=True, exist_ok=True)
    args.output.write_text(update_model_card(args.readme.read_text(encoding="utf-8"), block), encoding="utf-8")


def validate_release(args: argparse.Namespace) -> None:
    result = scan_public_tree(args.root)
    if args.output:
        write_json(args.output, result)
    else:
        print(json.dumps(result, indent=2, sort_keys=True))
    if not result["ok"]:
        raise SystemExit(1)


def make_holdout(args: argparse.Namespace) -> None:
    master_key = api_key_from_env(args.master_key_env)
    if master_key is None:
        raise RuntimeError("Holdout master key is required")
    config = derive_holdout_config(read_json(args.template), master_key, args.release_id)
    write_json(args.output, config)


def probe_boundary(args: argparse.Namespace) -> None:
    tokenizer = _tokenizer(args)
    result = probe_context_boundary(
        client=_client(args), tokenizer=tokenizer, model=args.model,
        context_window=args.context_window, reserved_output_tokens=args.reserved_output_tokens,
        include_positive=args.include_positive,
    )
    write_json(args.output, result)
    if not result["passed"]:
        raise SystemExit(1)


def add_runtime_arguments(parser: argparse.ArgumentParser) -> None:
    parser.add_argument("--base-url", required=True, help="OpenAI-compatible base URL ending in /v1")
    parser.add_argument("--model", required=True)
    parser.add_argument("--output", required=True, type=Path)
    parser.add_argument("--api-key-env", help="Environment-variable name containing the API key")
    parser.add_argument("--timeout", type=float, default=900)
    parser.add_argument("--variants", type=Path)
    parser.add_argument("--label", help="Stable candidate label stored in every result row")
    parser.add_argument("--limit", type=int)
    parser.add_argument("--stream", action="store_true")
    parser.add_argument("--hf-repo", help="Published Hugging Face repo evaluated by this run")
    parser.add_argument("--hf-revision", help="Full immutable Hugging Face revision evaluated by this run")
    parser.add_argument(
        "--benchmark-revision", help="Full immutable Shiftedx Bench revision used by this run"
    )


def add_tokenizer_profile_arguments(parser: argparse.ArgumentParser) -> None:
    parser.add_argument("--tokenizer", required=True, type=Path)
    parser.add_argument("--thinking", choices=["on", "off"], default="on")
    parser.add_argument("--reasoning-effort", default="medium")


def make_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(prog="shiftedx-bench")
    subparsers = parser.add_subparsers(dest="command", required=True)

    command = subparsers.add_parser("plan-context")
    command.add_argument("--config", required=True, type=Path)
    command.add_argument("--output", required=True, type=Path)
    command.set_defaults(func=plan_context)

    command = subparsers.add_parser("inspect-context")
    command.add_argument("--config", required=True, type=Path)
    add_tokenizer_profile_arguments(command)
    command.add_argument("--case-id", required=True)
    command.add_argument("--output", required=True, type=Path)
    command.add_argument("--include-prompt", action="store_true")
    command.set_defaults(func=inspect_context)

    command = subparsers.add_parser("run-context")
    add_runtime_arguments(command)
    command.add_argument("--config", required=True, type=Path)
    add_tokenizer_profile_arguments(command)
    command.add_argument("--matrix")
    command.set_defaults(func=run_context)

    command = subparsers.add_parser("run-suite")
    add_runtime_arguments(command)
    command.add_argument("--config", required=True, type=Path)
    command.add_argument("--suite", required=True, choices=["quality", "tools", "agentic", "vision"])
    command.add_argument(
        "--agentic-control-profile",
        choices=["baseline", "shiftedx-harness-v1"],
        default="baseline",
        help="Optional Shiftedx Agent Harness profile for the agentic suite only",
    )
    command.add_argument(
        "--thinking", choices=["on", "off"],
        help="Explicit reasoning mode for agentic requests; omit to use the endpoint default",
    )
    command.add_argument(
        "--reasoning-effort",
        help="Explicit reasoning effort for agentic requests; omit to use the endpoint default",
    )
    command.add_argument(
        "--agentic-set", choices=["core", "expanded", "repo"], default="core",
        help="Agentic scenario set; core remains the lightweight quant-gate default",
    )
    command.add_argument("--case-id", help="Run one named agentic case from the selected set")
    command.set_defaults(func=run_suite)

    command = subparsers.add_parser("summarize")
    command.add_argument("inputs", nargs="+", type=Path)
    command.add_argument("--output", required=True, type=Path)
    command.add_argument("--effective-threshold", type=float, default=0.90)
    command.add_argument("--baseline", help="Explicit baseline variant for paired comparison")
    command.set_defaults(func=summarize)

    command = subparsers.add_parser("summarize-agentic")
    command.add_argument("inputs", nargs="+", type=Path)
    command.add_argument("--output", required=True, type=Path)
    command.set_defaults(func=summarize_agentic)

    command = subparsers.add_parser("export-public-results")
    command.add_argument("inputs", nargs="+", type=Path)
    command.add_argument("--output", required=True, type=Path)
    command.add_argument("--manifest", type=Path)
    command.add_argument("--manifest-output", type=Path)
    command.set_defaults(func=export_public_results)

    command = subparsers.add_parser("run-quant-gate")
    command.add_argument("--base-url", required=True, help="OpenAI-compatible base URL ending in /v1")
    command.add_argument("--model", required=True)
    command.add_argument("--tokenizer", required=True, type=Path)
    command.add_argument("--label", required=True)
    command.add_argument("--output-dir", required=True, type=Path)
    command.add_argument("--context-config", type=Path)
    command.add_argument("--suite-config", type=Path)
    command.add_argument("--api-key-env")
    command.add_argument("--timeout", type=float, default=1800)
    command.add_argument("--thinking", choices=["on", "off"], default="on")
    command.add_argument("--reasoning-effort", default="medium")
    command.add_argument("--profile", choices=["vision", "text"], default="vision")
    command.add_argument("--hf-repo", help="Published Hugging Face repo evaluated by this run")
    command.add_argument("--hf-revision", help="Full immutable Hugging Face revision evaluated by this run")
    command.add_argument("--benchmark-revision", help="Full immutable Shiftedx Bench revision used by this run")
    command.set_defaults(func=run_quant_gate)

    command = subparsers.add_parser("render-model-card")
    command.add_argument("--run-dir", required=True, type=Path)
    command.add_argument("--readme", required=True, type=Path)
    command.add_argument("--output", required=True, type=Path)
    command.add_argument("--variant", required=True)
    command.add_argument("--profile", choices=["vision", "text"], default="vision")
    command.add_argument("--model-repo", required=True)
    command.add_argument("--model-revision", required=True)
    command.add_argument("--benchmark-revision", required=True)
    command.add_argument("--host", required=True)
    command.add_argument("--runtime", required=True)
    command.add_argument("--kv-cache", choices=["off", "q8", "q4"], required=True)
    command.add_argument("--mtp-depth", default="not-applicable")
    command.add_argument(
        "--max-window-status", choices=["not-run", "host-limited", "passed"], default="not-run"
    )
    command.set_defaults(func=render_model_card)

    command = subparsers.add_parser("validate-release")
    command.add_argument("--root", required=True, type=Path)
    command.add_argument("--output", type=Path)
    command.set_defaults(func=validate_release)

    command = subparsers.add_parser("make-holdout")
    command.add_argument("--template", required=True, type=Path)
    command.add_argument("--release-id", required=True)
    command.add_argument("--master-key-env", required=True)
    command.add_argument("--output", required=True, type=Path)
    command.set_defaults(func=make_holdout)

    command = subparsers.add_parser("probe-boundary")
    command.add_argument("--base-url", required=True)
    command.add_argument("--model", required=True)
    add_tokenizer_profile_arguments(command)
    command.add_argument("--context-window", type=int, default=262144)
    command.add_argument("--reserved-output-tokens", type=int, default=2048)
    command.add_argument("--include-positive", action="store_true")
    command.add_argument("--api-key-env")
    command.add_argument("--timeout", type=float, default=900)
    command.add_argument("--output", required=True, type=Path)
    command.set_defaults(func=probe_boundary)
    return parser


def main() -> None:
    args = make_parser().parse_args()
    args.func(args)


if __name__ == "__main__":
    main()