from __future__ import annotations

import copy
import math
import random
from dataclasses import dataclass

import numpy as np
import pandas as pd
import torch
from sklearn.metrics import average_precision_score, roc_auc_score
from torch.utils.data import DataLoader, Dataset, WeightedRandomSampler

from suite20_data import Suite20Bundle, faculty_class_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: Suite20Bundle, indices: np.ndarray):
        self.b = bundle
        self.idx = np.asarray(indices, int)

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

    def __getitem__(self, j):
        i = int(self.idx[j])
        return {
            "flat": torch.from_numpy(self.b.flat[i]),
            "student_seq": torch.from_numpy(self.b.student_seq[i]),
            "student_mask": torch.from_numpy(self.b.student_mask[i]),
            "course_target": torch.from_numpy(self.b.course_target[i]),
            "faculty_idx": torch.tensor(int(self.b.faculty_idx[i]), dtype=torch.long),
            "semester_scalar": torch.tensor(float(self.b.target_semester[i]), dtype=torch.float32),
            "y": torch.tensor(float(self.b.y[i]), dtype=torch.float32),
            "index": torch.tensor(i, dtype=torch.long),
        }


def _loader(bundle, mask, batch_size, shuffle, seed, sampling_beta=.9999, samples_per_epoch=0):
    idx = np.where(np.asarray(mask, bool))[0]
    ds = BundleDataset(bundle, idx)
    generator = torch.Generator()
    generator.manual_seed(int(seed))
    if shuffle:
        local_w, _ = faculty_class_sampling_weights(
            bundle.y[idx], bundle.faculty_idx[idx], bundle.faculty_names, beta=sampling_beta
        )
        num_samples = int(samples_per_epoch) if int(samples_per_epoch) > 0 else len(idx)
        sampler = WeightedRandomSampler(
            torch.as_tensor(local_w, dtype=torch.double),
            num_samples=num_samples,
            replacement=True,
            generator=generator,
        )
        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 member_bce_loss(member_logits: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
    target = y[:, None].expand_as(member_logits)
    return torch.nn.functional.binary_cross_entropy_with_logits(member_logits, target)


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


def safe_auc(y, p):
    y = np.asarray(y, int)
    if np.unique(y).size < 2:
        return np.nan
    return float(roc_auc_score(y, p))


def macro_faculty_ap(y, p, faculty_idx, faculty_names):
    vals = []
    rows = []
    for fi, name in enumerate(faculty_names):
        m = np.asarray(faculty_idx) == fi
        if not m.any() or np.unique(np.asarray(y)[m]).size < 2:
            continue
        ap = safe_ap(np.asarray(y)[m], np.asarray(p)[m])
        vals.append(ap)
        rows.append((name, ap))
    return (float(np.nanmean(vals)) if vals else np.nan), rows


def predict(model, bundle, mask, batch_size, device, perturbation="none"):
    model.eval()
    mask_arr = np.asarray(mask, bool)
    outputs = {k: [] for k in ["probability", "uncertainty", "gate", "attention", "has_history", "index"]}
    with torch.no_grad():
        for batch in _loader(bundle, mask_arr, batch_size, False, 0):
            b = move_batch(batch, device)
            student_seq = b["student_seq"]
            student_mask = b["student_mask"]
            if perturbation == "reverse_history":
                student_seq = torch.flip(student_seq, dims=[1])
                student_mask = torch.flip(student_mask, dims=[1])
            elif perturbation == "zero_history":
                student_seq = torch.zeros_like(student_seq)
                student_mask = torch.zeros_like(student_mask)
            out = model(
                b["flat"], student_seq, student_mask, b["course_target"], b["faculty_idx"], b["semester_scalar"]
            )
            for key in ["probability", "uncertainty", "gate", "attention", "has_history"]:
                outputs[key].append(out[key].detach().cpu().numpy())
            outputs["index"].append(b["index"].detach().cpu().numpy())
    for k in outputs:
        outputs[k] = np.concatenate(outputs[k], axis=0) if outputs[k] else np.array([])
    order = np.argsort(outputs["index"])
    for k in outputs:
        outputs[k] = outputs[k][order]
    return outputs


def validation_score(bundle, mask, pred):
    idx = np.where(mask)[0]
    macro_ap, faculty_rows = macro_faculty_ap(bundle.y[idx], pred, bundle.faculty_idx[idx], bundle.faculty_names)
    pooled_ap = safe_ap(bundle.y[idx], pred)
    # Give macro faculty performance priority while retaining pooled ranking signal.
    score = macro_ap + .15 * pooled_ap
    return {
        "score": float(score),
        "macro_ap": float(macro_ap),
        "pooled_ap": float(pooled_ap),
        "faculty_ap": faculty_rows,
    }


def train_select_epochs(
    model,
    bundle,
    train_mask,
    val_mask,
    device,
    epochs,
    lr,
    weight_decay,
    batch_size,
    predict_batch_size,
    sampling_beta,
    samples_per_epoch,
    patience,
    seed,
):
    optimizer = torch.optim.AdamW(model.parameters(), lr=lr, weight_decay=weight_decay)
    best_score = -np.inf
    best_epoch = 0
    best_state = copy.deepcopy(model.state_dict())
    bad = 0
    rows = []
    for epoch in range(1, int(epochs) + 1):
        model.train()
        total_loss, seen = 0.0, 0
        for batch in _loader(
            bundle, train_mask, batch_size, True, seed + epoch,
            sampling_beta=sampling_beta, samples_per_epoch=samples_per_epoch
        ):
            b = move_batch(batch, device)
            optimizer.zero_grad(set_to_none=True)
            out = model(
                b["flat"], b["student_seq"], b["student_mask"], b["course_target"],
                b["faculty_idx"], b["semester_scalar"]
            )
            loss = member_bce_loss(out["member_logits"], b["y"])
            loss.backward()
            torch.nn.utils.clip_grad_norm_(model.parameters(), 5.0)
            optimizer.step()
            total_loss += float(loss.detach().cpu()) * len(b["y"])
            seen += len(b["y"])
        val_pred = predict(model, bundle, val_mask, predict_batch_size, device)["probability"]
        stats = validation_score(bundle, val_mask, val_pred)
        row = {
            "epoch": epoch,
            "train_loss": total_loss / max(seen, 1),
            "val_score": stats["score"],
            "val_macro_ap": stats["macro_ap"],
            "val_pooled_ap": stats["pooled_ap"],
        }
        rows.append(row)
        print(
            f"[SELECT] epoch={epoch:02d}/{epochs} loss={row['train_loss']:.5f} "
            f"macroAP={row['val_macro_ap']:.4f} pooledAP={row['val_pooled_ap']:.4f} "
            f"selection={row['val_score']:.5f}"
        )
        if stats["score"] > best_score + 1e-4:
            best_score = stats["score"]
            best_epoch = epoch
            best_state = copy.deepcopy(model.state_dict())
            bad = 0
        else:
            bad += 1
        if epoch >= 3 and bad >= int(patience):
            break
    model.load_state_dict(best_state)
    return best_epoch, pd.DataFrame(rows)


def train_fixed_epochs(
    model,
    bundle,
    train_mask,
    device,
    epochs,
    lr,
    weight_decay,
    batch_size,
    sampling_beta,
    samples_per_epoch,
    seed,
):
    optimizer = torch.optim.AdamW(model.parameters(), lr=lr, weight_decay=weight_decay)
    for epoch in range(1, int(epochs) + 1):
        model.train()
        total_loss, seen = 0.0, 0
        for batch in _loader(
            bundle, train_mask, batch_size, True, seed + 1000 + epoch,
            sampling_beta=sampling_beta, samples_per_epoch=samples_per_epoch
        ):
            b = move_batch(batch, device)
            optimizer.zero_grad(set_to_none=True)
            out = model(
                b["flat"], b["student_seq"], b["student_mask"], b["course_target"],
                b["faculty_idx"], b["semester_scalar"]
            )
            loss = member_bce_loss(out["member_logits"], b["y"])
            loss.backward()
            torch.nn.utils.clip_grad_norm_(model.parameters(), 5.0)
            optimizer.step()
            total_loss += float(loss.detach().cpu()) * len(b["y"])
            seen += len(b["y"])
        if epoch == 1 or epoch == int(epochs):
            print(f"[REFIT] epoch={epoch:02d}/{epochs} loss={total_loss/max(seen,1):.5f}")
