from __future__ import annotations

import json
import random
from contextlib import nullcontext
from pathlib import Path

import torch
from PIL import Image
from torch.nn import functional as F
from torch.utils.data import DataLoader

from .checkpoints import load_checkpoint, save_checkpoint
from .data import ImageDataset, TrainingDataset, load_manifest, pseudo_split
from .losses import nt_xent
from .models import DINOEncoder, SSLModel
from .retrieval import rank_embeddings, rankings, retrieval_metrics, validate_rankings, write_submission
from .transforms import TrainTransforms, deterministic_degrade, inference_transform


@torch.inference_mode()
def encode(model, records, batch_size, device, transform=inference_transform):
    loader = DataLoader(ImageDataset(records, transform), batch_size=batch_size, shuffle=False)
    ids, batches = [], []
    model.eval()
    for batch_ids, images in loader:
        ids.extend(batch_ids)
        batches.append(model(images.to(device)).cpu())
    return ids, torch.cat(batches)


@torch.inference_mode()
def evaluate_pseudo(model, train_manifest, data_root, batch_size, device, seed=42):
    records = load_manifest(train_manifest, data_root)
    _, gallery, query_pairs = pseudo_split(records, seed)
    query_records = []
    query_tensors = []
    for order, (record, degradation_seed) in enumerate(query_pairs):
        query_records.append(f"pseudo_q_{order:04d}")
        with Image.open(record.path) as image:
            query_tensors.append(inference_transform(deterministic_degrade(image, degradation_seed)))
    gallery_ids, gallery_features = encode(model, gallery, batch_size, device)
    query_features = []
    for start in range(0, len(query_tensors), batch_size):
        query_features.append(model(torch.stack(query_tensors[start:start + batch_size]).to(device)).cpu())
    _, indices = rank_embeddings(torch.cat(query_features), gallery_features)
    predictions = rankings(query_records, gallery_ids, indices)
    truth = {query_records[i]: record.image_id for i, (record, _) in enumerate(query_pairs)}
    return retrieval_metrics(predictions, truth)


def train(args):
    random.seed(args.seed)
    torch.manual_seed(args.seed)
    if torch.cuda.is_available():
        torch.cuda.manual_seed_all(args.seed)
    device = torch.device(args.device)
    records = load_manifest(args.train_manifest, args.data_root)
    training, _, _ = pseudo_split(records, args.seed)
    dataset = TrainingDataset(training, args.method, TrainTransforms())
    loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=True, drop_last=args.method in {"simclr", "joint"})
    model = SSLModel(args.method, pretrained=not args.from_scratch).to(device)
    optimizer = torch.optim.AdamW(model.parameters(), lr=args.lr, weight_decay=1e-4)
    scaler = torch.amp.GradScaler("cuda", enabled=device.type == "cuda")
    best = -1.0
    config = {key: value for key, value in vars(args).items() if key != "handler"}
    for epoch in range(1, args.epochs + 1):
        model.train()
        total = 0.0
        for sample in loader:
            optimizer.zero_grad(set_to_none=True)
            amp = torch.autocast("cuda", dtype=torch.float16) if device.type == "cuda" else nullcontext()
            with amp:
                loss = torch.zeros((), device=device)
                if args.method in {"simclr", "joint"}:
                    loss = loss + args.contrastive_weight * nt_xent(model.project(sample["view1"].to(device)), model.project(sample["view2"].to(device)), args.temperature)
                if args.method in {"autoencoder", "joint"}:
                    loss = loss + args.reconstruction_weight * F.mse_loss(model.reconstruct(sample["degraded"].to(device)), sample["clean"].to(device))
                if args.method in {"rotation", "joint"}:
                    loss = loss + args.rotation_weight * F.cross_entropy(model.predict_rotation(sample["rotated"].to(device)), sample["rotation_label"].to(device))
            scaler.scale(loss).backward()
            scaler.step(optimizer)
            scaler.update()
            total += float(loss.detach())
        metrics = evaluate_pseudo(model.encoder, args.train_manifest, args.data_root, args.batch_size, device, args.seed)
        print(json.dumps({"epoch": epoch, "loss": total / len(loader), **metrics}))
        if metrics["score"] > best:
            best = metrics["score"]
            save_checkpoint(args.output, model, args.method, config, epoch, metrics)


def load_encoder(method, checkpoint, device):
    if method == "dino":
        return DINOEncoder().eval().to(device)
    if not checkpoint:
        raise ValueError(f"--checkpoint is required for {method}")
    model, _ = load_checkpoint(checkpoint, device)
    if model.method != method:
        raise ValueError(f"Checkpoint method is {model.method}, not {method}")
    return model.encoder.eval()


def evaluate(args):
    device = torch.device(args.device)
    model = load_encoder(args.method, args.checkpoint, device)
    print(json.dumps(evaluate_pseudo(model, args.train_manifest, args.data_root, args.batch_size, device, args.seed), indent=2))


def retrieve(args):
    device = torch.device(args.device)
    model = load_encoder(args.method, args.checkpoint, device)
    gallery = load_manifest(args.gallery, args.data_root)
    queries = load_manifest(args.queries, args.data_root)
    gallery_ids, gallery_features = encode(model, gallery, args.batch_size, device)
    query_ids, query_features = encode(model, queries, args.batch_size, device)
    _, indices = rank_embeddings(query_features, gallery_features)
    predictions = rankings(query_ids, gallery_ids, indices)
    validate_rankings(predictions, query_ids, gallery_ids)
    write_submission(predictions, args.output)
    print(f"saved {args.output}")