"""``mcr`` command line entry point.

    mcr list
    mcr eval --model st_text --benchmark ssrb,multiconir,mcmr,merit --output runs/foo
"""

from __future__ import annotations

import argparse
import json
import os
import sys
from typing import Any, Dict, List

from .config import resolve_benchmark_cfg, resolve_model_cfg
from .cache import EmbeddingCache
from .data.registry import available_benchmarks, build_tasks
from .models.registry import build_encoder, build_reranker
from .pipeline import evaluate_task, evaluate_task_agentic


def _cmd_list(_: argparse.Namespace) -> int:
    print("Available benchmarks:")
    for name in available_benchmarks():
        print(f"  - {name}")
    return 0


def _cmd_eval(args: argparse.Namespace) -> int:
    model_cfg = resolve_model_cfg(args.model)
    model_tag = model_cfg.get("tag") or model_cfg.get("model_name_or_path", "model")

    agentic_cfg = None
    if args.agentic:
        agentic_cfg = resolve_model_cfg(args.agentic)

    encoder = None
    reranker = None
    if agentic_cfg is None:
        encoder = build_encoder(model_cfg)
        if args.reranker:
            reranker = build_reranker(resolve_model_cfg(args.reranker))

    cache = EmbeddingCache(args.cache_dir, enabled=not args.no_cache)
    os.makedirs(args.output, exist_ok=True)

    summary: List[Dict[str, Any]] = []
    for bench in args.benchmark.split(","):
        bench = bench.strip()
        if not bench:
            continue
        bcfg = resolve_benchmark_cfg(bench)
        k_values = bcfg.get("k_values", [1, 5, 10, 20, 50, 100])
        tasks = build_tasks(bcfg["name"], bcfg)
        print(f"[{bench}] {len(tasks)} task(s)", flush=True)

        for task in tasks:
            print(f"  -> {task.name}", flush=True)
            if agentic_cfg is not None:
                report = evaluate_task_agentic(
                    task,
                    agentic_cfg,
                    cache=cache,
                    k_values=k_values,
                    top_k=args.top_k,
                    retriever_kwargs=bcfg.get("retriever", {}),
                    max_queries=args.max_queries,
                )
                report["benchmark"] = bench
                _dump(args.output, task.name, report)
                row = {"benchmark": bench, "task": task.name}
                row.update({m: report["agentic"]["metrics"].get(m) for m in report["official_metrics"]})
                summary.append(row)
            else:
                report = evaluate_task(
                    task,
                    encoder,
                    cache=cache,
                    model_tag=str(model_tag),
                    k_values=k_values,
                    top_k=args.top_k,
                    batch_size=model_cfg.get("batch_size", 64),
                    retriever_kwargs=bcfg.get("retriever", {}),
                    reranker=reranker,
                    rerank_top_k=args.rerank_top_k,
                    max_queries=args.max_queries,
                )
                report["benchmark"] = bench
                _dump(args.output, task.name, report)
                row = {"benchmark": bench, "task": task.name}
                row.update({m: report["dense"]["metrics"].get(m) for m in report["official_metrics"]})
                summary.append(row)

    with open(os.path.join(args.output, "summary.json"), "w", encoding="utf-8") as f:
        json.dump(summary, f, indent=2, ensure_ascii=False)
    _print_summary(summary)
    return 0


def _dump(output: str, task_name: str, report: Dict[str, Any]) -> None:
    safe = task_name.replace("/", "__")
    with open(os.path.join(output, f"{safe}.json"), "w", encoding="utf-8") as f:
        json.dump(report, f, indent=2, ensure_ascii=False)


def _print_summary(summary: List[Dict[str, Any]]) -> None:
    if not summary:
        print("(no results)")
        return
    cols = [k for k in summary[0] if k not in ("benchmark", "task")]
    header = ["task"] + cols
    print("\n" + "  ".join(h.ljust(14) for h in header))
    for row in summary:
        cells = [str(row["task"])[:14].ljust(14)]
        cells += [f"{row.get(c, 0) or 0:.4f}".ljust(14) for c in cols]
        print("  ".join(cells))


def build_parser() -> argparse.ArgumentParser:
    p = argparse.ArgumentParser(prog="mcr", description="Unified multi-condition retrieval eval")
    sub = p.add_subparsers(dest="command", required=True)

    sub.add_parser("list", help="list available benchmarks").set_defaults(func=_cmd_list)

    e = sub.add_parser("eval", help="run evaluation")
    e.add_argument("--model", required=True, help="model config name or yaml path")
    e.add_argument("--benchmark", required=True, help="comma-separated benchmark names/paths")
    e.add_argument("--output", required=True, help="output directory for reports")
    e.add_argument("--reranker", default=None, help="optional reranker config name or path")
    e.add_argument("--agentic", default=None, help="agentic search config name or yaml path")
    e.add_argument("--cache-dir", default=".mcr_cache", help="embedding cache directory")
    e.add_argument("--no-cache", action="store_true", help="disable embedding cache")
    e.add_argument("--top-k", type=int, default=100)
    e.add_argument("--rerank-top-k", type=int, default=100)
    e.add_argument("--max-queries", type=int, default=None, help="limit queries (smoke tests)")
    e.set_defaults(func=_cmd_eval)
    return p


def main(argv: List[str] | None = None) -> int:
    args = build_parser().parse_args(argv if argv is not None else sys.argv[1:])
    return args.func(args)


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