"""Faculty-local chronological selection and complete-history refit."""
from __future__ import annotations
from s34_runtime import configure_cuda_workspace

configure_cuda_workspace()

from contextlib import nullcontext
import random
import time
import numpy as np
import torch
from torch import nn
from s34_data import chronological_split
from s34_metrics import cell_metrics
from s34_model import IPMVCL, parameter_count
from s34_preprocessing import Preprocessor
from s34_views import view_indices


def seed_everything(seed, threads=4):
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    torch.set_num_threads(max(1, int(threads)))
    if torch.cuda.is_available():
        torch.cuda.manual_seed_all(seed)
    torch.use_deterministic_algorithms(True, warn_only=True)
    if hasattr(torch.backends, "cudnn"):
        torch.backends.cudnn.benchmark = False
        torch.backends.cudnn.deterministic = True
    if hasattr(torch.backends, "cuda"):
        torch.backends.cuda.matmul.allow_tf32 = False


def resolve_device(value):
    if value == "auto":
        return torch.device("cuda" if torch.cuda.is_available() else "cpu")
    device = torch.device(value)
    if device.type == "cuda" and not torch.cuda.is_available():
        raise ValueError("CUDA requested but unavailable; use --device cpu or auto")
    return device


def predict_model(model, X, batch_size=4096, return_details=False, **interventions):
    model.eval()
    device = next(model.parameters()).device
    probabilities, detail_chunks = [], {}
    with torch.no_grad():
        for start in range(0, len(X), batch_size):
            xb = torch.from_numpy(np.asarray(X[start:start+batch_size], np.float32)).to(device)
            if return_details:
                logit, detail = model(xb, return_details=True, **interventions)
                for k, v in detail.items():
                    if isinstance(v, torch.Tensor):
                        detail_chunks.setdefault(k, []).append(v.float().cpu().numpy())
            else:
                logit = model(xb, **interventions)
            probabilities.append(torch.sigmoid(logit.float()).cpu().numpy())
    p = np.concatenate(probabilities).astype(float)
    if not np.isfinite(p).all():
        raise ValueError("Nonfinite model inference")
    return (p, {k: np.concatenate(v) for k, v in detail_chunks.items()}) if return_details else p


def _evaluate(model, X, y, semesters, batch_size):
    p = predict_model(model, X, batch_size)
    result = cell_metrics(y, p)
    aps = [cell_metrics(y[semesters == s], p[semesters == s])["ap"] for s in np.unique(semesters)]
    result["ap_pooled"] = result["ap"]
    result["ap"] = float(np.nanmean(aps))
    result["defined_semesters"] = int(np.isfinite(aps).sum())
    return result


def make_scaler(enabled):
    try:
        return torch.amp.GradScaler("cuda", enabled=enabled)
    except (AttributeError, TypeError):
        return torch.cuda.amp.GradScaler(enabled=enabled)


def optimizer_step(model, optimizer, scaler, allow_overflow, max_norm):
    scaler.unscale_(optimizer)
    norm = torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm,
                                         error_if_nonfinite=not allow_overflow)
    if not torch.isfinite(norm):
        # Keep a persistent scale per phase; a recoverable scaled-gradient
        # overflow skips the update and reduces the scale instead of aborting.
        scaler.update(new_scale=scaler.get_scale()/2)
        optimizer.zero_grad(set_to_none=True)
        return float(norm), True
    scaler.step(optimizer)
    scaler.update()
    return float(norm), False


def _epoch(model, X, y, optimizer, scaler, config, seed, epoch):
    model.train()
    device = next(model.parameters()).device
    amp = bool(config.get("amp", False)) and device.type == "cuda"
    batch = int(config.get("batch_size", 1024))
    accumulation = int(config.get("gradient_accumulation", 1))
    order = np.random.default_rng(seed+epoch*1009).permutation(len(y))
    loss_sum, steps, grad_sum, projection_sum, skipped_steps = 0., 0, 0., 0., 0
    for start in range(0, len(y), batch*accumulation):
        window = order[start:start+batch*accumulation]
        optimizer.zero_grad(set_to_none=True)
        for sub in range(0, len(window), batch):
            index = window[sub:sub+batch]
            xb = torch.from_numpy(X[index]).to(device)
            yb = torch.from_numpy(y[index].astype(np.float32)).to(device)
            context = torch.autocast(device_type="cuda", dtype=torch.float16) if amp else nullcontext()
            with context:
                logit, details = model(xb, return_details=True)
                loss = nn.functional.binary_cross_entropy_with_logits(logit, yb, reduction="sum")
                if details["aux"]:
                    aux = sum(nn.functional.binary_cross_entropy_with_logits(v, yb, reduction="sum")
                              for v in details["aux"].values())/3
                    loss = loss + float(config.get("aux_weight", .05))*aux
                objective = loss/len(window)
            if not torch.isfinite(objective):
                raise FloatingPointError("Nonfinite training objective")
            scaler.scale(objective).backward()
            loss_sum += float(loss.detach().float().cpu())
        norm, skipped = optimizer_step(model, optimizer, scaler, amp,
                                       float(config.get("gradient_clip", 1.)))
        skipped_steps += int(skipped)
        grad_sum += norm if np.isfinite(norm) else 0.
        if hasattr(model, "projections") and not skipped:
            projection_sum += sum(float(p.grad.norm()) for p in model.projections.parameters()
                                  if p.grad is not None)
        steps += 1
    return dict(train_objective_loss=loss_sum/len(y), gradient_norm=grad_sum/max(1, steps),
                projection_gradient_norm=projection_sum/max(1, steps),
                optimizer_steps=steps-skipped_steps, amp_skipped_steps=skipped_steps,
                amp_scale=float(scaler.get_scale()))


def fit_predict(history, target, manifest, config, seed, arm, emit=None, calendar=None):
    emit = emit or (lambda tag, row: None)
    config = dict(config)
    max_epochs, minimum = int(config.get("epochs", 18)), int(config.get("min_epochs", 3))
    if not 1 <= minimum <= max_epochs:
        raise ValueError("Require 1 <= min_epochs <= epochs")
    device = resolve_device(config.get("device", "auto"))
    fit, val, split = chronological_split(history, int(config.get("validation_blocks", 3)), calendar)
    begin = time.monotonic()
    seed_everything(seed, config.get("threads", 4))
    pp = Preprocessor(history.names, manifest.get("categorical", []),
                      config.get("categorical_slots", 32), config.get("clip", 10)).fit(history.X[fit])
    Xfit, Xval = pp.transform(history.X[fit]), pp.transform(history.X[val])
    selection_preprocessing_seconds = time.monotonic()-begin
    views = view_indices(manifest, pp.bundles)
    model = IPMVCL(pp.dimension, views, arm, config).to(device)
    optimizer = torch.optim.AdamW(model.parameters(), lr=float(config.get("learning_rate", .0003)),
                                 weight_decay=float(config.get("weight_decay", .001)))
    scaler = make_scaler(bool(config.get("amp", False)) and device.type == "cuda")
    # Reset stochastic-training RNG after construction, including optional aux-head allocation.
    torch.manual_seed(seed+7919)
    curves, best_epoch, best_ap, best_bce, stale = [], 0, -np.inf, np.inf, 0
    emit("PREPROCESSING_AUDIT", dict(phase="selection", **pp.audit()))
    emit("TRAINING_START", dict(arm=arm, seed=seed, parameters=parameter_count(model),
                                input_dimension=pp.dimension,
                                view_dimensions={v: len(ix) for v, ix in views.items()}, **split))
    for epoch in range(1, max_epochs+1):
        epoch_start = time.monotonic()
        train_diag = _epoch(model, Xfit, history.y[fit], optimizer, scaler, config, seed, epoch)
        train = _evaluate(model, Xfit, history.y[fit], history.semester[fit], config.get("batch_size", 1024))
        valid = _evaluate(model, Xval, history.y[val], history.semester[val], config.get("batch_size", 1024))
        row = dict(phase="selection", epoch=epoch, train_loss=train["bce"], train_ap=train["ap"],
                   validation_loss=valid["bce"], validation_ap=valid["ap"],
                   validation_ap_pooled=valid["ap_pooled"], validation_auc=valid["auc"],
                   validation_brier=valid["brier"], learning_rate=optimizer.param_groups[0]["lr"],
                   elapsed_seconds=time.monotonic()-epoch_start, **train_diag)
        curves.append(row)
        emit("EPOCH_METRICS", row)
        if epoch >= minimum:
            improve = valid["ap"] > best_ap+1e-6 or (
                abs(valid["ap"]-best_ap) <= 1e-6 and valid["bce"] < best_bce-1e-9)
            if improve:
                best_epoch, best_ap, best_bce, stale = epoch, valid["ap"], valid["bce"], 0
            else:
                stale += 1
            if stale >= int(config.get("patience", 5)):
                break
    if not best_epoch:
        raise ValueError("No eligible validation epoch selected")
    selection_seconds = time.monotonic()-begin
    selection = dict(**split, selected_epoch=best_epoch, validation_ap=best_ap,
                     validation_bce=best_bce, selection_seconds=selection_seconds)
    emit("EARLY_STOPPING", selection)
    del optimizer, scaler, model, Xfit, Xval
    if device.type == "cuda":
        torch.cuda.empty_cache()
    refit_start = time.monotonic()
    seed_everything(seed, config.get("threads", 4))
    pp = Preprocessor(history.names, manifest.get("categorical", []),
                      config.get("categorical_slots", 32), config.get("clip", 10)).fit(history.X)
    Xall = pp.transform(history.X)
    refit_preprocessing_seconds = time.monotonic()-refit_start
    model = IPMVCL(pp.dimension, view_indices(manifest, pp.bundles), arm, config).to(device)
    optimizer = torch.optim.AdamW(model.parameters(), lr=float(config.get("learning_rate", .0003)),
                                 weight_decay=float(config.get("weight_decay", .001)))
    scaler = make_scaler(bool(config.get("amp", False)) and device.type == "cuda")
    torch.manual_seed(seed+7919)
    emit("PREPROCESSING_AUDIT", dict(phase="refit", **pp.audit()))
    emit("REFIT", dict(selected_epochs=best_epoch, permissible_rows=len(history), seed=seed))
    for epoch in range(1, best_epoch+1):
        epoch_start = time.monotonic()
        train_diag = _epoch(model, Xall, history.y, optimizer, scaler, config, seed, epoch)
        train = _evaluate(model, Xall, history.y, history.semester, config.get("batch_size", 1024))
        row = dict(phase="refit", epoch=epoch, train_loss=train["bce"], train_ap=train["ap"],
                   validation_loss=np.nan, validation_ap=np.nan, validation_auc=np.nan,
                   validation_brier=np.nan, learning_rate=optimizer.param_groups[0]["lr"],
                   elapsed_seconds=time.monotonic()-epoch_start, **train_diag)
        curves.append(row)
        emit("EPOCH_METRICS", row)
    refit_seconds = time.monotonic()-refit_start
    inference_start = time.monotonic()
    p = predict_model(model, pp.transform(target.X), config.get("batch_size", 1024))
    return dict(model=model, preprocessor=pp, manifest=manifest, probabilities=p,
                training_curves=curves, selection=selection, parameter_count=parameter_count(model),
                runtimes=dict(selection_seconds=selection_seconds, refit_seconds=refit_seconds,
                              selection_preprocessing_seconds=selection_preprocessing_seconds,
                              refit_preprocessing_seconds=refit_preprocessing_seconds,
                              selection_training_evaluation_seconds=selection_seconds-selection_preprocessing_seconds,
                              refit_training_evaluation_seconds=refit_seconds-refit_preprocessing_seconds,
                              inference_seconds=time.monotonic()-inference_start),
                final_train_ap=curves[-1]["train_ap"])


def fit_hgb(history, target, config, seed):
    from sklearn.ensemble import HistGradientBoostingClassifier
    from threadpoolctl import threadpool_limits
    begin = time.monotonic()
    model = HistGradientBoostingClassifier(learning_rate=.06, max_iter=int(config.get("hgb_iterations", 100)),
                                          max_leaf_nodes=15, min_samples_leaf=20,
                                          l2_regularization=1., early_stopping=False, random_state=seed)
    X = np.where(np.isfinite(history.X), history.X, np.nan)
    with threadpool_limits(limits=int(config.get("threads", 4))):
        model.fit(X, history.y)
        p = model.predict_proba(np.where(np.isfinite(target.X), target.X, np.nan))[:, 1]
    return dict(model=model, probabilities=p, manifest=None, preprocessor=None,
                selection=dict(selected_epoch=0, validation_ap=np.nan),
                training_curves=[], parameter_count=0, final_train_ap=np.nan,
                runtimes=dict(fit_seconds=time.monotonic()-begin))
