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 convnext import ConvNeXt2, model_urls

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=224):
    return A.Compose([
        A.RandomResizedCrop(size=(size, size), scale=(0.9, 1.0), p=1.0),
        A.HorizontalFlip(p=0.5),
        A.ShiftScaleRotate(
            p=0.5
        ),
        A.OneOf([
            A.OpticalDistortion(),
            A.GridDistortion(),
            A.ElasticTransform(),
        ], p=0.2),

        A.RandomBrightnessContrast(p=0.5),
        A.OneOf([
            A.GaussNoise(),
            A.GaussianBlur(),
            A.MotionBlur(),
            A.MedianBlur(),
        ], p=0.2),
        # A.Compose([A.Resize(size, size, interpolation=cv2.INTER_LANCZOS4)])
    ])

def val_transform(size=224):
    return A.Compose([A.Resize(size, size, interpolation=cv2.INTER_LANCZOS4)])

train_aug = train_transform(384)
val_aug = val_transform(384)

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:
        return None

def create_model(
    num_classes: int = 30
):

    model = ConvNeXt2(depths=[3, 3, 27, 3, 2], 
                      dims=[128, 256, 512, 1024, 1024], 
                      num_classes=num_classes)

    # checkpoint = torch.load("/root/disk_3tb/Padchest_dataset/checkpoint3/Model_20260119_062652/model_best.pth", map_location="cpu")

    url = model_urls['convnext_base_1k']
    checkpoint = torch.hub.load_state_dict_from_url(url=url, map_location="cpu")["model"]
    remove = ['norm.weight', 'norm.bias', 'head.weight', 'head.bias']

    for k in list(checkpoint.keys()):
        if k in remove:
            del checkpoint[k]

    model.load_state_dict(checkpoint, strict=False)

    print(f"Model created with {sum(p.numel() for p in model.parameters()):,} parameters.")

    return model

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)


        self.optim = AdamW(self.model.parameters(), 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.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 _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)
            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}")

        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, val_loader):
        os.makedirs(self.cfg["out_dir"], exist_ok=True)

        best_epoch = None
        for epoch in range(1, self.cfg["epochs"] + 1):
            tr_loss = self.train_one_epoch(train_loader, epoch)
            va_loss, m = self.evaluate(val_loader, epoch)
            self.sched.step()

            # record
            self.history["train_loss"].append(tr_loss)
            self.history["val_loss"].append(va_loss)
            self.history["lr"].append(self.sched.get_last_lr()[0])
            self.history["mAP"].append(m["mAP"])
            self.history["mAUC"].append(m["mAUC"])
            self.history["mF1"].append(m["mF1"])
            self.history["mECE"].append(m["mECE"])

            logger.info(
                f"Epoch {epoch:02d}/{self.cfg['epochs']} | "
                f"train_loss={tr_loss:.4f} val_loss={va_loss:.4f} | "
                f"mAP={m['mAP']:.4f} mAUC={m['mAUC']:.4f} mF1={m['mF1']:.4f} mECE={m['mECE']:.4f}"
            )

            # early stopping monitor
            monitor_value = va_loss if self.monitor == "val_loss" else m[self.monitor]
            improved = self.es.step(monitor_value)

            if improved:
                best_epoch = epoch
                self.history["best_epoch"] = best_epoch
                self.history["best_metric"] = float(self.es.best)
                self._save_best(self.cfg["out_dir"])

            if self.es.should_stop:
                logger.info(
                    f"Early stopping triggered at epoch {epoch}. "
                    f"Best {self.monitor}={self.es.best:.4f} at epoch {best_epoch}."
                )
                break

        logger.info(f"Done. Best epoch: {self.history['best_epoch']} | Best {self.monitor}: {self.history['best_metric']}")


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 = True
    torch.backends.cudnn.benchmark = False

    # Enforce deterministic algorithms (will error if an op has no det. impl)
    torch.use_deterministic_algorithms(True)


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():
    # device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    # print(f"Using device: {device}")
    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
    cfg = {
        "num_classes": 30,
        # "ckpt_path": "MedViT_base_im1k.pth",
        "lr": 4e-5,
        "weight_decay": 1e-2,
        "epochs": 30,         
        "patience": 3,        
        "min_delta": 0.0,
        "monitor": "mAP",     
        "batch_size": 32,
        "num_workers": 8,
        "log_every": 500,
        "out_dir": f"./checkpoint_thesis/stage1_no_posenc",
        "train_shards_dir": "/root/disk_3tb/Padchest_dataset/wds_shards_val_raw",
        "val_shards_dir": "/root/disk_3tb/Padchest_dataset/wds_shards_val_raw",
    }

    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)
    val_loader   = DataLoader(val_ds,   batch_size=cfg["batch_size"], num_workers=2, pin_memory=True)

    trainer = Trainer(cfg)
    trainer.fit(train_loader, val_loader)

    # checkpoint = torch.load("/root/disk_3tb/Padchest_dataset/checkpoint3/Model_20260119_062652/model_best.pth", map_location="cpu")
    # print("checkpoint keys: ", list(checkpoint.keys()))


if __name__ == "__main__":
    main()
