#!/usr/bin/env python3
"""
Reproduce the ~52% validation-accuracy CNN run on the ds16k packed expert-trace dataset.

Dataset format expected:
  dataset_root/
    expert_00/
      traces.npy      # shape (N, 16384), float32
      trial_ids.npy   # shape (N,), int32
    ...
    expert_31/

This script mirrors the original run settings:
- preprocess_mode=curr (baseline z-score over first 2000 samples)
- feature_len=16384 (already in dataset)
- append dx channel => model input_dim=32768
- grouped_trial split with val_size=10000, seed=7
- CNN (BatchNorm, dropout=0.2)
- Adam lr=1e-3, weight_decay=0, cosine schedule, warmup=2 epochs
- epochs=20, batch_size=32
"""

import argparse
import json
import math
import random
import time
from datetime import datetime
from pathlib import Path
from typing import Dict, List, Tuple

import numpy as np
import torch
import torch.nn as nn
from torch.utils.data import DataLoader, Dataset


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


def grouped_trial_split(y: np.ndarray, groups: np.ndarray, val_frac: float, seed: int, val_size: int = 0):
    valid_groups = sorted({int(g) for g in groups.tolist() if g >= 0})
    if len(valid_groups) < 2:
        raise ValueError("Need >=2 trial groups for grouped split")

    rng = np.random.default_rng(seed)
    rng.shuffle(valid_groups)

    if int(val_size) > 0:
        target = int(val_size)
        group_sizes = {g: int(np.sum(groups == g)) for g in valid_groups}
        running = 0
        best_i = 1
        best_diff = float("inf")
        for i, g in enumerate(valid_groups, start=1):
            if i >= len(valid_groups):
                break
            running += group_sizes[g]
            diff = abs(running - target)
            if diff < best_diff:
                best_diff = diff
                best_i = i
        n_val = best_i
    else:
        n_val = max(1, int(round(len(valid_groups) * val_frac)))
        n_val = min(n_val, len(valid_groups) - 1)

    val_groups = set(valid_groups[:n_val])
    val_mask = np.isin(groups, np.array(list(val_groups), dtype=np.int64))
    train_idx = np.where(~val_mask)[0]
    val_idx = np.where(val_mask)[0]

    if len(train_idx) == 0 or len(val_idx) == 0:
        raise ValueError("Grouped split produced empty train/val")

    for c in sorted(np.unique(y).tolist()):
        if not np.any(y[train_idx] == c):
            raise ValueError("Class {} missing from train after grouped split".format(c))
        if not np.any(y[val_idx] == c):
            raise ValueError("Class {} missing from val after grouped split".format(c))

    return train_idx.astype(np.int64), val_idx.astype(np.int64), sorted(val_groups)


def confusion_matrix_np(y_true: np.ndarray, y_pred: np.ndarray, num_classes: int) -> np.ndarray:
    cm = np.zeros((num_classes, num_classes), dtype=np.int64)
    for t, p in zip(y_true.tolist(), y_pred.tolist()):
        cm[t, p] += 1
    return cm


class CNN1DClassifier(nn.Module):
    def __init__(self, input_dim: int, num_classes: int, dropout: float = 0.2):
        super().__init__()
        self.input_dim = int(input_dim)
        self.features = nn.Sequential(
            nn.Conv1d(1, 32, kernel_size=9, padding=4),
            nn.BatchNorm1d(32, track_running_stats=True),
            nn.ReLU(),
            nn.Conv1d(32, 64, kernel_size=9, padding=4),
            nn.BatchNorm1d(64, track_running_stats=True),
            nn.ReLU(),
            nn.MaxPool1d(4),
            nn.Conv1d(64, 128, kernel_size=7, padding=3),
            nn.BatchNorm1d(128, track_running_stats=True),
            nn.ReLU(),
            nn.MaxPool1d(4),
            nn.Conv1d(128, 192, kernel_size=5, padding=2),
            nn.BatchNorm1d(192, track_running_stats=True),
            nn.ReLU(),
            nn.AdaptiveAvgPool1d(1),
        )
        self.head = nn.Sequential(
            nn.Flatten(),
            nn.Dropout(float(dropout)),
            nn.Linear(192, num_classes),
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        x = x.view(x.shape[0], 1, self.input_dim)
        x = self.features(x)
        return self.head(x)


class PackedFeatureDataset(Dataset):
    def __init__(
        self,
        traces_by_class: List[np.ndarray],
        labels: np.ndarray,
        class_of: np.ndarray,
        row_of: np.ndarray,
        indices: np.ndarray,
        baseline_samples: int,
    ):
        self.traces_by_class = traces_by_class
        self.labels = labels
        self.class_of = class_of
        self.row_of = row_of
        self.indices = indices.astype(np.int64)
        self.baseline_samples = int(baseline_samples)

    def __len__(self):
        return int(len(self.indices))

    def __getitem__(self, i: int):
        gidx = int(self.indices[i])
        c = int(self.class_of[gidx])
        r = int(self.row_of[gidx])
        y = int(self.labels[gidx])

        x = self.traces_by_class[c][r].astype(np.float32, copy=False)

        pre = max(1, min(len(x), self.baseline_samples))
        b = x[:pre]
        mu = float(b.mean())
        sd = float(b.std())
        x = x - mu
        if sd > 1e-8:
            x = x / sd

        dx = np.diff(x, prepend=x[0]).astype(np.float32)
        feat = np.concatenate([x, dx], axis=0).astype(np.float32)

        return torch.from_numpy(feat), torch.tensor(y, dtype=torch.long)


@torch.no_grad()
def evaluate(model: nn.Module, loader: DataLoader, device: str):
    model.eval()
    ys = []
    ps = []
    total = 0
    correct = 0
    for xb, yb in loader:
        xb = xb.to(device, non_blocking=True)
        yb = yb.to(device, non_blocking=True)
        logits = model(xb)
        pred = torch.argmax(logits, dim=1)
        ys.append(yb.cpu().numpy())
        ps.append(pred.cpu().numpy())
        total += int(yb.numel())
        correct += int((pred == yb).sum().item())

    y_true = np.concatenate(ys) if ys else np.array([], dtype=np.int64)
    y_pred = np.concatenate(ps) if ps else np.array([], dtype=np.int64)
    acc = float(correct / total) if total > 0 else 0.0
    return acc, y_true, y_pred


def build_index(dataset_root: Path, class_names: List[str]):
    traces_by_class = []
    labels_list = []
    groups_list = []
    class_of_list = []
    row_of_list = []

    for cid, cname in enumerate(class_names):
        cdir = dataset_root / cname
        tpath = cdir / "traces.npy"
        gpath = cdir / "trial_ids.npy"
        if not tpath.exists() or not gpath.exists():
            raise FileNotFoundError("Missing {} or {}".format(tpath, gpath))

        traces = np.load(tpath, mmap_mode="r")
        trial_ids = np.load(gpath, mmap_mode="r").astype(np.int64)

        if traces.ndim != 2:
            raise ValueError("{} must be 2D".format(tpath))
        if traces.shape[0] != trial_ids.shape[0]:
            raise ValueError("row count mismatch in {}".format(cdir))

        n = int(traces.shape[0])
        traces_by_class.append(traces)
        labels_list.append(np.full((n,), cid, dtype=np.int64))
        groups_list.append(trial_ids)
        class_of_list.append(np.full((n,), cid, dtype=np.int16))
        row_of_list.append(np.arange(n, dtype=np.int32))

    labels = np.concatenate(labels_list, axis=0)
    groups = np.concatenate(groups_list, axis=0)
    class_of = np.concatenate(class_of_list, axis=0)
    row_of = np.concatenate(row_of_list, axis=0)

    return traces_by_class, labels, groups, class_of, row_of


def parse_args():
    p = argparse.ArgumentParser(description="Reproduce ~52% CNN result from ds16k dataset")
    p.add_argument("--dataset-root", required=True)
    p.add_argument("--run-dir", required=True)

    p.add_argument("--seed", type=int, default=7)
    p.add_argument("--feature-len", type=int, default=16384)
    p.add_argument("--baseline-samples", type=int, default=2000)

    p.add_argument("--epochs", type=int, default=20)
    p.add_argument("--batch-size", type=int, default=32)
    p.add_argument("--lr", type=float, default=1e-3)
    p.add_argument("--weight-decay", type=float, default=0.0)
    p.add_argument("--warmup-epochs", type=float, default=2.0)
    p.add_argument("--val-frac", type=float, default=0.25)
    p.add_argument("--val-size", type=int, default=10000)
    p.add_argument("--dropout", type=float, default=0.2)

    p.add_argument("--num-workers", type=int, default=8)
    p.add_argument("--expect-min-val-acc", type=float, default=0.50)
    return p.parse_args()


def main():
    args = parse_args()
    set_seed(int(args.seed))

    dataset_root = Path(args.dataset_root).expanduser().resolve()
    run_dir = Path(args.run_dir).expanduser().resolve()
    run_dir.mkdir(parents=True, exist_ok=True)

    class_names = sorted([d.name for d in dataset_root.iterdir() if d.is_dir() and d.name.startswith("expert_")])
    if len(class_names) < 2:
        raise RuntimeError("Expected expert_* directories under {}".format(dataset_root))

    traces_by_class, y_np, groups_np, class_of, row_of = build_index(dataset_root, class_names)

    # This dataset is already downsampled to feature_len.
    sample_len = int(traces_by_class[0].shape[1])
    if sample_len != int(args.feature_len):
        raise ValueError("Dataset sample length {} != --feature-len {}".format(sample_len, int(args.feature_len)))

    train_idx, val_idx, val_groups = grouped_trial_split(
        y_np,
        groups_np,
        float(args.val_frac),
        int(args.seed),
        val_size=int(args.val_size),
    )

    train_ds = PackedFeatureDataset(
        traces_by_class=traces_by_class,
        labels=y_np,
        class_of=class_of,
        row_of=row_of,
        indices=train_idx,
        baseline_samples=int(args.baseline_samples),
    )
    val_ds = PackedFeatureDataset(
        traces_by_class=traces_by_class,
        labels=y_np,
        class_of=class_of,
        row_of=row_of,
        indices=val_idx,
        baseline_samples=int(args.baseline_samples),
    )

    nw = int(args.num_workers)
    train_loader = DataLoader(
        train_ds,
        batch_size=int(args.batch_size),
        shuffle=True,
        num_workers=nw,
        pin_memory=True,
        persistent_workers=(nw > 0),
    )
    train_eval_loader = DataLoader(
        train_ds,
        batch_size=int(args.batch_size),
        shuffle=False,
        num_workers=nw,
        pin_memory=True,
        persistent_workers=(nw > 0),
    )
    val_loader = DataLoader(
        val_ds,
        batch_size=int(args.batch_size),
        shuffle=False,
        num_workers=nw,
        pin_memory=True,
        persistent_workers=(nw > 0),
    )

    device = "cuda" if torch.cuda.is_available() else "cpu"
    model = CNN1DClassifier(input_dim=int(args.feature_len) * 2, num_classes=len(class_names), dropout=float(args.dropout)).to(device)

    opt = torch.optim.Adam(model.parameters(), lr=float(args.lr), weight_decay=float(args.weight_decay))
    crit = nn.CrossEntropyLoss()

    total_steps = max(1, int(args.epochs) * max(1, len(train_loader)))
    warmup_steps = int(max(0.0, float(args.warmup_epochs)) * max(1, len(train_loader)))

    def lr_at_step(step: int) -> float:
        base_lr = float(args.lr)
        if warmup_steps > 0 and step < warmup_steps:
            return base_lr * float(step + 1) / float(max(1, warmup_steps))
        progress = float(step - warmup_steps) / float(max(1, total_steps - warmup_steps))
        progress = min(max(progress, 0.0), 1.0)
        return base_lr * (0.5 * (1.0 + math.cos(math.pi * progress)))

    best_state = None
    best_val = -1.0
    best_epoch = 0
    best_loss = float("inf")
    history = []
    global_step = 0

    for epoch in range(1, int(args.epochs) + 1):
        model.train()
        epoch_loss = 0.0
        seen = 0

        t_ep = time.time()
        for xb, yb in train_loader:
            xb = xb.to(device, non_blocking=True)
            yb = yb.to(device, non_blocking=True)

            lr_now = lr_at_step(global_step)
            for pg in opt.param_groups:
                pg["lr"] = lr_now

            opt.zero_grad(set_to_none=True)
            logits = model(xb)
            loss = crit(logits, yb)
            loss.backward()
            opt.step()

            global_step += 1
            epoch_loss += float(loss.item()) * xb.shape[0]
            seen += int(xb.shape[0])

        train_acc, _, _ = evaluate(model, train_eval_loader, device)
        val_acc, _, _ = evaluate(model, val_loader, device)

        mean_loss = epoch_loss / max(1, seen)
        history.append({
            "epoch": int(epoch),
            "loss": float(mean_loss),
            "train_acc": float(train_acc),
            "val_acc": float(val_acc),
            "lr": float(opt.param_groups[0]["lr"]),
            "epoch_sec": float(time.time() - t_ep),
        })

        print(
            "[train] epoch={:03d} loss={:.4f} train_acc={:.3f} val_acc={:.3f} lr={:.2e} t={:.1f}s".format(
                epoch,
                mean_loss,
                train_acc,
                val_acc,
                float(opt.param_groups[0]["lr"]),
                history[-1]["epoch_sec"],
            ),
            flush=True,
        )

        improved_val = val_acc > (best_val + 1e-12)
        tie_better_loss = abs(val_acc - best_val) <= 1e-12 and mean_loss < (best_loss - 1e-12)
        if improved_val or tie_better_loss:
            best_val = float(val_acc)
            best_loss = float(mean_loss)
            best_epoch = int(epoch)
            best_state = {k: v.detach().cpu().clone() for k, v in model.state_dict().items()}

    if best_state is not None:
        model.load_state_dict(best_state)

    train_acc, ytr, ptr = evaluate(model, train_eval_loader, device)
    val_acc, yva, pva = evaluate(model, val_loader, device)

    cm_train = confusion_matrix_np(ytr, ptr, len(class_names))
    cm_val = confusion_matrix_np(yva, pva, len(class_names))

    torch.save(
        {
            "state_dict": model.state_dict(),
            "model_type": "cnn",
            "input_dim": int(args.feature_len) * 2,
            "class_names": class_names,
            "feature_len": int(args.feature_len),
            "baseline_samples": int(args.baseline_samples),
            "source_dataset_root": str(dataset_root),
        },
        run_dir / "classifier.pt",
    )

    metrics = {
        "created_at": datetime.now().isoformat(),
        "source_dataset": str(dataset_root),
        "class_names": class_names,
        "dataset": {
            "num_samples": int(len(y_np)),
            "feature_dim": int(args.feature_len) * 2,
            "train_size": int(len(train_idx)),
            "val_size": int(len(val_idx)),
            "split": {
                "mode": "grouped_trial",
                "val_groups": [int(g) for g in val_groups],
                "val_group_count": int(len(val_groups)),
                "val_size_actual": int(len(val_idx)),
                "val_size_target": int(args.val_size),
                "chance_acc": float(1.0 / max(1, len(class_names))),
            },
        },
        "hyperparams": {
            "model": "cnn",
            "preprocess_mode": "curr",
            "baseline_mode": "meanstd",
            "feature_len": int(args.feature_len),
            "baseline_samples": int(args.baseline_samples),
            "epochs": int(args.epochs),
            "batch_size": int(args.batch_size),
            "lr": float(args.lr),
            "optimizer": "adam",
            "weight_decay": float(args.weight_decay),
            "lr_scheduler": "cosine",
            "warmup_epochs": float(args.warmup_epochs),
            "seed": int(args.seed),
            "val_size": int(args.val_size),
            "split_mode": "grouped_trial",
            "cnn_norm": "batch",
            "cnn_dropout": float(args.dropout),
            "cnn_bn_track_running_stats": True,
        },
        "results": {
            "train_acc": float(train_acc),
            "val_acc": float(val_acc),
            "best_val_acc": float(best_val),
            "best_epoch": int(best_epoch),
            "cm_train": cm_train.tolist(),
            "cm_val": cm_val.tolist(),
            "history": history,
        },
    }

    with open(run_dir / "train_metrics.json", "w") as f:
        json.dump(metrics, f, indent=2)

    print("[done] run_dir=", run_dir, flush=True)
    print("[done] best_val_acc={:.6f} at epoch {}".format(float(best_val), int(best_epoch)), flush=True)

    if float(args.expect_min_val_acc) > 0.0 and float(best_val) < float(args.expect_min_val_acc):
        raise SystemExit(
            "Best val_acc {:.6f} below expected minimum {:.6f}".format(
                float(best_val), float(args.expect_min_val_acc)
            )
        )


if __name__ == "__main__":
    main()