#!/usr/bin/env python3
"""
Full Thatcher benchmark: CLIP ViT-L/14, SigLIP 2 Large, and DINOv2 Large.
By default, evaluates FFHQ + SFHQ, all four image roots, and ALL available
face variants (both/eo/mo plus ll/rr in gazefix roots).
Resumes completed quartet/model results from an existing CSV.

Install: pip install -U torch transformers datasets pillow
Run:     python getting_started.py
Preview: python getting_started.py --preflight-only  (also caches the dataset)
Quick:   python getting_started.py --model clip --max-per-variant 2 --fresh

Dataset partitions are downloaded and cached before GPU inference; subsequent
runs reuse the Hugging Face Hub / Datasets caches (HF_HOME, HF_HUB_CACHE,
HF_DATASETS_CACHE). No dataset streaming is used.
"""

from __future__ import annotations

import argparse
import csv
import hashlib
import io
import statistics
from collections import Counter, defaultdict
from math import acos, pi
from pathlib import Path

MODELS = {
    "CLIP ViT-L/14": "openai/clip-vit-large-patch14",
    "SigLIP 2 Large": "google/siglip2-large-patch16-256",
    "DINOv2 Large": "facebook/dinov2-large",
}
MODEL_SHORT = {
    "clip": "CLIP ViT-L/14",
    "siglip2": "SigLIP 2 Large",
    "dino": "DINOv2 Large",
}
ROOT_VARIANTS = ("original", "gazefix", "passportify", "passportify_gazefix")
BASE_VARIANTS = ("both", "eo", "mo")
MIRROR_VARIANTS = ("ll", "rr")
IMAGE_COLS = ("normal_u", "normal_i", "thatcher_u", "thatcher_i")
FIELDS = (
    "dataset_ref", "source_dataset", "root_variant", "face_variant",
    "identity", "model", "model_id", "cos_upright", "cos_inverted",
    "thatcher_excess", "angular_excess_pp",
)
SUMMARY_FIELDS = (
    "source_dataset", "root_variant", "face_variant", "model", "N",
    "cos_upright", "cos_inverted", "thatcher_excess",
    "angular_excess_pp", "pct_faces", "d_faces",
)


def expected_variants(root_variant):
    # LL/RR were generated only for the two gaze-corrected roots.
    return BASE_VARIANTS + (MIRROR_VARIANTS if "gazefix" in root_variant else ())


def decode_rgb(image_value):
    from PIL import Image

    if isinstance(image_value, Image.Image):
        return image_value.convert("RGB")
    if isinstance(image_value, dict):
        if image_value.get("bytes") is not None:
            with Image.open(io.BytesIO(image_value["bytes"])) as image:
                return image.convert("RGB")
        if image_value.get("path"):
            with Image.open(image_value["path"]) as image:
                return image.convert("RGB")
    raise TypeError(f"Unsupported image column: {type(image_value).__name__}")


def angular_distance_percent(cosine):
    """Angular distance as a percentage of the entire 180-degree range."""
    return 100.0 * acos(max(-1.0, min(1.0, cosine))) / pi


def dataset_ref(args):
    local_root = args.local_root or (
        Path(args.repo) if Path(args.repo).is_dir() else None
    )
    if local_root is None:
        return f"hub:{args.repo}"
    # CSV resume marker
    digest = hashlib.sha256(str(local_root.resolve()).encode("utf-8")).hexdigest()[:16]
    return f"local:{digest}"


def load_examples(args, source, root_variant):
    """Download/prepare once, then return a locally cached Arrow dataset."""
    from datasets import Image, load_dataset

    dataset_cache_dir = (
        str(args.dataset_cache_dir) if args.dataset_cache_dir is not None else None
    )
    local_root = args.local_root or (
        Path(args.repo) if Path(args.repo).is_dir() else None
    )
    if local_root is not None:
        folder = local_root / "data" / source / root_variant
        parquet_paths = sorted(folder.glob("*.parquet"))
        if not parquet_paths:
            raise FileNotFoundError(f"No Parquet shards under {folder}")
        ds = load_dataset(
            "parquet",
            data_files={"train": [str(path) for path in parquet_paths]},
            split="train",
            streaming=False,
            cache_dir=dataset_cache_dir,
        )
    else:
        ds = load_dataset(
            args.repo, name=f"{source}_{root_variant}",
            split="train", streaming=False, cache_dir=dataset_cache_dir,
        )

    # FIX: Dataset has no .decode(False); that API is for IterableDataset.
    # Cast the image features instead, so only selected quartets are decoded
    # by decode_rgb() during GPU inference.
    for column in IMAGE_COLS:
        if isinstance(ds.features[column], Image):
            ds = ds.cast_column(column, Image(decode=False))
    return ds


def preflight_coverage(args, sources, roots, example_sets, example_indices):
    """Cache partitions and index metadata without loading image bytes."""
    coverage = {}
    total = 0
    for source in sources:
        for root_variant in roots:
            available = expected_variants(root_variant)
            wanted = (
                available if args.face_variant == "all"
                else tuple(v for v in available if v == args.face_variant)
            )
            if not wanted:
                continue  # E.g., --face-variant ll on the original root.
            print(f"Preparing cached dataset: {source}/{root_variant}", flush=True)
            example_sets[(source, root_variant)] = load_examples(
                args, source, root_variant
            )
            counts = Counter()
            identity_sets = defaultdict(set)
            selected_indices = []
            # Select only two metadata columns: no image bytes hit Python here.
            metadata = example_sets[(source, root_variant)].select_columns(
                ["face_variant", "identity"]
            )
            for row_index, row in enumerate(metadata):
                variant = str(row["face_variant"]).lower()
                if variant not in available:
                    raise ValueError(
                        f"Unexpected face_variant={variant!r} in {source}/{root_variant}"
                    )
                if variant not in wanted:
                    continue
                if args.max_per_variant and counts[variant] >= args.max_per_variant:
                    continue
                identity = str(row["identity"])
                if identity in identity_sets[variant]:
                    raise ValueError(
                        f"Duplicate identity {identity!r}: {source}/{root_variant}/{variant}"
                    )
                identity_sets[variant].add(identity)
                counts[variant] += 1
                selected_indices.append((variant, identity, row_index))

            missing = [variant for variant in wanted if not counts[variant]]
            if missing:
                raise RuntimeError(
                    f"Missing conditions {missing}: {source}/{root_variant}"
                )
            if not args.max_per_variant and len(wanted) > 1:
                first_ids = identity_sets[wanted[0]]
                for variant in wanted[1:]:
                    if identity_sets[variant] != first_ids:
                        raise RuntimeError(
                            f"Different identity sets in {source}/{root_variant}: "
                            f"{wanted[0]} vs {variant}"
                        )
            coverage[(source, root_variant)] = {
                variant: frozenset(identity_sets[variant]) for variant in wanted
            }
            example_indices[(source, root_variant)] = selected_indices
            n = sum(counts.values())
            total += n
            print(f"{source.upper():4} / {root_variant:20}: {dict(counts)}", flush=True)
    if not coverage:
        raise RuntimeError("No matching source/root/face conditions selected")
    model_count = len(MODELS) if args.model == "all" else 1
    print(
        f"Coverage: {total} quartets per model "
        f"({total * model_count} across {model_count} selected model(s); "
        "four images each).\n",
        flush=True,
    )
    return coverage


def result_key(row):
    return tuple(str(row[name]) for name in (
        "dataset_ref", "source_dataset", "root_variant",
        "face_variant", "identity", "model_id",
    ))


def load_existing(out, fresh):
    if fresh or not out.is_file() or out.stat().st_size == 0:
        return {}
    existing = {}
    with out.open("r", newline="", encoding="utf-8-sig") as file:
        reader = csv.DictReader(file)
        if tuple(reader.fieldnames or ()) != FIELDS:
            raise RuntimeError(
                f"Existing CSV has a different schema: {out}. "
                "Use --out NEW_FILE or --fresh to start a new benchmark."
            )
        for row in reader:
            if any(row.get(field) is None for field in FIELDS):
                raise RuntimeError(f"Incomplete CSV row in {out}; inspect before resuming")
            key = result_key(row)
            if key in existing:
                raise RuntimeError(f"Duplicate checkpoint key in {out}: {key}")
            existing[key] = row
    return existing


def load_model(model_name, cache_dir, device):
    import torch
    from transformers import (
        AutoImageProcessor, AutoProcessor, CLIPModel, Dinov2Model,
        SiglipVisionModel,
    )

    cache_kwargs = {"cache_dir": str(cache_dir)} if cache_dir is not None else {}
    if model_name.startswith("openai/clip"):
        processor = AutoProcessor.from_pretrained(model_name, **cache_kwargs)
        model = CLIPModel.from_pretrained(model_name, **cache_kwargs)
        family = "clip"
    elif "siglip2" in model_name:
        # The published SigLIP 2 Large checkpoint uses the SigLIP vision
        # architecture. Loading only it avoids unused text-config defaults.
        class SiglipImageOnly(SiglipVisionModel):
            # Ignore unused keys
            _keys_to_ignore_on_load_unexpected = set(
                SiglipVisionModel._keys_to_ignore_on_load_unexpected or ()
            ) | {r"^text_model\.", r"^logit_scale$", r"^logit_bias$"}

        processor = AutoImageProcessor.from_pretrained(model_name, **cache_kwargs)
        model = SiglipImageOnly.from_pretrained(model_name, **cache_kwargs)
        family = "siglip2"
    else:
        processor = AutoImageProcessor.from_pretrained(model_name, **cache_kwargs)
        model = Dinov2Model.from_pretrained(model_name, **cache_kwargs)
        family = "dino"
    model = model.to(device).eval().float()
    return model, processor, family


def image_embeddings(model, processor, family, row, device):
    """Compute a complete normal/Thatcher upright/inverted quartet."""
    import torch
    import torch.nn.functional as F

    images = [decode_rgb(row[column]) for column in IMAGE_COLS]
    batch = processor(images=images, return_tensors="pt")
    batch = {key: value.to(device) for key, value in batch.items() if hasattr(value, "to")}
    with torch.inference_mode():
        if family == "dino":
            z = model(**batch).last_hidden_state[:, 0, :]
        elif family == "siglip2":
            # Same pooled visual embedding as SiglipModel.get_image_features().
            z = model(**batch).pooler_output
        else:
            z = model.get_image_features(**batch)
            if not isinstance(z, torch.Tensor):
                if getattr(z, "image_embeds", None) is not None:
                    z = z.image_embeds
                elif getattr(z, "pooler_output", None) is not None:
                    z = z.pooler_output
                else:
                    z = z[0]
        z = F.normalize(z.float(), dim=-1).cpu()
    if z.ndim != 2 or z.shape[0] != 4:
        raise RuntimeError(f"Expected four embeddings; got {tuple(z.shape)}")
    return float((z[0] * z[2]).sum()), float((z[1] * z[3]).sum())


def summarize(vals, source, root_variant, face_variant, model):
    upright = [float(row["cos_upright"]) for row in vals]
    inverted = [float(row["cos_inverted"]) for row in vals]
    excesses = [float(row["thatcher_excess"]) for row in vals]
    spread = statistics.stdev(excesses) if len(excesses) > 1 else 0.0
    return {
        "source_dataset": source,
        "root_variant": root_variant,
        "face_variant": face_variant,
        "model": model,
        "N": len(vals),
        "cos_upright": statistics.fmean(upright),
        "cos_inverted": statistics.fmean(inverted),
        "thatcher_excess": statistics.fmean(excesses),
        "angular_excess_pp": statistics.fmean(
            float(row["angular_excess_pp"]) for row in vals
        ),
        "pct_faces": 100.0 * sum(delta > 0 for delta in excesses) / len(excesses),
        "d_faces": (
            statistics.fmean(excesses) / spread if spread > 0 else float("nan")
        ),
    }


def write_summary(args, coverage, model_items, completed, current_ref):
    grouped = defaultdict(list)
    for (source, root_variant), variants in coverage.items():
        for face_variant, identities in variants.items():
            for model, model_id in model_items:
                for identity in identities:
                    key = (
                        current_ref, source, root_variant, face_variant,
                        identity, model_id,
                    )
                    if key not in completed:
                        raise RuntimeError(f"Missing result for {key}")
                    grouped[(source, root_variant, face_variant, model)].append(
                        completed[key]
                    )

    summary_rows = []
    for (source, root_variant), variants in coverage.items():
        print(f"\n{source.upper()} / {root_variant}")
        print(
            f"{'Model':20} {'Face':5} {'N':>3} "
            f"{'upright':>8} {'inverted':>8} {'excess':>9} "
            f"{'ang pp':>8} {'% faces':>8} {'d_faces':>8}"
        )
        for face_variant in expected_variants(root_variant):
            if face_variant not in variants:
                continue
            for model, _ in model_items:
                vals = grouped[(source, root_variant, face_variant, model)]
                row = summarize(vals, source, root_variant, face_variant, model)
                summary_rows.append(row)
                print(
                    f"{model:20} {face_variant:5} {row['N']:3d} "
                    f"{row['cos_upright']:8.4f} {row['cos_inverted']:8.4f} "
                    f"{row['thatcher_excess']:+9.4f} "
                    f"{row['angular_excess_pp']:+8.2f} "
                    f"{row['pct_faces']:8.1f} {row['d_faces']:8.2f}"
                )

    summary_out = (
        args.summary_out
        if args.summary_out is not None
        else args.out.with_name(f"{args.out.stem}_summary.csv")
    )
    summary_out.parent.mkdir(parents=True, exist_ok=True)
    with summary_out.open("w", newline="", encoding="utf-8-sig") as file:
        writer = csv.DictWriter(file, fieldnames=SUMMARY_FIELDS)
        writer.writeheader()
        writer.writerows(summary_rows)
    print(f"\nPer-quartet results: {args.out}")
    print(f"Complete summary:    {summary_out}")
    print("Cosine distributions are not calibrated across models.")
    print("Angular pp = paired extra angle / 180 deg * 100; % faces = positive excess rate.")
    print("d_faces = mean paired excess / sample SD across identities (not human accuracy).")


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--repo", default="zer0int/Thatcher_Effect_Faces")
    parser.add_argument("--local-root", type=Path, help="Local FFHQ/SFHQ Parquet export")
    parser.add_argument("--source", choices=("both", "ffhq", "sfhq"), default="both")
    parser.add_argument(
        "--root-variant", choices=("all",) + ROOT_VARIANTS, default="all"
    )
    parser.add_argument(
        "--face-variant", choices=("all",) + BASE_VARIANTS + MIRROR_VARIANTS,
        default="all",
    )
    parser.add_argument(
        "--max-per-variant", type=int, default=0,
        help="0 (default) = all quartets; positive integer = quick sample per condition",
    )
    parser.add_argument(
        "--model", choices=("all",) + tuple(MODEL_SHORT), default="all"
    )
    parser.add_argument("--device", default="auto", help="auto, cuda, cpu, ...")
    parser.add_argument(
        "--cache-dir", type=Path,
        default=None,
        help="Optional model cache override (default: Hugging Face cache settings)",
    )
    parser.add_argument(
        "--dataset-cache-dir", type=Path, default=None,
        help="Optional Arrow cache override (default: HF_DATASETS_CACHE / HF_HOME)",
    )
    parser.add_argument("--out", type=Path, default=Path("thatcher_quickstart.csv"))
    parser.add_argument("--summary-out", type=Path, default=None)
    parser.add_argument("--fresh", action="store_true", help="Overwrite output CSV and recompute")
    parser.add_argument(
        "--preflight-only", action="store_true",
        help="Check variant/identity coverage without loading any models",
    )
    args = parser.parse_args()
    if args.max_per_variant < 0:
        parser.error("--max-per-variant must be >= 0")
    if args.out == args.summary_out:
        parser.error("--out and --summary-out must be different files")

    sources = ("ffhq", "sfhq") if args.source == "both" else (args.source,)
    roots = ROOT_VARIANTS if args.root_variant == "all" else (args.root_variant,)
    # Keep these memory-mapped datasets alive and reuse them for every model.
    example_sets = {}
    example_indices = {}
    coverage = preflight_coverage(args, sources, roots, example_sets, example_indices)
    if args.preflight_only:
        return

    import torch

    device = (
        "cuda" if torch.cuda.is_available() else "cpu"
    ) if args.device == "auto" else args.device
    if device.startswith("cuda") and not torch.cuda.is_available():
        raise RuntimeError("CUDA unavailable; use --device cpu or configure CUDA")
    if args.cache_dir is not None:
        args.cache_dir.mkdir(parents=True, exist_ok=True)
    args.out.parent.mkdir(parents=True, exist_ok=True)
    completed = load_existing(args.out, args.fresh)
    current_ref = dataset_ref(args)
    model_items = (
        list(MODELS.items()) if args.model == "all"
        else [(MODEL_SHORT[args.model], MODELS[MODEL_SHORT[args.model]])]
    )

    output_exists = args.out.is_file() and args.out.stat().st_size > 0 and not args.fresh
    with args.out.open("a" if output_exists else "w", newline="", encoding="utf-8") as file:
        writer = csv.DictWriter(file, fieldnames=FIELDS)
        if not output_exists:
            writer.writeheader()
            file.flush()

        for model_label, model_id in model_items:
            required = {
                (current_ref, source, root_variant, variant, identity, model_id)
                for (source, root_variant), variants in coverage.items()
                for variant, identities in variants.items()
                for identity in identities
            }
            missing = required - completed.keys()
            if not missing:
                print(f"SKIP {model_label}: all {len(required)} quartet results already saved.")
                continue

            print(f"\nLoading {model_label} on {device}; {len(missing)} remaining quartets...", flush=True)
            model, processor, family = load_model(model_id, args.cache_dir, device)
            done = 0
            try:
                for (source, root_variant), variants in coverage.items():
                    remaining = {
                        (variant, identity)
                        for variant, identities in variants.items()
                        for identity in identities
                        if (current_ref, source, root_variant, variant, identity, model_id)
                        not in completed
                    }
                    if not remaining:
                        continue
                    for variant, identity, row_index in example_indices[(source, root_variant)]:
                        if (variant, identity) not in remaining:
                            continue
                        # Fetch image bytes only for a quartet we actually need.
                        row = example_sets[(source, root_variant)][row_index]
                        cos_upright, cos_inverted = image_embeddings(
                            model, processor, family, row, device
                        )
                        result = {
                            "dataset_ref": current_ref,
                            "source_dataset": source,
                            "root_variant": root_variant,
                            "face_variant": variant,
                            "identity": identity,
                            "model": model_label,
                            "model_id": model_id,
                            "cos_upright": cos_upright,
                            "cos_inverted": cos_inverted,
                            "thatcher_excess": cos_inverted - cos_upright,
                            "angular_excess_pp": (
                                angular_distance_percent(cos_upright)
                                - angular_distance_percent(cos_inverted)
                            ),
                        }
                        writer.writerow(result)
                        file.flush()  # Per-quartet checkpoint: interruption-safe.
                        completed[result_key(result)] = result
                        remaining.remove((variant, identity))
                        done += 1
                        if done % 20 == 0:
                            print(f"  {model_label}: {done}/{len(missing)} new quartets", flush=True)
                        if not remaining:
                            break
                    if remaining:
                        raise RuntimeError(
                            f"Preflight/compute coverage mismatch for {source}/{root_variant}: "
                            f"{len(remaining)} quartets missing"
                        )
            finally:
                del model
                if device.startswith("cuda"):
                    torch.cuda.empty_cache()
            print(f"{model_label}: finished {done} new quartets.", flush=True)

    write_summary(args, coverage, model_items, completed, current_ref)


if __name__ == "__main__":
    main()