"""
Train Super-Resolution model (Stage 2: 1K→2K, Stage 3: 2K→4K).
Uses a diffusion-based SR approach similar to StableSR/SUPIR.
"""
import argparse
from pathlib import Path

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms
from PIL import Image
from accelerate import Accelerator
from accelerate.utils import ProjectConfiguration
from tqdm import tqdm
import wandb


class SRDataset(Dataset):
    def __init__(self, input_dir, target_dir, input_size, target_size):
        self.input_dir = Path(input_dir)
        self.target_dir = Path(target_dir)
        self.input_size = input_size
        self.target_size = target_size

        self.input_files = sorted(self.input_dir.glob("*.png"))
        self.target_files = sorted(self.target_dir.glob("*.png"))

        # Match by filename
        input_stems = {f.stem: f for f in self.input_files}
        target_stems = {f.stem: f for f in self.target_files}
        common = set(input_stems.keys()) & set(target_stems.keys())

        self.pairs = [(input_stems[s], target_stems[s]) for s in sorted(common)]
        print(f"Found {len(self.pairs)} image pairs")

        self.input_transform = transforms.Compose([
            transforms.Resize((input_size, input_size), interpolation=transforms.InterpolationMode.LANCZOS),
            transforms.ToTensor(),
            transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]),
        ])
        self.target_transform = transforms.Compose([
            transforms.Resize((target_size, target_size), interpolation=transforms.InterpolationMode.LANCZOS),
            transforms.ToTensor(),
            transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]),
        ])

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

    def __getitem__(self, idx):
        input_path, target_path = self.pairs[idx]
        input_img = Image.open(input_path).convert("RGB")
        target_img = Image.open(target_path).convert("RGB")
        return {
            "input": self.input_transform(input_img),
            "target": self.target_transform(target_img),
        }


class ResidualBlock(nn.Module):
    def __init__(self, channels):
        super().__init__()
        self.conv1 = nn.Conv2d(channels, channels, 3, padding=1)
        self.conv2 = nn.Conv2d(channels, channels, 3, padding=1)
        self.norm1 = nn.GroupNorm(8, channels)
        self.norm2 = nn.GroupNorm(8, channels)

    def forward(self, x):
        residual = x
        x = F.silu(self.norm1(self.conv1(x)))
        x = self.norm2(self.conv2(x))
        return x + residual


class SRUNet(nn.Module):
    """Simple U-Net based super-resolution model."""
    def __init__(self, in_channels=3, out_channels=3, base_channels=64, scale_factor=2):
        super().__init__()
        self.scale_factor = scale_factor

        # Encoder
        self.enc1 = nn.Sequential(
            nn.Conv2d(in_channels, base_channels, 3, padding=1),
            ResidualBlock(base_channels),
            ResidualBlock(base_channels),
        )
        self.enc2 = nn.Sequential(
            nn.Conv2d(base_channels, base_channels * 2, 3, stride=2, padding=1),
            ResidualBlock(base_channels * 2),
            ResidualBlock(base_channels * 2),
        )
        self.enc3 = nn.Sequential(
            nn.Conv2d(base_channels * 2, base_channels * 4, 3, stride=2, padding=1),
            ResidualBlock(base_channels * 4),
            ResidualBlock(base_channels * 4),
        )

        # Bottleneck
        self.bottleneck = nn.Sequential(
            ResidualBlock(base_channels * 4),
            ResidualBlock(base_channels * 4),
        )

        # Decoder
        self.dec3 = nn.Sequential(
            nn.ConvTranspose2d(base_channels * 4, base_channels * 2, 4, stride=2, padding=1),
            ResidualBlock(base_channels * 2),
            ResidualBlock(base_channels * 2),
        )
        self.dec2 = nn.Sequential(
            nn.ConvTranspose2d(base_channels * 4, base_channels, 4, stride=2, padding=1),
            ResidualBlock(base_channels),
            ResidualBlock(base_channels),
        )
        self.dec1 = nn.Sequential(
            ResidualBlock(base_channels * 2),
            ResidualBlock(base_channels),
        )

        # Upscale + output
        self.upscale = nn.Sequential(
            nn.Conv2d(base_channels, base_channels * (scale_factor ** 2), 3, padding=1),
            nn.PixelShuffle(scale_factor),
            nn.Conv2d(base_channels, out_channels, 3, padding=1),
            nn.Tanh(),
        )

    def forward(self, x):
        # Encoder
        e1 = self.enc1(x)
        e2 = self.enc2(e1)
        e3 = self.enc3(e2)

        # Bottleneck
        b = self.bottleneck(e3)

        # Decoder with skip connections
        d3 = self.dec3(b)
        d3 = torch.cat([d3, e2], dim=1)
        d2 = self.dec2(d3)
        d2 = torch.cat([d2, e1], dim=1)
        d1 = self.dec1(d2)

        # Upscale
        out = self.upscale(d1)
        return out


class PerceptualLoss(nn.Module):
    """VGG-based perceptual loss."""
    def __init__(self):
        super().__init__()
        from torchvision.models import vgg19, VGG19_Weights
        vgg = vgg19(weights=VGG19_Weights.DEFAULT).features
        self.blocks = nn.ModuleList([
            vgg[:4],   # relu1_2
            vgg[4:9],  # relu2_2
            vgg[9:18], # relu3_4
        ])
        for p in self.parameters():
            p.requires_grad = False

    def forward(self, x, target):
        loss = 0.0
        for block in self.blocks:
            x = block(x)
            with torch.no_grad():
                target = block(target)
            loss += F.l1_loss(x, target)
        return loss


def main():
    parser = argparse.ArgumentParser(description="Train SR model")
    parser.add_argument("--stage", type=int, choices=[2, 3], required=True, help="Stage 2 (1K→2K) or Stage 3 (2K→4K)")
    parser.add_argument("--input-dir", type=Path, default=None)
    parser.add_argument("--target-dir", type=Path, default=None)
    parser.add_argument("--output-dir", type=Path, default=None)
    parser.add_argument("--batch-size", type=int, default=4)
    parser.add_argument("--learning-rate", type=float, default=2e-4)
    parser.add_argument("--max-steps", type=int, default=200000)
    parser.add_argument("--save-steps", type=int, default=10000)
    parser.add_argument("--base-channels", type=int, default=64)
    parser.add_argument("--perceptual-weight", type=float, default=0.1)
    parser.add_argument("--seed", type=int, default=42)
    parser.add_argument("--use-wandb", action="store_true")
    args = parser.parse_args()

    # Set defaults based on stage
    sr_pairs_dir = Path("/home/adminuser/chungcat/data/processed/sr_pairs")
    if args.stage == 2:
        args.input_dir = args.input_dir or sr_pairs_dir / "1k_input"
        args.target_dir = args.target_dir or sr_pairs_dir / "2k_target"
        args.output_dir = args.output_dir or Path("/home/adminuser/chungcat/checkpoints/sr_stage2")
        input_size, target_size = 1024, 2048
    else:
        args.input_dir = args.input_dir or sr_pairs_dir / "2k_input"
        args.target_dir = args.target_dir or sr_pairs_dir / "4k_target"
        args.output_dir = args.output_dir or Path("/home/adminuser/chungcat/checkpoints/sr_stage3")
        input_size, target_size = 2048, 4096

    # Accelerator
    project_config = ProjectConfiguration(project_dir=str(args.output_dir))
    accelerator = Accelerator(
        mixed_precision="bf16",
        project_config=project_config,
    )

    if accelerator.is_main_process:
        args.output_dir.mkdir(parents=True, exist_ok=True)
        if args.use_wandb:
            wandb.init(project=f"sr-stage{args.stage}", config=vars(args))

    # Model
    model = SRUNet(
        in_channels=3,
        out_channels=3,
        base_channels=args.base_channels,
        scale_factor=2,
    )

    # Losses
    l1_loss = nn.L1Loss()
    perceptual_loss = PerceptualLoss()

    # Optimizer
    optimizer = torch.optim.AdamW(model.parameters(), lr=args.learning_rate, weight_decay=0.01)
    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=args.max_steps)

    # Dataset
    dataset = SRDataset(args.input_dir, args.target_dir, input_size, target_size)
    dataloader = DataLoader(
        dataset, batch_size=args.batch_size, shuffle=True,
        num_workers=8, pin_memory=True, drop_last=True,
    )

    # Prepare
    model, optimizer, dataloader, scheduler = accelerator.prepare(
        model, optimizer, dataloader, scheduler
    )
    perceptual_loss.to(accelerator.device)

    # Training
    global_step = 0
    print(f"Starting SR Stage {args.stage} training...")
    print(f"  Input: {input_size}px → Target: {target_size}px")
    print(f"  Dataset: {len(dataset)} pairs")
    print(f"  Max steps: {args.max_steps}")

    model.train()
    while global_step < args.max_steps:
        for batch in dataloader:
            if global_step >= args.max_steps:
                break

            input_imgs = batch["input"]
            target_imgs = batch["target"]

            # Forward
            pred = model(input_imgs)

            # Resize pred to match target if needed
            if pred.shape != target_imgs.shape:
                pred = F.interpolate(pred, size=target_imgs.shape[2:], mode="bilinear", align_corners=False)

            # Losses
            loss_l1 = l1_loss(pred, target_imgs)
            loss_perceptual = perceptual_loss(pred, target_imgs)
            loss = loss_l1 + args.perceptual_weight * loss_perceptual

            # Backward
            accelerator.backward(loss)
            optimizer.step()
            scheduler.step()
            optimizer.zero_grad()

            global_step += 1

            if global_step % 100 == 0 and accelerator.is_main_process:
                print(f"Step {global_step}/{args.max_steps} | L1: {loss_l1.item():.4f} | Perceptual: {loss_perceptual.item():.4f} | Total: {loss.item():.4f}")
                if args.use_wandb:
                    wandb.log({
                        "loss_l1": loss_l1.item(),
                        "loss_perceptual": loss_perceptual.item(),
                        "loss_total": loss.item(),
                        "lr": scheduler.get_last_lr()[0],
                        "step": global_step,
                    })

            if global_step % args.save_steps == 0 and accelerator.is_main_process:
                save_path = args.output_dir / f"checkpoint-{global_step}"
                save_path.mkdir(parents=True, exist_ok=True)
                torch.save(
                    accelerator.unwrap_model(model).state_dict(),
                    save_path / "model.pt",
                )
                print(f"Saved checkpoint: {save_path}")

    # Save final
    if accelerator.is_main_process:
        final_path = args.output_dir / "final"
        final_path.mkdir(parents=True, exist_ok=True)
        torch.save(
            accelerator.unwrap_model(model).state_dict(),
            final_path / "model.pt",
        )
        print(f"Training complete! Model saved to {final_path}")
        if args.use_wandb:
            wandb.finish()


if __name__ == "__main__":
    main()