"""
Stage 03b (v32b): rank qualified layers by best_reduction desc.

A layer is "safe" (per Stage 03 calibration with new mono rule):
  - best_alpha = argmax(reduction) over non-trivial alphas
  - path from α=1.0 → best_alpha is monotonic non-decreasing
  - best_reduction >= min_reduction (= 1.0 default)

Stage 03b just:
  1. Filter to safe layers.
  2. Rank by best_reduction descending.
  3. Emit N_max = len(safe layers), full ranking and per-layer alpha.

Stage 04 sweeps top-K of the ranking for various K.
"""
import os, sys, argparse
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from configs import get_config
from configs.paths import LOG_DIR, dim_paths, ensure_dirs
from src.utils import read_json, write_json, setup_logger


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--dimension", default="monitoring")
    ap.add_argument("--alpha-floor",   type=float, default=0.0)
    ap.add_argument("--alpha-ceiling", type=float, default=0.99)
    ap.add_argument("--output-suffix", type=str, default="")
    args = ap.parse_args()

    ensure_dirs(args.dimension)
    cfg = get_config(args.dimension)
    p = dim_paths(args.dimension)

    out_path = p.SELECTED_LAYERS
    if args.output_suffix:
        base, ext = os.path.splitext(p.SELECTED_LAYERS)
        out_path = f"{base}{args.output_suffix}{ext}"

    log = setup_logger("03b_select",
                       os.path.join(LOG_DIR, f"03b_select_{cfg.NAME}.log"))
    log.info("=" * 72)
    log.info(f"Stage 03b [{cfg.NAME}] (v32b): rank by best_reduction desc")
    log.info(f"  non_trivial_alphas = {cfg.NON_TRIVIAL_ALPHAS}")
    log.info(f"  alpha_floor        = {args.alpha_floor}")
    log.info(f"  alpha_ceiling      = {args.alpha_ceiling}")
    log.info("=" * 72)

    if not os.path.exists(p.CALIBRATION):
        log.error(f"missing {p.CALIBRATION} — run stage 03 first."); sys.exit(1)
    calib = read_json(p.CALIBRATION)
    per_layer = calib.get("calibration_per_layer", {})

    cands = []
    skip_reasons = {"not_safe": 0, "high_alpha": 0}
    for L_str, d in per_layer.items():
        L = int(L_str)
        if not d.get("safe"):
            log.info(f"  L{L}: SKIP (not safe — fail mono or red < min)")
            skip_reasons["not_safe"] += 1
            continue
        best_a   = float(d.get("best_alpha", 1.0))
        best_red = float(d.get("best_reduction", 0.0))
        mono     = bool(d.get("fully_monotonic", False))
        if best_a >= args.alpha_ceiling:
            log.info(f"  L{L}: SKIP (best_alpha={best_a:.2f} >= ceiling)")
            skip_reasons["high_alpha"] += 1
            continue

        # Per-alpha audit table
        sweep = d.get("sweep_detail", {})
        per_alpha_red = {}
        for a in cfg.NON_TRIVIAL_ALPHAS:
            key = f"{a:.2f}"
            cell = sweep.get(key) or {}
            per_alpha_red[key] = float(cell.get("avg_reduction", 0.0))

        eff_a = max(best_a, args.alpha_floor)
        cands.append({
            "layer":           L,
            "alpha":           eff_a,
            "raw_best_alpha":  best_a,
            "best_reduction":  best_red,
            "per_alpha_red":   per_alpha_red,
            "mean_alpha_red":  sum(per_alpha_red.values()) / max(1, len(per_alpha_red)),
            "fully_monotonic": mono,
        })

    log.info(f"  qualification: {len(cands)} / {len(per_layer)} kept")
    log.info(f"  skip reasons: {skip_reasons}")
    if not cands:
        log.error("No layers qualified."); sys.exit(2)

    # Rank by best_reduction descending (user's spec for v32b)
    ranking = sorted(cands, key=lambda x: -x["best_reduction"])
    selected = ranking[:]
    selected_sorted = sorted(selected, key=lambda x: x["layer"])

    log.info(f"  N_max = {len(selected)}")
    log.info(f"  QUALIFIED LAYERS (layer-id ascending):")
    cum_p = cum_r = 0.0
    for it in selected_sorted:
        cum_p += 1 - it["alpha"]
        cum_r += it["best_reduction"]
        per_a = it["per_alpha_red"]
        log.info(f"    L{it['layer']:>2}  alpha={it['alpha']:.2f}  "
                 f"best_red={it['best_reduction']:+.2f}  "
                 f"per_a={ {k:f'{v:+.1f}' for k,v in per_a.items()} }")
    log.info(f"  Cum best-reduction: {cum_r:.2f}")
    log.info(f"  Cum pressure (sum(1-α)): {cum_p:.2f}")
    if cum_p > 5.0:
        log.warning(f"  Cum pressure {cum_p:.2f} > 5.0 — collapse risk in stage 04")

    log.info(f"  RANKING (by best_reduction desc, ranking[0] = picked first in top-N):")
    for r_, it in enumerate(ranking):
        log.info(f"    rank{r_+1:>2}: L{it['layer']:>2}  "
                 f"best_red={it['best_reduction']:+.2f}  "
                 f"alpha={it['alpha']:.2f}")

    out = {
        "dimension": cfg.NAME,
        "selected_layers":      [it["layer"] for it in selected_sorted],
        "alpha_per_layer":      {str(it["layer"]): it["alpha"] for it in selected_sorted},
        "ranking":              [it["layer"] for it in ranking],
        "ranking_full":         ranking,
        "rank_by":              "best_reduction_desc",
        "n_qualified":          len(ranking),
        "cumulative_best_reduction": cum_r,
        "cumulative_pressure_at_best_alpha": cum_p,
        "skip_reasons":         skip_reasons,
        "policy": "v32b_best_reduction_desc",
        "policy_params": {
            "alpha_floor":   args.alpha_floor,
            "alpha_ceiling": args.alpha_ceiling,
        },
    }
    write_json(out, out_path)
    log.info(f"Saved -> {out_path}")
    log.info("Done.")


if __name__ == "__main__":
    main()