from __future__ import annotations

import json
import math
import random
import shutil
from pathlib import Path

import numpy as np
import torch
import trackio
from model import MeshGraphGAT, parameter_count
from safetensors.torch import save_file
from sklearn.metrics import (
    accuracy_score,
    average_precision_score,
    f1_score,
    precision_score,
    recall_score,
    roc_auc_score,
)
from torch.nn import functional as F

PROJECT_DIR = Path(__file__).resolve().parent
ROOT_DIR = PROJECT_DIR.parents[1]
SOURCE_DIR = ROOT_DIR / "projects" / "meshgraph-gcn"
ARTIFACT_DIR = PROJECT_DIR / "artifacts" / "meshgraph-gat"
DATA_DIR = PROJECT_DIR / "data"
SEED = 2189


def metrics(labels: np.ndarray, scores: np.ndarray, threshold: float) -> dict:
    predictions = scores >= threshold
    return {
        "accuracy": float(accuracy_score(labels, predictions)),
        "roc_auc": float(roc_auc_score(labels, scores)),
        "average_precision": float(average_precision_score(labels, scores)),
        "precision": float(precision_score(labels, predictions, zero_division=0)),
        "recall": float(recall_score(labels, predictions, zero_division=0)),
        "f1": float(f1_score(labels, predictions, zero_division=0)),
    }


def best_threshold(labels: np.ndarray, scores: np.ndarray) -> float:
    candidates = np.quantile(scores, np.linspace(0.05, 0.95, 300))
    return float(
        max(
            candidates,
            key=lambda threshold: f1_score(
                labels, scores >= threshold, zero_division=0
            ),
        )
    )


def attention_audit(
    attention: torch.Tensor,
    adjacency: torch.Tensor,
    nodes: np.ndarray,
) -> dict:
    mean_attention = attention.mean(0)
    normalized_entropies = []
    top_edges = []
    for node in nodes:
        neighbors = torch.nonzero(adjacency[node] > 0).flatten()
        weights = mean_attention[node, neighbors]
        if len(neighbors) > 1:
            entropy = -(weights * weights.clamp_min(1e-12).log()).sum()
            normalized_entropies.append(float(entropy / math.log(len(neighbors))))
        for neighbor, weight in zip(neighbors.tolist(), weights.tolist(), strict=True):
            top_edges.append((float(weight), int(node), int(neighbor)))
    top_edges.sort(reverse=True)
    return {
        "mean_normalized_attention_entropy": float(np.mean(normalized_entropies)),
        "top_test_edges": [
            {"source": source, "target": target, "attention": weight}
            for weight, source, target in top_edges[:20]
        ],
    }


def main() -> None:
    random.seed(SEED)
    np.random.seed(SEED)
    torch.manual_seed(SEED)
    torch.set_num_threads(1)
    graph = np.load(SOURCE_DIR / "data" / "meshgraph.npz")
    features = graph["features"].astype(np.float32)
    labels = graph["labels"].astype(np.int64)
    train_indices = graph["train_indices"]
    validation_indices = graph["validation_indices"]
    test_indices = graph["test_indices"]
    mean = features[train_indices].mean(0)
    scale = np.maximum(features[train_indices].std(0), 1e-5)
    feature_tensor = torch.from_numpy((features - mean) / scale)
    label_tensor = torch.from_numpy(labels)
    adjacency = torch.from_numpy(graph["adjacency"].astype(np.float32))
    model = MeshGraphGAT(features.shape[1])
    positive_weight = (labels[train_indices] == 0).sum() / max(
        1, (labels[train_indices] == 1).sum()
    )
    class_weights = torch.tensor([1.0, positive_weight], dtype=torch.float32)
    optimizer = torch.optim.AdamW(model.parameters(), lr=0.008, weight_decay=0.002)
    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=400)
    best_auc = -1.0
    best_epoch = 0
    best_state = None
    trackio.init(
        project="meshgraph-gat",
        name="four-head-enterprise-gat-v1",
        config={
            "parameters": parameter_count(model),
            "nodes": len(labels),
            "edges": int(adjacency.sum() // 2),
            "heads": 4,
        },
    )
    for epoch in range(1, 401):
        model.train()
        logits = model(feature_tensor, adjacency)
        loss = F.cross_entropy(
            logits[train_indices], label_tensor[train_indices], weight=class_weights
        )
        optimizer.zero_grad(set_to_none=True)
        loss.backward()
        optimizer.step()
        scheduler.step()
        model.eval()
        with torch.inference_mode():
            scores = model(feature_tensor, adjacency).softmax(1)[:, 1]
        validation_auc = roc_auc_score(
            labels[validation_indices], scores[validation_indices].numpy()
        )
        if validation_auc > best_auc:
            best_auc = validation_auc
            best_epoch = epoch
            best_state = {
                name: value.detach().cpu().clone()
                for name, value in model.state_dict().items()
            }
        if epoch == 1 or epoch % 20 == 0:
            trackio.log(
                {
                    "epoch": epoch,
                    "training_loss": float(loss.detach()),
                    "validation_roc_auc": validation_auc,
                }
            )
    assert best_state is not None
    model.load_state_dict(best_state)
    model.eval()
    with torch.inference_mode():
        logits, attention = model(
            feature_tensor, adjacency, return_attention=True
        )
        scores = logits.softmax(1)[:, 1].numpy()
    threshold = best_threshold(labels[validation_indices], scores[validation_indices])
    gcn_report = json.loads(
        (
            SOURCE_DIR / "artifacts" / "meshgraph-gcn" / "evaluation.json"
        ).read_text(encoding="utf-8")
    )
    results = {
        "model": "MeshGraph GAT",
        "parameters": parameter_count(model),
        "best_epoch": best_epoch,
        "best_validation_roc_auc": best_auc,
        "threshold": threshold,
        "gat_test": metrics(labels[test_indices], scores[test_indices], threshold),
        "existing_gcn_test": gcn_report["gcn_test"],
        "existing_feature_only_test": gcn_report["feature_only_logistic_test"],
        "attention_audit": attention_audit(attention, adjacency, test_indices),
    }
    ARTIFACT_DIR.mkdir(parents=True, exist_ok=True)
    DATA_DIR.mkdir(parents=True, exist_ok=True)
    save_file(model.state_dict(), ARTIFACT_DIR / "model.safetensors")
    np.savez(
        ARTIFACT_DIR / "preprocessing.npz",
        mean=mean,
        scale=scale,
        threshold=threshold,
    )
    (ARTIFACT_DIR / "evaluation.json").write_text(
        json.dumps(results, indent=2), encoding="utf-8"
    )
    shutil.copy2(SOURCE_DIR / "data" / "meshgraph.npz", DATA_DIR / "meshgraph.npz")
    trackio.log(
        {
            "test_roc_auc": results["gat_test"]["roc_auc"],
            "test_average_precision": results["gat_test"]["average_precision"],
            "test_f1": results["gat_test"]["f1"],
            "attention_entropy": results["attention_audit"][
                "mean_normalized_attention_entropy"
            ],
        }
    )
    trackio.finish()
    print(json.dumps(results, indent=2))


if __name__ == "__main__":
    main()