"""Batch CLI: STEP folder -> Excel. Single process, models loaded once."""
from __future__ import annotations
import argparse
import sys
import tempfile
from datetime import datetime
from pathlib import Path
from typing import Dict, List

from openpyxl import Workbook

from heg_brep import (
    DEFAULT_PASS1_MODEL, DEFAULT_ELBOW_MODEL, DEFAULT_TEE_MODEL, REPO_ROOT,
)
from heg_brep.inference import LoadedModel, TwoPassClassifier
from heg_brep.extraction import extract_folder_to_npz


COLUMNS = [
    "file_name", "file_path", "stem", "status",
    "pass1_argmax", "pass1_conf", "route",
    "pass2_argmax", "pass2_predicted", "pass2_conf",
    "final_label", "final_conf", "npz_path", "note",
]


def parse_args() -> argparse.Namespace:
    ap = argparse.ArgumentParser(description=__doc__)
    ap.add_argument("step_folder")
    ap.add_argument("output_excel", nargs="?", default=None,
                    help="Defaults to ./brep_two_pass_<timestamp>.xlsx")
    ap.add_argument("--pass1_model", default=str(DEFAULT_PASS1_MODEL))
    ap.add_argument("--elbow_model", default=str(DEFAULT_ELBOW_MODEL))
    ap.add_argument("--tee_model",   default=str(DEFAULT_TEE_MODEL))
    ap.add_argument("--device", default="cpu", choices=["cpu", "cuda"])
    ap.add_argument("--pass2_min_conf", type=float, default=0.85)
    ap.add_argument("--pass2_tau", type=float, default=0.0)
    ap.add_argument("--num_workers", type=int, default=1)
    ap.add_argument("--max_file_mb", type=float, default=None)
    ap.add_argument("--npz_dir", default=None, help="Persist NPZs here (default: temp).")
    return ap.parse_args()


def write_excel(rows: List[Dict[str, object]], output_excel: Path) -> None:
    wb = Workbook()
    ws = wb.active
    ws.title = "brep_two_pass"
    ws.append(COLUMNS)
    for r in rows:
        ws.append([r.get(c, "") for c in COLUMNS])
    for col in ws.columns:
        letter = col[0].column_letter
        max_len = max((len(str(c.value)) if c.value is not None else 0 for c in col), default=0)
        ws.column_dimensions[letter].width = min(max(12, max_len + 2), 70)
    output_excel.parent.mkdir(parents=True, exist_ok=True)
    wb.save(output_excel)


def main() -> int:
    args = parse_args()
    step_folder = Path(args.step_folder).expanduser().resolve()
    if not step_folder.is_dir():
        raise FileNotFoundError(f"step_folder not found: {step_folder}")

    output_excel = (Path(args.output_excel).expanduser().resolve()
                    if args.output_excel
                    else REPO_ROOT / f"brep_two_pass_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx")
    npz_dir = (Path(args.npz_dir).expanduser().resolve() if args.npz_dir
               else Path(tempfile.mkdtemp(prefix="heg_brep_npz_")))

    print(f"Extracting STEP files in {step_folder} -> {npz_dir}")
    t0 = datetime.now()
    summary = extract_folder_to_npz(
        step_folder, output_dir=npz_dir,
        num_workers=args.num_workers, max_file_mb=args.max_file_mb,
    )
    print(f"  extraction took {(datetime.now() - t0).total_seconds():.1f}s "
          f"({len(summary['ok_stems'])} OK, {len(summary['skipped'])} skipped)")

    print(f"Loading models on {args.device}...")
    t0 = datetime.now()
    pass1 = LoadedModel(Path(args.pass1_model), device=args.device)
    elbow = LoadedModel(Path(args.elbow_model), device=args.device) if Path(args.elbow_model).exists() else None
    tee   = LoadedModel(Path(args.tee_model),   device=args.device) if Path(args.tee_model).exists()   else None
    clf = TwoPassClassifier(pass1=pass1, elbow=elbow, tee=tee,
                            pass2_min_conf=args.pass2_min_conf, pass2_tau=args.pass2_tau)
    print(f"  models loaded in {(datetime.now() - t0).total_seconds():.1f}s")

    print(f"Classifying {len(summary['step_paths'])} files...")
    t0 = datetime.now()
    rows: List[Dict[str, object]] = []
    ok = pass1_failed = pass2_failed = extraction_failed = 0
    for sp in summary["step_paths"]:
        stem = sp.stem
        base = {c: "" for c in COLUMNS}
        base.update({"file_name": sp.name, "file_path": str(sp), "stem": stem})
        npz = npz_dir / f"{stem}.npz"
        if not npz.exists():
            base["status"] = "EXTRACTION_FAILED"
            base["note"] = summary["skipped"].get(stem, "NPZ missing after extraction")
            extraction_failed += 1
            rows.append(base); continue
        base["npz_path"] = str(npz)
        try:
            result = clf.classify_npz(npz)
        except Exception as exc:
            base["status"] = "INFERENCE_FAILED"
            base["note"] = str(exc)[:500]
            pass1_failed += 1
            rows.append(base); continue
        base.update({k: result.get(k, "") for k in result})
        # Round confidences for the spreadsheet
        for k in ("pass1_conf", "pass2_conf", "final_conf"):
            v = base.get(k)
            base[k] = round(float(v), 6) if isinstance(v, (int, float)) else v
        base["status"] = "OK"
        ok += 1
        rows.append(base)

    elapsed = (datetime.now() - t0).total_seconds()
    print(f"  inference took {elapsed:.1f}s ({elapsed / max(1, len(rows)):.2f}s/file)")

    write_excel(rows, output_excel)
    print(f"Saved Excel: {output_excel}")
    print(f"Summary -> total: {len(rows)} | OK: {ok} | "
          f"extraction_failed: {extraction_failed} | inference_failed: {pass1_failed}")
    print(f"NPZ dir: {npz_dir}")
    return 0


if __name__ == "__main__":
    sys.exit(main())