"""Evaluate RMSE / CDF for a sensing-only checkpoint.

Loads ckpt, reuses the same train/test split (seed 2027, 80/20), runs UL
forward, and reports for each user:
  - range RMSE (m), azimuth RMSE (deg), Cartesian RMSE (m)
  - CDF percentiles 50/67/90/95
  - argmax-bin vs soft-expected estimators

Usage:
    python eval_rmse.py --ckpt experiments_v2/checkpoints/phys_layout6L5N.pt
"""
import argparse, math, torch
from torch.nn.functional import softmax

from joint_dual_sim import (
    JointDualSIM, PortReadout, PerBinPort, LinearReadout,
    soft_position_estimate, make_range_edges,
)
from rate_aware_gen import make_config
from updated_SIM_0413_multi_user import hadamard_matrix


def polar_to_xy(r, az):
    return r * torch.cos(az), r * torch.sin(az)


def argmax_position(logits, cfg, device):
    idx = logits.argmax(dim=-1)
    s = idx % cfg.S
    q = idx // cfg.S
    az_edges = torch.linspace(cfg.az_min_deg, cfg.az_max_deg, cfg.S + 1, device=device)
    r_edges = make_range_edges(cfg, device)
    az_hat = (az_edges[:-1] + az_edges[1:]) / 2.0 * math.pi / 180.0
    r_hat = (r_edges[:-1] + r_edges[1:]) / 2.0
    return r_hat[q], az_hat[s]


def percentiles(err):
    err = err.sort().values
    n = err.numel()
    return {p: err[min(n - 1, int(n * p / 100))].item() for p in (50, 67, 90, 95)}


def main():
    pa = argparse.ArgumentParser()
    pa.add_argument("--ckpt", required=True)
    pa.add_argument("--cache", default="experiments_v2/caches/v2_K2_15k.pt")
    pa.add_argument("--scale", default="large")
    pa.add_argument("--device", default="cuda:0")
    pa.add_argument("--batch-size", type=int, default=64)
    args = pa.parse_args()

    device = torch.device(args.device if torch.cuda.is_available() else "cpu")
    print(f"Device: {device}")

    ckpt = torch.load(args.ckpt, weights_only=False, map_location="cpu")
    cfg_dict = ckpt['cfg']
    print(f"Loaded ckpt: {args.ckpt}")
    print(f"  layout={ckpt['layout']} share_mask={ckpt['share_mask']} "
          f"readout={ckpt['readout']} range_grid={ckpt['range_grid']}")

    d = torch.load(args.cache, weights_only=False, map_location="cpu")
    geos, full_rates = d['geos'], d['rates']
    M = geos.shape[0]
    K = geos.shape[1] // 2

    cfg = make_config(args.scale, K)
    cfg.range_grid = ckpt['range_grid']
    for k, v in cfg_dict.items():
        setattr(cfg, k, v)

    Pt_dBm_ul = getattr(cfg, 'Pt_UE_dBm', cfg.Pt_dBm)
    pt_w = 10 ** (Pt_dBm_ul / 10) / 1000
    sqrt_pt = math.sqrt(pt_w)

    r_all = geos[:, ::2] * cfg.r_max
    az_all = geos[:, 1::2] * math.pi

    g = torch.Generator().manual_seed(2027)
    perm = torch.randperm(M, generator=g)
    n_tr = int(0.8 * M)
    te = perm[n_tr:]
    print(f"  test set size: {len(te)}")

    sim = JointDualSIM(cfg, layout=ckpt['layout'],
                       share_mask=tuple(int(c) == 1 for c in ckpt['share_mask'])).to(device)
    sim.load_state_dict(ckpt['sim'])
    sim.eval()

    n_bins = cfg.S * cfg.Q
    if ckpt['readout'] == "port":
        head = PortReadout(n_bins).to(device)
    elif ckpt['readout'] == "perbin":
        head = PerBinPort(n_bins).to(device)
    else:
        head = LinearReadout(n_bins).to(device)
    head.load_state_dict(ckpt['head'])
    head.eval()

    pilot_H = hadamard_matrix(max(cfg.T, K), device)
    pilot = pilot_H[:K, :cfg.T].to(torch.float32) * sqrt_pt  # (K, T)

    r_true_all, az_true_all = [], []
    r_soft_all, az_soft_all = [], []
    r_arg_all,  az_arg_all  = [], []

    with torch.no_grad():
        for s_ in range(0, len(te), args.batch_size):
            idx = te[s_:s_ + args.batch_size]
            r_b = r_all[idx].to(device)
            az_b = az_all[idx].to(device)
            B = r_b.shape[0]
            for k in range(K):
                x_pilot = pilot[k:k+1].expand(B, -1)
                y = sim.forward_ul_signal(r_b[:, k], az_b[:, k], x_pilot)
                logits = head(y.abs())
                r_s, az_s = soft_position_estimate(logits, cfg)
                r_a, az_a = argmax_position(logits, cfg, device)
                r_true_all.append(r_b[:, k]); az_true_all.append(az_b[:, k])
                r_soft_all.append(r_s); az_soft_all.append(az_s)
                r_arg_all.append(r_a);  az_arg_all.append(az_a)

    r_true = torch.cat(r_true_all)
    az_true = torch.cat(az_true_all)
    r_s_ = torch.cat(r_soft_all); az_s_ = torch.cat(az_soft_all)
    r_a_ = torch.cat(r_arg_all);  az_a_ = torch.cat(az_arg_all)

    def report(tag, r_hat, az_hat):
        x_t, y_t = polar_to_xy(r_true, az_true)
        x_h, y_h = polar_to_xy(r_hat, az_hat)
        pos_err = torch.sqrt((x_t - x_h)**2 + (y_t - y_h)**2)
        r_rmse = (r_true - r_hat).pow(2).mean().sqrt().item()
        az_rmse_deg = ((az_true - r_hat * 0 - az_hat) * 180 / math.pi).pow(2).mean().sqrt().item()
        pos_rmse = pos_err.pow(2).mean().sqrt().item()
        pcts = percentiles(pos_err)
        print(f"\n[{tag}]  range RMSE = {r_rmse:.3f} m   az RMSE = {az_rmse_deg:.2f}°   "
              f"pos RMSE = {pos_rmse:.3f} m")
        print(f"   pos err CDF — p50={pcts[50]:.2f}m  p67={pcts[67]:.2f}m  "
              f"p90={pcts[90]:.2f}m  p95={pcts[95]:.2f}m")

    print(f"\n=== Eval ({len(te)} test samples × {K} users = {r_true.numel()} estimates) ===")
    print(f"   bin sizes: az = {(cfg.az_max_deg - cfg.az_min_deg)/cfg.S:.2f}°  "
          f"r ≈ {(cfg.r_max - cfg.r_min)/cfg.Q:.2f} m")
    report("argmax (hard)", r_a_, az_a_)
    report("soft expected", r_s_, az_s_)


if __name__ == "__main__":
    main()