import os
os.environ["TOKENIZERS_PARALLELISM"] = "false"

import io
import json
import logging
from datetime import datetime
from pathlib import Path

import torch
import torch.nn as nn
from torch.optim import AdamW
from torch.optim.lr_scheduler import CosineAnnealingLR
from torch.utils.data import DataLoader
from tqdm import tqdm
import webdataset as wds

from torchvision.transforms.functional import normalize, rgb_to_grayscale
import torchvision.transforms.functional as TF
from timm.data.constants import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD
import random
import numpy as np
from torchmetrics.classification import (
    MultilabelAveragePrecision,
    MultilabelAUROC,
    MultilabelF1Score,
)
from torchmetrics.classification import BinaryCalibrationError

from convnext3 import ConvNeXt3 
logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
logger = logging.getLogger(__name__)

import albumentations as A  # type: ignore
import cv2 # type: ignore
from PIL import Image

def train_transform(size=512):
    return A.Compose([
        A.RandomResizedCrop(size=(size, size), scale=(0.9, 1.0), p=1.0),
        A.HorizontalFlip(p=0.5),
        A.RandomBrightnessContrast(p=0.5),
    ])


def val_transform(size=224):
    return A.Compose([A.Resize(size, size, interpolation=cv2.INTER_LANCZOS4)])

train_aug = train_transform(512)
val_aug = val_transform(512)

def decode_and_transform(sample, is_train=True):
    try:
        img_bytes = sample["img"]
        y = torch.load(io.BytesIO(sample["cls"]))

        # Decode using OpenCV (more tolerant than PIL)
        img_np = cv2.imdecode(
            np.frombuffer(img_bytes, np.uint8),
            cv2.IMREAD_COLOR
        )

        if img_np is None:
            pass

        img_np = cv2.cvtColor(img_np, cv2.COLOR_BGR2RGB)

        if is_train:
            out = train_aug(image=img_np)["image"]
        else:
            out = val_aug(image=img_np)["image"]

        x = torch.from_numpy(out).permute(2, 0, 1).float() / 255.0
        return x, y

    except Exception as e:
        # Returning None tells WebDataset to drop this sample
        return None


# def load_checkpoint(
#     model, ckpt_path: str, noise_std: float = 0.01, device: str = "cpu"
# ):
#     """
#     Loads ConvNeXt2 checkpoint into ConvNeXt3 with strict=True by:
#       - copying matching keys from old checkpoint
#       - initializing new MoE params:
#           * extra experts copied from base expert weights + Gaussian noise
#           * routers already initialized small (we still put them in state_dict to satisfy strict)
#     """
#     old = torch.load(ckpt_path, map_location=device)
#     new = model.state_dict()

#     merged = {}

#     # 1) copy what exists
#     for k, v in new.items():
#         if k in old:
#             merged[k] = old[k].to(v.dtype)
#         else:
#             merged[k] = v  # default init (will override for expert params below)

#     # 2) initialize MoE extra experts from base expert weights + noise
#     # ConvNeXt MoE blocks: copy from pwconv1/pwconv2
#     for k in list(merged.keys()):
#         if ".moe_mlp.extra_experts." in k:
#             # Example key:
#             # stages.3.0.moe_mlp.extra_experts.2.fc1.weight
#             prefix = k.split(".moe_mlp.extra_experts.")[0]  # stages.3.0
#             if ".fc1." in k:
#                 base_k = prefix + ".pwconv1.weight" if k.endswith("weight") else prefix + ".pwconv1.bias"
#             elif ".fc2." in k:
#                 base_k = prefix + ".pwconv2.weight" if k.endswith("weight") else prefix + ".pwconv2.bias"
#             else:
#                 base_k = None

#             if base_k is not None and base_k in merged:
#                 base = merged[base_k]
#                 noise = torch.randn_like(merged[k]) * (noise_std * base.std().clamp(min=1e-8))
#                 merged[k] = base.clone().detach() + noise

#         if ".moe_ffn_ca.extra_experts." in k:
#             # Decoder MoE FFN experts: copy from ffn_ca
#             # ffn_ca is Sequential: [0]=Linear(d->ff), [3]=Linear(ff->d)
#             prefix = k.split(".moe_ffn_ca.extra_experts.")[0]  # head.decoder_layers.0
#             if ".fc1." in k:
#                 base_k = prefix + ".ffn_ca.0.weight" if k.endswith("weight") else prefix + ".ffn_ca.0.bias"
#             elif ".fc2." in k:
#                 base_k = prefix + ".ffn_ca.3.weight" if k.endswith("weight") else prefix + ".ffn_ca.3.bias"
#             else:
#                 base_k = None

#             if base_k is not None and base_k in merged:
#                 base = merged[base_k]
#                 noise = torch.randn_like(merged[k]) * (noise_std * base.std().clamp(min=1e-8))
#                 merged[k] = base.clone().detach() + noise

#     # 3) load strictly
#     model.load_state_dict(merged, strict=True)
#     return model



def create_model(num_classes: int = 30):
    model = ConvNeXt3(
        depths=[3, 3, 27, 3, 2],
        dims=[128, 256, 512, 1024, 1024],
        num_classes=num_classes,
        moe_n_experts=4,
    )

    path = "/root/disk_3tb/Padchest_dataset/checkpoint1/Model_20260121_215228/model_best.pth"

    state = torch.load(path, map_location="cpu")

    if isinstance(state, dict) and "state_dict" in state:
        state = state["state_dict"]
    elif isinstance(state, dict) and "model" in state:
        state = state["model"]

    model.load_state_dict(state, strict=True)

    print(f"Model created with {sum(p.numel() for p in model.parameters()):,} parameters.")
    return model



def set_params(model: ConvNeXt3):
    # Freeze everything first
    for p in model.parameters():
        p.requires_grad = False

    # ---- Train full decoder head (including queries) ----
    for p in model.head.parameters():
        p.requires_grad = True
    if hasattr(model.head, "query_embed") and model.head.query_embed is not None:
        model.head.query_embed.requires_grad_(True)

    # ---- Unfreeze MoE + LN/gamma in last 2 stages (stage 4 & 5) ----
    for si in (3, 4):
        for blk in model.stages[si]:
            # MoE params
            if hasattr(blk, "moe_mlp"):
                for p in blk.moe_mlp.parameters():
                    p.requires_grad = True
            # LN affine
            if hasattr(blk, "norm"):
                for p in blk.norm.parameters():
                    p.requires_grad = True
            # gamma LayerScale
            if hasattr(blk, "gamma") and blk.gamma is not None:
                blk.gamma.requires_grad_(True)

    for blk in model.stages[4]:
        for p in blk.parameters():
            p.requires_grad = True

    if hasattr(model, "downsample_layers") and len(model.downsample_layers) >= 5:
        for p in model.downsample_layers[4].parameters():
            p.requires_grad = True

    if hasattr(model, "pos_encoding"):
        for p in getattr(model.pos_encoding, "parameters", lambda: [])():
            p.requires_grad = True




class AsymmetricLoss(nn.Module):
    def __init__(self, gamma_neg=4.0, gamma_pos=1.0, clip=0.05, eps=1e-8,
                 disable_torch_grad_focal_loss=True, reduction="mean"):
        super().__init__()
        assert reduction in ("mean", "sum", "none")
        self.gamma_neg = gamma_neg
        self.gamma_pos = gamma_pos
        self.clip = clip
        self.eps = eps
        self.disable_torch_grad_focal_loss = disable_torch_grad_focal_loss
        self.reduction = reduction

    def forward(self, x, y):
        y = y.float()

        x_sigmoid = torch.sigmoid(x)
        xs_pos = x_sigmoid
        xs_neg = 1.0 - x_sigmoid

        if self.clip is not None and self.clip > 0:
            xs_neg = (xs_neg + self.clip).clamp(max=1.0)

        los_pos = y * torch.log(xs_pos.clamp(min=self.eps))
        los_neg = (1.0 - y) * torch.log(xs_neg.clamp(min=self.eps))
        loss = los_pos + los_neg  # log-likelihood

        if self.gamma_neg > 0 or self.gamma_pos > 0:
            if self.disable_torch_grad_focal_loss:
                with torch.no_grad():
                    pt = xs_pos * y + xs_neg * (1.0 - y)
                    gamma = self.gamma_pos * y + self.gamma_neg * (1.0 - y)
                    w = (1.0 - pt).pow(gamma)
            else:
                pt = xs_pos * y + xs_neg * (1.0 - y)
                gamma = self.gamma_pos * y + self.gamma_neg * (1.0 - y)
                w = (1.0 - pt).pow(gamma)

            loss = loss * w

        loss = -loss  # convert to positive loss

        if self.reduction == "mean":
            return loss.mean()
        if self.reduction == "sum":
            return loss.sum()
        return loss

class EarlyStopping:
    def __init__(self, patience: int = 10, mode: str = "max", min_delta: float = 0.0):
        assert mode in ("min", "max")
        self.patience = patience
        self.mode = mode
        self.min_delta = min_delta
        self.best = None
        self.bad_epochs = 0

    def step(self, value: float) -> bool:
        """Return True if improved, False otherwise."""
        if self.best is None:
            self.best = value
            self.bad_epochs = 0
            return True

        improved = (value > self.best + self.min_delta) if self.mode == "max" else (value < self.best - self.min_delta)
        if improved:
            self.best = value
            self.bad_epochs = 0
            return True

        self.bad_epochs += 1
        return False

    @property
    def should_stop(self) -> bool:
        return self.bad_epochs >= self.patience


def preprocess_batch(x: torch.Tensor) -> torch.Tensor:
    """
    x: [B, 3, H, W] (RGB tensor)
    returns: [B, 3, H, W] grayscale replicated to 3 channels
    """
    # # Convert RGB → grayscale (keeps channel dim)
    # x = rgb_to_grayscale(x, num_output_channels=1)  # [B,1,H,W]

    # Normalize
    x = normalize(x, mean=IMAGENET_DEFAULT_MEAN, std=IMAGENET_DEFAULT_STD)
    return x


class Trainer:
    def __init__(self, cfg: dict):
        self.cfg = cfg
        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        logger.info(f"Device: {self.device}")

        self.model = create_model(cfg["num_classes"]).to(self.device)
        set_params(self.model)
        print(f"Trainable parameters: {sum(p.numel() for p in self.model.parameters() if p.requires_grad):,}")

        trainable = [p for p in self.model.parameters() if p.requires_grad]
        self.optim = AdamW(trainable, lr=cfg["lr"], weight_decay=cfg["weight_decay"])
        self.sched = CosineAnnealingLR(self.optim, T_max=cfg["epochs"])
        self.crit = AsymmetricLoss(gamma_neg=2.0, gamma_pos=0.0, clip=0.05, reduction="mean")


        C = cfg["num_classes"]
        self.map = MultilabelAveragePrecision(num_labels=C, average="macro").to(self.device)
        self.auc = MultilabelAUROC(num_labels=C, average="macro").to(self.device)
        self.f1  = MultilabelF1Score(num_labels=C, average="macro", threshold=0.5).to(self.device)
        self.ece = BinaryCalibrationError(n_bins=15, norm="l1").to(self.device)
        self.scaler = None

        self.history = {
            "train_loss": [], "val_loss": [], "lr": [],
            "mAP": [], "mAUC": [], "mF1": [], "mECE": [],
            "best_epoch": None, "best_metric": None,
        }

        # Early stopping config
        self.monitor = cfg.get("monitor", "mAP")     # one of: "mAP", "mAUC", "mF1", "mECE", "val_loss"
        self.patience = cfg.get("patience", 10)

        if self.monitor == "val_loss":
            self.es = EarlyStopping(patience=self.patience, mode="min", min_delta=cfg.get("min_delta", 0.0))
        elif self.monitor == "mECE":
            self.es = EarlyStopping(patience=self.patience, mode="min", min_delta=cfg.get("min_delta", 0.0))
        else:
            self.es = EarlyStopping(patience=self.patience, mode="max", min_delta=cfg.get("min_delta", 0.0))

    @staticmethod
    def _save_json(obj, path):
        with open(path, "w") as f:
            json.dump(obj, f, indent=2)

    def _save_best(self, out_dir: str):
        os.makedirs(out_dir, exist_ok=True)
        torch.save(self.model.state_dict(), os.path.join(out_dir, "model_best.pth"))
        self._save_json(self.history, os.path.join(out_dir, "history.json"))
        logger.info(f"Saved BEST checkpoint to: {out_dir}")

    def _save_epoch(self, out_dir: str, epoch: int):
        os.makedirs(out_dir, exist_ok=True)
        torch.save(self.model.state_dict(), os.path.join(out_dir, f"final_model.pth"))
        logger.info(f"Saved checkpoint for epoch {epoch} to: {out_dir}")

    # def _normalize(self, x: torch.Tensor) -> torch.Tensor:
    #     return normalize(x, mean=IMAGENET_DEFAULT_MEAN, std=IMAGENET_DEFAULT_STD)

    def train_one_epoch(self, loader, epoch: int) -> float:
        self.model.train()
        running = 0.0

        pbar = tqdm(loader, desc=f"Train {epoch}/{self.cfg['epochs']}", leave=False)
        for step, (x, y) in enumerate(pbar, start=1):
            x = preprocess_batch(x.to(self.device, non_blocking=True))
            y = y.to(self.device, non_blocking=True)
            if not torch.is_floating_point(y):
                y = y.float()

            self.optim.zero_grad(set_to_none=True)
            logits = self.model(x)
            loss = self.crit(logits, y)
            moe_aux = getattr(self.model, "last_aux_loss", None)
            if moe_aux is not None:
                loss = loss + 0.0008 * moe_aux

            loss.backward()
            self.optim.step()

            running += float(loss.item())
            pbar.set_postfix(loss=f"{loss.item():.4f}", lr=f"{self.sched.get_last_lr()[0]:.2e}")

            if step % self.cfg["log_every"] == 0:
                logger.info(f"[Epoch {epoch} Step {step}] train_loss(avg)={running/step:.4f} last_loss={loss.item():.4f} moe_aux={moe_aux.item() if moe_aux is not None else 0.0:.4f}")

        return running / max(1, step)

    @torch.no_grad()
    def evaluate(self, loader, epoch: int):
        self.model.eval()
        self.map.reset(); self.auc.reset(); self.f1.reset(); self.ece.reset()

        running = 0.0
        pbar = tqdm(loader, desc=f"Eval  {epoch}/{self.cfg['epochs']}", leave=False)
        for step, (x, y) in enumerate(pbar, start=1):
            x = preprocess_batch(x.to(self.device, non_blocking=True))
            y = y.to(self.device, non_blocking=True)
            if not torch.is_floating_point(y):
                y = y.float()

            logits = self.model(x)
            loss = self.crit(logits, y)
            running += float(loss.item())

            probs = torch.sigmoid(logits)
            y_int = (y > 0.5).int()
            self.map.update(probs, y_int)
            self.auc.update(probs, y_int)
            self.f1.update(probs, y_int)
            self.ece.update(probs.reshape(-1), y_int.reshape(-1))

        val_loss = running / max(1, step)
        metrics = {
            "mAP": float(self.map.compute().item()),
            "mAUC": float(self.auc.compute().item()),
            "mF1": float(self.f1.compute().item()),
            "mECE": float(self.ece.compute().item()),
        }
        return val_loss, metrics

    def fit(self, train_loader):
        os.makedirs(self.cfg["out_dir"], exist_ok=True)

        max_steps = self.cfg.get("max_steps", None)
        assert max_steps is not None, "max_steps must be set for iteration-based training"

        global_step = 0
        epoch = 0

        logger.info(f"Training will stop after {max_steps} iterations.")

        while True:
            epoch += 1
            self.model.train()

            pbar = tqdm(train_loader, desc=f"Train epoch {epoch}", leave=False)

            for x, y in pbar:
                global_step += 1

                x = preprocess_batch(x.to(self.device, non_blocking=True))
                y = y.to(self.device, non_blocking=True)
                if not torch.is_floating_point(y):
                    y = y.float()

                self.optim.zero_grad(set_to_none=True)

                logits = self.model(x)
                loss = self.crit(logits, y)

                moe_aux = getattr(self.model, "last_aux_loss", None)
                if moe_aux is not None:
                    loss = loss + self.cfg.get("moe_lambda", 0.001) * moe_aux

                loss.backward()
                self.optim.step()

                pbar.set_postfix(
                    step=global_step,
                    loss=f"{loss.item():.4f}",
                    lr=f"{self.sched.get_last_lr()[0]:.2e}",
                )

                if global_step % self.cfg["log_every"] == 0:
                    logger.info(
                        f"[Step {global_step}] loss={loss.item():.4f} "
                        f"moe_aux={moe_aux.item() if moe_aux is not None else 0.0:.4f}"
                    )

                # ---- HARD STOP ----
                if global_step >= max_steps:
                    logger.info(f"Reached max_steps={max_steps}. Saving checkpoint and exiting.")

                    torch.save(
                        self.model.state_dict(),
                        os.path.join(self.cfg["out_dir"], f"model_step_{global_step}.pth")
                    )

                    return  # EXIT IMMEDIATELY

            self.sched.step()




def seed_everything(seed: int):
    os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":4096:8" 
    # os.environ["PYTHONHASHSEED"] = str(seed)

    random.seed(seed)
    np.random.seed(seed)

    torch.manual_seed(seed)
    torch.cuda.manual_seed(seed)
    torch.cuda.manual_seed_all(seed)

    torch.backends.cudnn.deterministic = False
    torch.backends.cudnn.benchmark = True

    # Enforce deterministic algorithms (will error if an op has no det. impl)
    torch.use_deterministic_algorithms(False)


def make_webdataset(train_dir: str, val_dir: str):
    train_shards = sorted(Path(train_dir).glob("shard_*.tar"))
    val_shards   = sorted(Path(val_dir).glob("shard_*.tar"))

    uri_train = ["file:" + p.resolve().as_posix() for p in train_shards]
    uri_val   = ["file:" + p.resolve().as_posix() for p in val_shards]

    logger.info(f"Train shards: {len(uri_train)} | Val shards: {len(uri_val)}")

    train_ds = (
    wds.WebDataset(uri_train, shardshuffle=True)
    .shuffle(32)
    .map(lambda s: decode_and_transform(s, is_train=True))
    .select(lambda x: x is not None)
    )

    val_ds = (
        wds.WebDataset(uri_val, shardshuffle=True)
        .map(lambda s: decode_and_transform(s, is_train=False))
        .select(lambda x: x is not None)
    )

    return train_ds, val_ds


def main():
    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
    cfg = {
        "num_classes": 30,
        # "ckpt_path": "MedViT_base_im1k.pth",
        "lr": 5e-6,
        "weight_decay": 1e-3,
        "epochs": 3,
        "train_only": True,          # <- NEW
        "save_after_epoch": 1,         
        "patience": 1,        
        "min_delta": 0.0,
        "monitor": "mAP",     
        "batch_size": 32,
        "num_workers": 6,
        "log_every": 500,
        "out_dir": f"./checkpoint1/Model_{ts}",
        "train_shards_dir": "./wds_shards_train_raw",
        "val_shards_dir": "./wds_shards_val_raw",
        "max_steps": 700,
    }

    train_ds, val_ds = make_webdataset(cfg["train_shards_dir"], cfg["val_shards_dir"])

    SEED = 42

    seed_everything(SEED)
    g_torch = torch.Generator()
    g_torch.manual_seed(SEED)

    train_loader = DataLoader(train_ds, batch_size=cfg["batch_size"], num_workers=cfg["num_workers"], pin_memory=True, 
                              generator=g_torch, persistent_workers=True, prefetch_factor=2)
    val_loader   = DataLoader(val_ds,   batch_size=cfg["batch_size"], num_workers=2, pin_memory=True)

    trainer = Trainer(cfg)
    trainer.fit(train_loader)


if __name__ == "__main__":
    main()
