"""
Stage 03 (v8b): Per-layer alpha sweep + monotonicity gate.

Sweep over THREE alphas {0.0, 0.3, 0.7} for each kept layer. For each
alpha and each "active" calibration problem, run inference with the
direction at that alpha and compute the reduction in reflection-marker
count vs. the baseline (alpha = 1.0).

Calibration problems = the LAST CALIBRATION_N_TEST (=15) problems of
RAW_COTS_PATH, regenerated at baseline.

Detector here is the regex-based BehaviorDetector (configs/monitoring.py
PATTERNS) — the EVALUATION instrument only; the direction itself was
learned without it.

A layer is KEPT (safe) if some alpha < 1.0 reduces reflection by >=
min_reduction while staying within side-effect budget.

Resume: per-layer JSON cache (one file per layer) + baseline cache.
"""
import argparse, json, os, sys
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

import torch
from tqdm import tqdm
from configs import get_config
from configs.paths import RAW_COTS_PATH, LOG_DIR, dim_paths, ensure_dirs
from src.calibration import calibrate_all_layers
from src.detectors import BehaviorDetector
from src.interventions import generate_plain
from src.utils import (
    build_chat_prompt, get_device, load_model_and_tokenizer,
    read_jsonl, setup_logger, write_json, think_segment,
)

MIN_REDUCTION = 1.0


def get_problem(item):
    for k in ("problem", "question", "query", "Problem"):
        if k in item and item[k]:
            return item[k]
    return ""


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--dimension", default="monitoring")
    ap.add_argument("--n-test", type=int, default=None)
    ap.add_argument("--active-threshold", type=int, default=None)
    ap.add_argument("--side-effect-rate", type=float, default=None)
    ap.add_argument("--gen-max-tokens", type=int, default=None)
    ap.add_argument("--min-reduction", type=float, default=MIN_REDUCTION)
    ap.add_argument("--force", action="store_true", help="Wipe caches and recompute.")
    args = ap.parse_args()

    ensure_dirs(args.dimension)
    cfg = get_config(args.dimension)
    p = dim_paths(args.dimension)
    n_test = args.n_test or cfg.CALIBRATION_N_TEST
    active_threshold = (args.active_threshold
                        if args.active_threshold is not None
                        else cfg.CALIBRATION_ACTIVE_THRESHOLD)
    side_rate = (args.side_effect_rate
                 if args.side_effect_rate is not None
                 else cfg.CALIBRATION_SIDE_EFFECT_RATE)
    gen_max = args.gen_max_tokens or cfg.GEN_MAX_NEW_TOKENS
    severe_repetition = float(getattr(cfg, "SEVERE_REPETITION", 0.3))

    log = setup_logger("03_calibrate",
                       os.path.join(LOG_DIR, f"03_calibrate_{cfg.NAME}.log"))
    log.info("=" * 70)
    log.info(f"Stage 03 [{cfg.NAME}] (v8b)  "
             f"n_test={n_test}  active_thr={active_threshold}  side_rate={side_rate}")
    log.info(f"  alphas={cfg.NON_TRIVIAL_ALPHAS}  min_reduction={args.min_reduction}")
    log.info(f"  severe_repetition_skip={severe_repetition} (layer abandoned early if any alpha/case loops)")
    log.info("=" * 70)

    if not os.path.exists(p.DIRECTIONS):
        log.error(f"missing {p.DIRECTIONS} — run stage 02 first"); sys.exit(1)

    blob = torch.load(p.DIRECTIONS, map_location="cpu", weights_only=False)
    directions = {int(k): v for k, v in blob["directions"].items()}

    only_env = os.environ.get("CALIB_ONLY_LAYERS", "").strip()
    if only_env:
        wanted = {int(x) for x in only_env.replace(",", " ").split()}
        directions = {L: v for L, v in directions.items() if int(L) in wanted}
        log.info(f"CALIB_ONLY_LAYERS active: {sorted(wanted)}")

    if not directions:
        log.error("No directions left for calibration after CALIB_ONLY_LAYERS filter.")
        sys.exit(2)

    log.info(f"Loaded {len(directions)} layers: {sorted(directions.keys())}")

    if args.force:
        for f_ in [p.CALIB_BASELINE]:
            if os.path.exists(f_):
                os.remove(f_)
        import shutil
        if os.path.isdir(p.CALIB_PER_LAYER):
            shutil.rmtree(p.CALIB_PER_LAYER)
        log.info("[force] caches cleared")

    raw = read_jsonl(RAW_COTS_PATH)
    problems = [get_problem(it) for it in raw if get_problem(it)]
    test_items = problems[-n_test:]
    log.info(f"  calibration problems: {len(test_items)}")

    device = get_device()
    log.info("Loading model...")
    model, tokenizer = load_model_and_tokenizer(device=device)
    detector = BehaviorDetector(cfg)

    samples = None
    if os.path.exists(p.CALIB_BASELINE):
        try:
            with open(p.CALIB_BASELINE) as f_:
                cached = json.load(f_)
            reuse_any = os.environ.get("REUSE_CALIB_BASELINE", "0") == "1"
            ok_strict = (cached.get("n_test") == n_test
                    and cached.get("gen_max") == gen_max
                    and cached.get("active_threshold") == active_threshold
                    and len(cached.get("samples", [])) == n_test)

            if ok_strict or (reuse_any and len(cached.get("samples", [])) > 0):
                samples = cached["samples"]
                log.info(f"  [resume] loaded {len(samples)} baselines from cache"
                         f" (reuse_any={reuse_any}, strict={ok_strict})")
        except Exception as e:
            log.warning(f"  [resume] baseline cache unreadable ({e}); recomputing")

    if samples is None:
        samples = []
        for prob in tqdm(test_items, desc="  baselines"):
            prompt = build_chat_prompt(tokenizer, prob, enable_thinking=True)
            text = generate_plain(model, tokenizer, prompt, device,
                                  max_new_tokens=gen_max)
            n = detector.detect(think_segment(text))["total"]
            samples.append({
                "prompt": prompt,
                "behavior_count": int(n),
                "baseline_text": text,
                "problem": prob,
            })
        blob2 = {
            "n_test": n_test, "gen_max": gen_max,
            "active_threshold": active_threshold, "samples": samples,
        }
        tmp = p.CALIB_BASELINE + ".tmp"
        with open(tmp, "w", encoding="utf-8") as f_:
            json.dump(blob2, f_, indent=2, ensure_ascii=False)
        os.replace(tmp, p.CALIB_BASELINE)
        log.info("  baseline cache saved")

    active = [s for s in samples if s["behavior_count"] >= active_threshold]
    inactive = [s for s in samples if s["behavior_count"] < active_threshold]
    log.info(f"  active={len(active)}  inactive={len(inactive)}")
    log.info(f"  baseline counts: {[s['behavior_count'] for s in samples]}")
    if not active:
        log.error("No active samples. Lower active_threshold or raise gen_max_tokens.")
        sys.exit(3)

    results = calibrate_all_layers(
        model, tokenizer, directions, list(cfg.NON_TRIVIAL_ALPHAS), device,
        active, inactive, detector,
        side_effect_rate=side_rate, min_reduction=args.min_reduction,
        gen_max_tokens=gen_max, logger=log,
        per_layer_dir=p.CALIB_PER_LAYER,
        severe_repetition=severe_repetition,
    )

    kept = [L for L, r in results.items() if r["safe"]]
    best_alpha_per_layer = {int(L): float(results[L]["best_alpha"]) for L in kept}
    log.info(f"KEEP layers: {sorted(kept)}")
    log.info(f"best_alpha_per_layer: {best_alpha_per_layer}")

    save = {
        "dimension": cfg.NAME,
        "n_test": n_test,
        "active_threshold": active_threshold,
        "side_effect_rate": side_rate,
        "min_reduction": args.min_reduction,
        "severe_repetition": severe_repetition,
        "n_active": len(active),
        "n_inactive": len(inactive),
        "baseline_counts": [s["behavior_count"] for s in samples],
        "calibration_per_layer": {str(L): r for L, r in results.items()},
        "kept_layers": sorted(kept),
        "best_alpha_per_layer": {str(L): v for L, v in best_alpha_per_layer.items()},
    }
    write_json(save, p.CALIBRATION)
    log.info(f"Saved {p.CALIBRATION}. Done.")


if __name__ == "__main__":
    main()