#!/usr/bin/env python3
'Fit and evaluate an eight-class real-image-source classifier on frozen CLIP features.'

from __future__ import annotations

import argparse
import csv
import json
import random
import sys
from collections import defaultdict
from pathlib import Path

import numpy as np
import torch
import torch.nn.functional as F
import torchvision.transforms as T
from PIL import Image
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, balanced_accuracy_score, classification_report
from torch.utils.data import DataLoader, Dataset
from tqdm import tqdm

try:
    import clip
except ImportError:
    raise ImportError("Please install clip: pip install git+https://github.com/openai/CLIP.git")


PROJECT_ROOT = Path(__file__).resolve().parents[2]
ARTIFACT_ROOT = PROJECT_ROOT / "artifacts"
DEFAULT_SPLIT_DIR = ARTIFACT_ROOT / "metadata" / "fixed_split"
CLIP_MEAN = [0.48145466, 0.4578275, 0.40821073]
CLIP_STD = [0.26862954, 0.26130258, 0.27577711]

csv.field_size_limit(min(sys.maxsize, 2_147_483_647))


class RealSourceDataset(Dataset):
    def __init__(self, rows: list[dict[str, str]], label_to_idx: dict[str, int], transform):
        self.rows = rows
        self.label_to_idx = label_to_idx
        self.transform = transform

    def __len__(self) -> int:
        return len(self.rows)

    def __getitem__(self, idx: int):
        row = self.rows[idx]
        image = Image.open(row["image_path"]).convert("RGB")
        return self.transform(image), self.label_to_idx[row["source_dataset"]]


def read_rows(path: Path) -> list[dict[str, str]]:
    with path.open("r", newline="", encoding="utf-8") as f:
        return list(csv.DictReader(f))


def sample_per_source(rows: list[dict[str, str]], per_source: int | None, seed: int) -> list[dict[str, str]]:
    grouped: dict[str, list[dict[str, str]]] = defaultdict(list)
    for row in rows:
        grouped[row["source_dataset"]].append(row)
    rng = random.Random(seed)
    selected = []
    for source in sorted(grouped):
        source_rows = list(grouped[source])
        rng.shuffle(source_rows)
        if per_source is not None:
            source_rows = source_rows[:per_source]
        selected.extend(source_rows)
    return selected


def make_transform() -> T.Compose:
    return T.Compose([
        T.Resize(int(224 * 1.15)),
        T.CenterCrop(224),
        T.ToTensor(),
        T.Normalize(CLIP_MEAN, CLIP_STD),
    ])


@torch.no_grad()
def extract_features(model, loader, device: torch.device) -> tuple[np.ndarray, np.ndarray]:
    features = []
    labels = []
    for images, y in tqdm(loader, desc="Extracting real-source features"):
        images = images.to(device)
        feat = model.encode_image(images).float()
        feat = F.normalize(feat, dim=-1)
        features.append(feat.cpu().numpy())
        labels.append(y.numpy())
    return np.concatenate(features, axis=0), np.concatenate(labels, axis=0)


def main() -> None:
    parser = argparse.ArgumentParser(description="training real-source bias control.")
    parser.add_argument("--real-train-csv", type=Path, default=DEFAULT_SPLIT_DIR / "real_train_pool.csv")
    parser.add_argument("--real-val-csv", type=Path, default=DEFAULT_SPLIT_DIR / "real_validation.csv")
    parser.add_argument("--train-per-source", type=int, default=5000)
    parser.add_argument("--val-per-source", type=int, default=1000)
    parser.add_argument("--batch-size", type=int, default=128)
    parser.add_argument("--num-workers", type=int, default=8)
    parser.add_argument("--device", type=str, default="cuda")
    parser.add_argument("--seed", type=int, default=42)
    parser.add_argument("--output", type=Path, default=ARTIFACT_ROOT / "results" / "training" / "real_source_bias_clip_logreg.json")
    args = parser.parse_args()

    random.seed(args.seed)
    np.random.seed(args.seed)
    torch.manual_seed(args.seed)
    device = torch.device(args.device if torch.cuda.is_available() else "cpu")

    train_rows = sample_per_source(read_rows(args.real_train_csv), args.train_per_source, args.seed)
    val_rows = sample_per_source(read_rows(args.real_val_csv), args.val_per_source, args.seed)
    labels = sorted({row["source_dataset"] for row in train_rows + val_rows})
    label_to_idx = {label: idx for idx, label in enumerate(labels)}
    idx_to_label = {idx: label for label, idx in label_to_idx.items()}

    model, _ = clip.load("ViT-L/14", device=device)
    model.eval()
    transform = make_transform()
    train_loader = DataLoader(
        RealSourceDataset(train_rows, label_to_idx, transform),
        batch_size=args.batch_size,
        shuffle=False,
        num_workers=args.num_workers,
        pin_memory=True,
    )
    val_loader = DataLoader(
        RealSourceDataset(val_rows, label_to_idx, transform),
        batch_size=args.batch_size,
        shuffle=False,
        num_workers=args.num_workers,
        pin_memory=True,
    )

    x_train, y_train = extract_features(model, train_loader, device)
    x_val, y_val = extract_features(model, val_loader, device)
    clf = LogisticRegression(max_iter=1000, C=1.0, solver="lbfgs")
    clf.fit(x_train, y_train)
    pred = clf.predict(x_val)

    report = classification_report(
        y_val,
        pred,
        target_names=[idx_to_label[i] for i in range(len(idx_to_label))],
        output_dict=True,
        zero_division=0,
    )
    result = {
        "seed": args.seed,
        "train_per_source": args.train_per_source,
        "val_per_source": args.val_per_source,
        "labels": idx_to_label,
        "accuracy": float(accuracy_score(y_val, pred)),
        "balanced_accuracy": float(balanced_accuracy_score(y_val, pred)),
        "classification_report": report,
    }
    args.output.parent.mkdir(parents=True, exist_ok=True)
    with args.output.open("w", encoding="utf-8") as f:
        json.dump(result, f, indent=2, ensure_ascii=False)
    print(json.dumps(result, indent=2, ensure_ascii=False))


if __name__ == "__main__":
    main()