from __future__ import annotations

import copy
import random

import numpy as np
import pandas as pd
import torch
import torch.nn.functional as F
from sklearn.metrics import average_precision_score, brier_score_loss
from torch.utils.data import DataLoader, Dataset, WeightedRandomSampler

from suite22_data import Suite22Bundle, faculty_sampling_weights


def seed_everything(seed: int):
    random.seed(seed); np.random.seed(seed); torch.manual_seed(seed)
    if torch.cuda.is_available(): torch.cuda.manual_seed_all(seed)
    torch.backends.cudnn.deterministic = True
    torch.backends.cudnn.benchmark = False


def choose_device(value: str) -> torch.device:
    if value == "cpu": return torch.device("cpu")
    if value == "cuda":
        if not torch.cuda.is_available(): raise RuntimeError("CUDA requested but unavailable")
        return torch.device("cuda")
    return torch.device("cuda" if torch.cuda.is_available() else "cpu")


class BundleDataset(Dataset):
    def __init__(self, bundle: Suite22Bundle, indices: np.ndarray, relation_permutation: np.ndarray | None = None):
        self.b = bundle
        self.idx = np.asarray(indices, int)
        self.rel_perm = None if relation_permutation is None else np.asarray(relation_permutation, int)

    def __len__(self): return len(self.idx)

    def __getitem__(self, j):
        i = int(self.idx[j])
        ri = i if self.rel_perm is None else int(self.rel_perm[i])
        b = self.b
        return {
            "flat": torch.from_numpy(b.flat[i]),
            "course_target": torch.from_numpy(b.course_target[i]),
            "student_seq": torch.from_numpy(b.student_seq[ri]),
            "student_mask": torch.from_numpy(b.student_mask[ri]),
            "course_neighbors": torch.from_numpy(b.course_neighbors[ri]),
            "course_neighbor_mask": torch.from_numpy(b.course_neighbor_mask[ri]),
            "course_relation_type": torch.from_numpy(b.course_relation_type[ri]),
            "relation_events": torch.from_numpy(b.relation_events[ri]),
            "relation_mask": torch.from_numpy(b.relation_mask[ri]),
            "relation_type": torch.from_numpy(b.relation_type[ri]),
            "component_events": torch.from_numpy(b.component_events[ri]),
            "component_mask": torch.from_numpy(b.component_mask[ri]),
            "component_type": torch.from_numpy(b.component_type[ri]),
            "faculty_idx": torch.tensor(int(b.faculty_idx[i]), dtype=torch.long),
            "semester_ordinal": torch.tensor(float(b.semester_ordinal[i]), dtype=torch.float32),
            "semester_z": torch.tensor(float(b.semester_z[i]), dtype=torch.float32),
            "y": torch.tensor(float(b.y[i]), dtype=torch.float32),
            "index": torch.tensor(i, dtype=torch.long),
        }


def make_relation_permutation(bundle: Suite22Bundle, mask, seed: int) -> np.ndarray:
    rng = np.random.default_rng(int(seed))
    perm = np.arange(len(bundle), dtype=int)
    m0 = np.asarray(mask, bool)
    for fi in np.unique(bundle.faculty_idx[m0]):
        idx = np.where(m0 & (bundle.faculty_idx == fi))[0]
        if len(idx) > 1:
            perm[idx] = rng.permutation(idx)
    return perm


def make_loader(bundle, mask, batch_size, training, seed, samples_per_epoch=0, relation_permutation=None):
    idx = np.where(np.asarray(mask, bool))[0]
    ds = BundleDataset(bundle, idx, relation_permutation=relation_permutation)
    gen = torch.Generator(); gen.manual_seed(int(seed))
    if training:
        weights, _ = faculty_sampling_weights(bundle.faculty_idx[idx], bundle.faculty_names)
        n = int(samples_per_epoch) if int(samples_per_epoch) > 0 else len(idx)
        sampler = WeightedRandomSampler(torch.as_tensor(weights, dtype=torch.double), n, replacement=True, generator=gen)
        return DataLoader(ds, batch_size=batch_size, sampler=sampler, num_workers=0,
                          pin_memory=torch.cuda.is_available())
    return DataLoader(ds, batch_size=batch_size, shuffle=False, num_workers=0,
                      pin_memory=torch.cuda.is_available())


def move_batch(batch, device):
    return {k: (v.to(device, non_blocking=True) if torch.is_tensor(v) else v) for k, v in batch.items()}


def model_forward(model, b, ablation="none", semester_shift=0.0, semester_scale=1.0):
    current = torch.cat([b["flat"], b["course_target"]], 1)
    so = b["semester_ordinal"] + float(semester_shift)
    sz = b["semester_z"] + float(semester_shift) / max(float(semester_scale), 1e-6)
    return model(
        current=current, faculty_idx=b["faculty_idx"], semester_ordinal=so, semester_z=sz,
        course_target=b["course_target"], student_seq=b["student_seq"], student_mask=b["student_mask"],
        course_neighbors=b["course_neighbors"], course_neighbor_mask=b["course_neighbor_mask"], course_relation_type=b["course_relation_type"],
        relation_events=b["relation_events"], relation_mask=b["relation_mask"], relation_type=b["relation_type"],
        component_events=b["component_events"], component_mask=b["component_mask"], component_type=b["component_type"],
        ablation=ablation,
    )


def pair_ranking_loss(logits, y, faculty_idx, max_per_class=16):
    mean_logit = logits.mean(1)
    losses = []
    for fi in torch.unique(faculty_idx):
        m = faculty_idx == fi
        pos = torch.where(m & (y > .5))[0]
        neg = torch.where(m & (y <= .5))[0]
        if len(pos) == 0 or len(neg) == 0: continue
        pos = pos[:int(max_per_class)]; neg = neg[:int(max_per_class)]
        diff = mean_logit[pos][:, None] - mean_logit[neg][None, :]
        losses.append(F.softplus(-diff).mean())
    return torch.stack(losses).mean() if losses else torch.zeros((), device=y.device)


def loss_components(out, y, faculty_idx, ranking_weight: float):
    target = y[:, None].expand_as(out["logits"])
    bce = F.binary_cross_entropy_with_logits(out["logits"], target)
    ranking = pair_ranking_loss(out["logits"], y, faculty_idx) if ranking_weight > 0 else torch.zeros((), device=y.device)
    loss = bce + float(ranking_weight) * ranking
    return loss, {"bce": bce, "ranking": ranking}


def safe_ap(y, p):
    y = np.asarray(y, int)
    return float(average_precision_score(y, p)) if np.unique(y).size > 1 else np.nan


def warn_by_rate(score, rate=.20):
    score = np.asarray(score, float); k = max(0, min(len(score), int(round(rate * len(score)))))
    out = np.zeros(len(score), np.int8)
    if k: out[np.argsort(-score, kind="mergesort")[:k]] = 1
    return out


def fbeta(y, pred, beta=2.0):
    y = np.asarray(y, int); pred = np.asarray(pred, int)
    tp = ((y==1)&(pred==1)).sum(); fp=((y==0)&(pred==1)).sum(); fn=((y==1)&(pred==0)).sum()
    p=tp/max(tp+fp,1); r=tp/max(tp+fn,1); b2=beta*beta
    return float((1+b2)*p*r/max(b2*p+r,1e-12))


def macro_validation(bundle, mask, pred, beta=2.0):
    idx = np.where(np.asarray(mask,bool))[0]
    y=bundle.y[idx]; f=bundle.faculty_idx[idx]
    rows=[]
    for fi,name in enumerate(bundle.faculty_names):
        m=f==fi
        if not m.any() or np.unique(y[m]).size<2: continue
        rows.append({"faculty":name,"ap":safe_ap(y[m],pred[m]),
                     "f2_at_20":fbeta(y[m],warn_by_rate(pred[m],.20),beta),
                     "brier":float(brier_score_loss(y[m],np.clip(pred[m],0,1)))})
    d=pd.DataFrame(rows)
    return {
        "macro_ap":float(d.ap.mean()) if len(d) else -np.inf,
        "macro_f2":float(d.f2_at_20.mean()) if len(d) else -np.inf,
        "macro_brier":float(d.brier.mean()) if len(d) else np.inf,
        "faculties":int(len(d)),
    }, d


def _is_better(stats, best, tol=1e-5):
    if best is None: return True
    if stats["macro_ap"] > best["macro_ap"] + tol: return True
    if abs(stats["macro_ap"]-best["macro_ap"]) <= tol:
        if stats["macro_f2"] > best["macro_f2"] + tol: return True
        if abs(stats["macro_f2"]-best["macro_f2"]) <= tol and stats["macro_brier"] < best["macro_brier"] - tol:
            return True
    return False


def predict_model(model, bundle, mask, batch_size, device, ablation="none", seed=0,
                  semester_shift=0.0, semester_scale=1.0):
    relation_perm = make_relation_permutation(bundle, mask, seed) if ablation == "shuffle_relations" else None
    model.eval(); scores=[]; unc=[]; indices=[]
    with torch.no_grad():
        for batch in make_loader(bundle, mask, batch_size, False, seed, relation_permutation=relation_perm):
            b=move_batch(batch,device)
            # relation permutation is implemented by the dataset; model should run normally.
            actual_ablation = "none" if ablation == "shuffle_relations" else ablation
            out=model_forward(model,b,actual_ablation,semester_shift,semester_scale)
            scores.append(out["probability"].detach().cpu().numpy())
            unc.append(out["uncertainty"].detach().cpu().numpy())
            indices.append(b["index"].detach().cpu().numpy())
    score=np.concatenate(scores); uncertainty=np.concatenate(unc); ix=np.concatenate(indices)
    order=np.argsort(ix)
    return score[order].astype(np.float32), uncertainty[order].astype(np.float32)


def train_select_epochs(model,bundle,train_mask,val_mask,device,epochs,min_epochs,patience,lr,weight_decay,
                        batch_size,predict_batch_size,samples_per_epoch,ranking_weight,seed,beta=2.0):
    opt=torch.optim.AdamW(model.parameters(),lr=lr,weight_decay=weight_decay)
    best_stats=None; best_epoch=1; best_state=copy.deepcopy(model.state_dict()); bad=0; rows=[]
    for ep in range(1,int(epochs)+1):
        model.train(); sums={"loss":0.,"bce":0.,"ranking":0.}; seen=0
        for batch in make_loader(bundle,train_mask,batch_size,True,seed+ep,samples_per_epoch):
            b=move_batch(batch,device); opt.zero_grad(set_to_none=True)
            out=model_forward(model,b); loss,parts=loss_components(out,b["y"],b["faculty_idx"],ranking_weight)
            if not torch.isfinite(loss): raise FloatingPointError("Suite22 training diverged to non-finite loss")
            loss.backward(); torch.nn.utils.clip_grad_norm_(model.parameters(),5.0); opt.step()
            n=len(b["y"]); seen+=n; sums["loss"]+=float(loss.detach().cpu())*n
            for k,v in parts.items(): sums[k]+=float(v.detach().cpu())*n
        pred,_=predict_model(model,bundle,val_mask,predict_batch_size,device,seed=seed+ep)
        stats,_=macro_validation(bundle,val_mask,pred,beta)
        row={"epoch":ep,**stats,**{f"train_{k}":v/max(seen,1) for k,v in sums.items()}}
        rows.append(row)
        improved=_is_better(stats,best_stats)
        if improved:
            best_stats=dict(stats); best_epoch=ep; best_state=copy.deepcopy(model.state_dict()); bad=0
        else: bad+=1
        print(f"[SELECT] epoch={ep:02d}/{epochs} loss={row['train_loss']:.5f} macroAP={stats['macro_ap']:.4f} "
              f"F2@20={stats['macro_f2']:.4f} Brier={stats['macro_brier']:.4f} best={best_epoch:02d}")
        if ep>=int(min_epochs) and bad>=int(patience): break
    model.load_state_dict(best_state)
    return int(best_epoch), dict(best_stats), pd.DataFrame(rows)


def train_fixed_epochs(model,bundle,mask,device,epochs,lr,weight_decay,batch_size,samples_per_epoch,ranking_weight,seed):
    opt=torch.optim.AdamW(model.parameters(),lr=lr,weight_decay=weight_decay)
    for ep in range(1,int(epochs)+1):
        model.train(); total=0.;seen=0
        for batch in make_loader(bundle,mask,batch_size,True,seed+ep,samples_per_epoch):
            b=move_batch(batch,device);opt.zero_grad(set_to_none=True)
            out=model_forward(model,b);loss,_=loss_components(out,b["y"],b["faculty_idx"],ranking_weight)
            loss.backward();torch.nn.utils.clip_grad_norm_(model.parameters(),5.0);opt.step()
            total+=float(loss.detach().cpu())*len(b["y"]);seen+=len(b["y"])
        if ep==1 or ep==int(epochs): print(f"[REFIT] epoch={ep:02d}/{epochs} loss={total/max(seen,1):.5f}")


def blend_logits(committee, candidate, alpha):
    q=np.clip(np.asarray(committee,float),1e-5,1-1e-5); p=np.clip(np.asarray(candidate,float),1e-5,1-1e-5)
    lq=np.log(q)-np.log1p(-q); lp=np.log(p)-np.log1p(-p)
    z=(1-float(alpha))*lq+float(alpha)*lp
    return (1/(1+np.exp(-np.clip(z,-30,30)))).astype(np.float32)


def select_safe_blend_alpha(bundle,val_mask,candidate,alpha_grid,beta=2.0):
    idx=np.where(np.asarray(val_mask,bool))[0]; q=bundle.committee[idx]
    best=None; rows=[]
    for a in alpha_grid:
        pred=blend_logits(q,candidate,a); stats,_=macro_validation(bundle,val_mask,pred,beta)
        rows.append({"alpha":float(a),**stats})
        if _is_better(stats,best): best={**stats,"alpha":float(a)}
    return float(best["alpha"]), pd.DataFrame(rows)
