from __future__ import annotations

import json
import random
import time
from pathlib import Path
from typing import Any

import numpy as np
import torch
from sklearn.metrics import accuracy_score, confusion_matrix, f1_score, precision_score, recall_score
from torch import nn
from torch.utils.data import DataLoader

from .data import FallClipDataset
from .models import build_model


def set_seed(seed: int) -> None:
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    torch.cuda.manual_seed_all(seed)


def resolve_device(device: str) -> torch.device:
    if device == "auto":
        return torch.device("cuda" if torch.cuda.is_available() else "cpu")
    return torch.device(device)


class FocalLoss(nn.Module):
    def __init__(self, gamma: float = 2.0, weight: torch.Tensor | None = None):
        super().__init__()
        self.gamma = gamma
        self.weight = weight

    def forward(self, logits: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
        ce = nn.functional.cross_entropy(logits, target, weight=self.weight, reduction="none")
        pt = torch.exp(-ce)
        return ((1 - pt) ** self.gamma * ce).mean()


def batch_to_device(batch: dict[str, Any], device: torch.device) -> dict[str, Any]:
    return {k: (v.to(device) if torch.is_tensor(v) else v) for k, v in batch.items()}


def compute_metrics(y_true: list[int], y_pred: list[int]) -> dict[str, float]:
    labels = [0, 1]
    cm = confusion_matrix(y_true, y_pred, labels=labels)
    tn, fp, fn, tp = cm.ravel() if cm.size == 4 else (0, 0, 0, 0)
    spec = tn / (tn + fp) if (tn + fp) else 0.0
    return {
        "accuracy": float(accuracy_score(y_true, y_pred)),
        "precision": float(precision_score(y_true, y_pred, zero_division=0)),
        "recall": float(recall_score(y_true, y_pred, zero_division=0)),
        "specificity": float(spec),
        "f1": float(f1_score(y_true, y_pred, zero_division=0)),
        "macro_f1": float(f1_score(y_true, y_pred, average="macro", zero_division=0)),
    }


@torch.no_grad()
def evaluate_loader(model: nn.Module, loader: DataLoader, device: torch.device) -> tuple[dict[str, float], float]:
    model.eval()
    y_true: list[int] = []
    y_pred: list[int] = []
    start = time.perf_counter()
    n = 0
    for batch in loader:
        batch = batch_to_device(batch, device)
        logits = model(batch)
        pred = logits.argmax(1).detach().cpu().tolist()
        y_pred.extend(pred)
        y_true.extend(batch["label"].detach().cpu().tolist())
        n += len(pred)
    elapsed = max(time.perf_counter() - start, 1e-9)
    metrics = compute_metrics(y_true, y_pred)
    return metrics, n / elapsed


def train_model(
    dataset: str,
    method: str,
    cfg: dict[str, Any],
    epochs: int | None = None,
    out_dir: str | Path | None = None,
    processed_dataset: str | None = None,
) -> dict[str, Any]:
    set_seed(int(cfg["seed"]))
    device = resolve_device(cfg.get("device", "auto"))
    base = Path("data/processed") / (processed_dataset or dataset)
    out = Path(out_dir or Path("results") / dataset / method)
    out.mkdir(parents=True, exist_ok=True)
    train_ds = FallClipDataset(
        base / "train.pkl",
        train=True,
        confidence_dropout=method == "dynafall" and cfg["dropout"]["enabled"],
        random_dropout=method == "dynafall_random_dropout",
        random_dropout_prob=cfg["dropout"]["high_conf_prob"],
        high_conf_prob=cfg["dropout"]["high_conf_prob"],
        low_conf_prob=cfg["dropout"]["low_conf_prob"],
        low_conf_threshold=cfg["dropout"]["low_conf_threshold"],
        seed=cfg["seed"],
    )
    val_ds = FallClipDataset(base / "val.pkl")
    train_loader = DataLoader(train_ds, batch_size=cfg["batch_size"], shuffle=True, num_workers=cfg["num_workers"])
    val_loader = DataLoader(val_ds, batch_size=cfg["batch_size"], shuffle=False, num_workers=cfg["num_workers"])
    model = build_model(method, hidden=cfg["model"]["hidden"], num_classes=cfg["model"]["num_classes"]).to(device)
    opt = torch.optim.AdamW(model.parameters(), lr=cfg["lr"], weight_decay=cfg["weight_decay"])
    class_weight = class_weights_from_dataset(train_ds, cfg["model"]["num_classes"]).to(device)
    loss_fn: nn.Module = (
        FocalLoss(cfg["loss"]["gamma"], weight=class_weight)
        if cfg["loss"]["name"] == "focal"
        else nn.CrossEntropyLoss(weight=class_weight)
    )
    best_f1 = -1.0
    best_epoch = 0
    patience = int(cfg["patience"])
    max_epochs = int(epochs or cfg["epochs"])
    history = []
    for epoch in range(1, max_epochs + 1):
        model.train()
        losses = []
        for batch in train_loader:
            batch = batch_to_device(batch, device)
            opt.zero_grad(set_to_none=True)
            loss = loss_fn(model(batch), batch["label"])
            loss.backward()
            opt.step()
            losses.append(float(loss.detach().cpu()))
        val_metrics, val_fps = evaluate_loader(model, val_loader, device)
        row = {"epoch": epoch, "loss": float(np.mean(losses)), "val_fps": val_fps, **{f"val_{k}": v for k, v in val_metrics.items()}}
        history.append(row)
        if val_metrics["f1"] > best_f1:
            best_f1 = val_metrics["f1"]
            best_epoch = epoch
            torch.save({"model": model.state_dict(), "cfg": cfg, "method": method}, out / "best.pt")
        if epoch - best_epoch >= patience:
            break
    (out / "history.json").write_text(json.dumps(history, indent=2))
    return {"best_epoch": best_epoch, "best_val_f1": best_f1, "checkpoint": str(out / "best.pt")}


def class_weights_from_dataset(ds: FallClipDataset, num_classes: int) -> torch.Tensor:
    counts = torch.zeros(num_classes, dtype=torch.float32)
    for sample in ds.samples:
        counts[int(sample["label"])] += 1
    counts = counts.clamp_min(1.0)
    weights = counts.sum() / (num_classes * counts)
    return weights / weights.mean()


def evaluate_checkpoint(
    dataset: str,
    method: str,
    cfg: dict[str, Any],
    checkpoint: str | Path | None = None,
    split: str = "test",
    robustness: str = "clean",
    missing_amount: float = 0.0,
    tag: str | None = None,
    processed_dataset: str | None = None,
    out_dir: str | Path | None = None,
) -> dict[str, Any]:
    device = resolve_device(cfg.get("device", "auto"))
    default_dir = Path(out_dir or Path("results") / dataset / method)
    ckpt_path = Path(checkpoint or default_dir / "best.pt")
    state = torch.load(ckpt_path, map_location=device)
    method = state.get("method", method)
    model = build_model(method, hidden=cfg["model"]["hidden"], num_classes=cfg["model"]["num_classes"]).to(device)
    model.load_state_dict(state["model"])
    ds = FallClipDataset(
        Path("data/processed") / (processed_dataset or dataset) / f"{split}.pkl",
        robustness=robustness,
        missing_amount=missing_amount,
    )
    loader = DataLoader(ds, batch_size=cfg["batch_size"], shuffle=False, num_workers=cfg["num_workers"])
    metrics, fps = evaluate_loader(model, loader, device)
    params = sum(p.numel() for p in model.parameters())
    result = {"dataset": dataset, "method": method, "split": split, "robustness": robustness, "fps": fps, "params": params, **metrics}
    out_dir = default_dir
    out_dir.mkdir(parents=True, exist_ok=True)
    suffix = tag or f"{split}_{robustness}"
    (out_dir / f"metrics_{suffix}.json").write_text(json.dumps(result, indent=2))
    return result