from __future__ import annotations

import json
import random
from dataclasses import dataclass
from pathlib import Path

from PIL import Image
from torch.utils.data import Dataset


@dataclass(frozen=True)
class ImageRecord:
    image_id: str
    path: Path


def load_manifest(path: str | Path, data_root: str | Path | None = None) -> list[ImageRecord]:
    manifest = Path(path)
    root = Path(data_root) if data_root else manifest.parent
    rows = json.loads(manifest.read_text(encoding="utf-8"))
    if not isinstance(rows, list):
        raise ValueError(f"{manifest}: expected a JSON list")
    records = []
    for index, row in enumerate(rows):
        if not isinstance(row, dict) or not {"image_id", "image_path"} <= row.keys():
            raise ValueError(f"{manifest}: invalid row {index}")
        relative = Path(row["image_path"])
        candidates = (relative,) if relative.is_absolute() else (
            root / relative,
            manifest.parent / relative,
            manifest.parent.parent / relative,
            manifest.parent.parent.parent / relative,
        )
        resolved = next((candidate for candidate in candidates if candidate.is_file()), None)
        if resolved is None:
            raise FileNotFoundError(f"Cannot resolve {relative} from {manifest}")
        records.append(ImageRecord(str(row["image_id"]), resolved.resolve()))
    if len({record.image_id for record in records}) != len(records):
        raise ValueError(f"{manifest}: duplicate image IDs")
    return records


def pseudo_split(records: list[ImageRecord], seed: int = 42, gallery_size: int = 1000, query_size: int = 200):
    if len(records) < gallery_size:
        raise ValueError(f"Need at least {gallery_size} records")
    shuffled = records.copy()
    random.Random(seed).shuffle(shuffled)
    gallery = shuffled[:gallery_size]
    query_indices = random.Random(seed + 1).sample(range(gallery_size), query_size)
    queries = [(gallery[index], seed * 100_000 + order) for order, index in enumerate(query_indices)]
    return shuffled[gallery_size:], gallery, queries


class ImageDataset(Dataset):
    def __init__(self, records: list[ImageRecord], transform):
        self.records, self.transform = records, transform

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

    def __getitem__(self, index):
        record = self.records[index]
        with Image.open(record.path) as image:
            return record.image_id, self.transform(image.convert("RGB"))


class TrainingDataset(Dataset):
    def __init__(self, records: list[ImageRecord], method: str, transforms):
        self.records, self.method, self.transforms = records, method, transforms

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

    def __getitem__(self, index):
        with Image.open(self.records[index].path) as source:
            image = source.convert("RGB")
            clean = self.transforms.clean(image)
            sample = {"clean": clean}
            if self.method in {"simclr", "joint"}:
                sample["view1"] = self.transforms.contrastive(image)
                sample["view2"] = self.transforms.contrastive(image)
            if self.method in {"autoencoder", "joint"}:
                sample["degraded"] = self.transforms.degraded(image)
            if self.method in {"rotation", "joint"}:
                rotated, label = self.transforms.rotation(image)
                sample["rotated"], sample["rotation_label"] = rotated, label
            return sample