import os
import cv2
import torch
import numpy as np
import pandas as pd

from torch.utils.data import Dataset, DataLoader
from torchvision import transforms
from pytorchvideo.models.resnet import create_resnet

import torch.nn as nn
import torch.optim as optim
from tqdm import tqdm

# =========================
# CONFIG
# =========================
NUM_FRAMES = 16
IMG_SIZE = 112
BATCH_SIZE = 8
EPOCHS = 20
LR = 5e-5

DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("🚀 Using device:", DEVICE)

# =========================
# DATASET
# =========================
class AirLettersDataset(Dataset):
    def __init__(self, csv_path, video_dir):
        self.df = pd.read_csv(csv_path)
        self.df.columns = self.df.columns.str.strip()
        self.video_dir = video_dir

        self.transform = transforms.Compose([
            transforms.ToPILImage(),
            transforms.Resize((IMG_SIZE, IMG_SIZE)),   # ✅ no cropping issues
            transforms.RandomHorizontalFlip(p=0.3),
            transforms.RandomRotation(10),
            transforms.ToTensor(),
            transforms.Normalize([0.45]*3, [0.225]*3)
        ])

    def __len__(self):
        return len(self.df)

    def get_label(self, label):
        label = label.lower().strip()

        try:
            if "letter" in label:
                char = label.split("letter")[1].strip()[0]
                return ord(char.upper()) - ord('A')

            elif "digit" in label:
                digit = label.split("digit")[1].strip()[0]
                return 26 + int(digit)

            elif "doing nothing" in label:
                return 36

            else:
                return 37
        except:
            return 37

    def load_video(self, path):
        cap = cv2.VideoCapture(path)

        if not cap.isOpened():
            return None

        total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
        if total == 0:
            cap.release()
            return None

        indices = np.linspace(0, total - 1, NUM_FRAMES).astype(int)
        frames = []

        for idx in indices:
            cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
            ret, frame = cap.read()

            if ret and frame is not None:
                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
                frames.append(self.transform(frame))

        cap.release()

        if len(frames) == 0:
            return None

        while len(frames) < NUM_FRAMES:
            frames.append(frames[-1])

        return torch.stack(frames).permute(1, 0, 2, 3)

    def __getitem__(self, idx):
        for _ in range(5):
            row = self.df.iloc[idx]
            video_path = os.path.join(self.video_dir, row['filename'])

            video = self.load_video(video_path)

            if video is not None:
                label = self.get_label(row['label'])
                return video, label

            idx = (idx + 1) % len(self.df)

        raise RuntimeError("Too many bad videos")


# =========================
# MAIN
# =========================
def main():

    train_csv = "train.csv"
    val_csv   = "val.csv"
    test_csv  = "test.csv"
    video_dir = "videos"

    train_set = AirLettersDataset(train_csv, video_dir)
    val_set   = AirLettersDataset(val_csv, video_dir)
    test_set  = AirLettersDataset(test_csv, video_dir)

    train_loader = DataLoader(train_set, batch_size=BATCH_SIZE, shuffle=True, num_workers=4, pin_memory=True)
    val_loader   = DataLoader(val_set, batch_size=BATCH_SIZE, shuffle=False, num_workers=4, pin_memory=True)
    test_loader  = DataLoader(test_set, batch_size=BATCH_SIZE, shuffle=False, num_workers=4, pin_memory=True)

    # =========================
    # MODEL
    # =========================
    model = create_resnet(
        input_channel=3,
        model_depth=101,
        model_num_class=38
    ).to(DEVICE)

    # =========================
    # LOAD PRETRAINED
    # =========================
    if os.path.exists("resnext200_airletters.pth"):
        print("📦 Loading pretrained weights...")

        state_dict = torch.load("resnext200_airletters.pth", map_location=DEVICE)
        model_dict = model.state_dict()

        filtered_dict = {k: v for k, v in state_dict.items()
                         if k in model_dict and model_dict[k].shape == v.shape}

        model_dict.update(filtered_dict)
        model.load_state_dict(model_dict)

        print("✅ Pretrained loaded safely")

    # =========================
    # TRAIN SETUP
    # =========================
    criterion = nn.CrossEntropyLoss(label_smoothing=0.1)
    optimizer = optim.Adam(model.parameters(), lr=LR)

    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=EPOCHS)
    scaler = torch.cuda.amp.GradScaler()

    best_acc = 0

    # =========================
    # TRAIN LOOP
    # =========================
    for epoch in range(EPOCHS):

        model.train()
        correct, total, loss_sum = 0, 0, 0

        loop = tqdm(train_loader, desc=f"🔥 Epoch {epoch+1}/{EPOCHS}")

        for videos, labels in loop:
            videos, labels = videos.to(DEVICE), labels.to(DEVICE)

            optimizer.zero_grad()

            # ✅ AMP
            with torch.cuda.amp.autocast():
                outputs = model(videos)
                loss = criterion(outputs, labels)

            scaler.scale(loss).backward()
            scaler.step(optimizer)
            scaler.update()

            loss_sum += loss.item()

            _, preds = torch.max(outputs, 1)
            correct += (preds == labels).sum().item()
            total += labels.size(0)

            acc = 100 * correct / total
            loop.set_postfix(loss=f"{loss.item():.4f}", acc=f"{acc:.2f}%")

        scheduler.step()

        train_acc = 100 * correct / total
        print(f"\n📈 Train Acc: {train_acc:.2f}%")

        # =========================
        # VALIDATION
        # =========================
        model.eval()
        val_correct, val_total = 0, 0

        with torch.no_grad():
            for videos, labels in val_loader:
                videos, labels = videos.to(DEVICE), labels.to(DEVICE)

                outputs = model(videos)
                _, preds = torch.max(outputs, 1)

                val_correct += (preds == labels).sum().item()
                val_total += labels.size(0)

        val_acc = 100 * val_correct / val_total
        print(f"🎯 Validation Acc: {val_acc:.2f}%")

        # ✅ Save best model
        if val_acc > best_acc:
            best_acc = val_acc
            torch.save(model.state_dict(), "best_model.pth")
            print("🏆 Best model saved!")

    # =========================
    # TEST
    # =========================
    model.eval()
    test_correct, test_total = 0, 0

    with torch.no_grad():
        for videos, labels in test_loader:
            videos, labels = videos.to(DEVICE), labels.to(DEVICE)

            outputs = model(videos)
            _, preds = torch.max(outputs, 1)

            test_correct += (preds == labels).sum().item()
            test_total += labels.size(0)

    print(f"\n🏆 Final Test Accuracy: {100*test_correct/test_total:.2f}%")

    torch.save(model.state_dict(), "final_model.pth")
    print("✅ Final model saved as final_model.pth")


# =========================
if __name__ == "__main__":
    main()