"""Package the existing public files into typed, self-contained HF tables.

Run from any directory: python scripts/build_release.py
No inference, network access, uploads, or changes to source data are performed.
"""
import hashlib
import io
import json
import re
import math
import subprocess
import tempfile
from collections import Counter
from pathlib import Path

import pyarrow as pa
import pyarrow.parquet as pq
from datasets import Features, Image as HFImage, List, Value, Video
from PIL import Image, ImageDraw


ROOT = Path(__file__).resolve().parents[1]
DATA = ROOT / "data"
OUT = ROOT / "release"
REVISION = "177436de2edfc620065134530409e1394d8672fd"
BASE_URL = f"https://huggingface.co/datasets/sprited/sprite-dx-data/resolve/{REVISION}/"


def image_bytes(path):
    return {"bytes": path.read_bytes(), "path": path.name}


def png_bytes(image, name):
    buffer = io.BytesIO()
    image.save(buffer, format="PNG")
    return {"bytes": buffer.getvalue(), "path": name}


def strip(path, start=0, end=None):
    """Static, indexed filmstrip so every HF client can display motion samples."""
    with Image.open(path) as animation:
        n = animation.n_frames
        end = n if end is None else end
        if not 0 <= start < end <= n:
            raise ValueError(f"Invalid range for {path}: {start}:{end} / {n}")
        indices = sorted({start + (end - start - 1) * i // 3 for i in range(4)})
        preview = Image.new("RGB", (160 * len(indices), 184), "#f1f3f5")
        draw = ImageDraw.Draw(preview)
        for column, index in enumerate(indices):
            animation.seek(index)
            frame = animation.convert("RGBA")
            frame.thumbnail((160, 160))
            preview.paste(frame, (column * 160 + (160 - frame.width) // 2, 0), frame)
            draw.text((column * 160 + 8, 166), f"frame {index}", fill="#20242a")
        return png_bytes(preview, path.stem + "-preview.png"), n


def video_bytes(path, start=0, end=None):
    """Browser-compatible viewing copy; original WebP and timing stay available.

    Repeat frames at the greatest common divisor of durations to preserve the
    source's millisecond timing, including variable-duration WebP frames.
    """
    frames, durations = [], []
    with Image.open(path) as animation:
        end = animation.n_frames if end is None else end
        if not 0 <= start < end <= animation.n_frames:
            raise ValueError(f"Invalid video range: {path}, {start}:{end}")
        for index in range(start, end):
            animation.seek(index)
            animation.load()
            duration = animation.info.get("duration")
            if not isinstance(duration, int) or duration <= 0:
                raise ValueError(f"Missing or invalid frame duration: {path}, {index}")
            frame = animation.convert("RGBA")
            frame.thumbnail((320, 320))
            # MP4/H.264 has no alpha: previews use a neutral background.
            background = Image.new("RGBA", frame.size, (241, 243, 245, 255))
            background.alpha_composite(frame)
            frames.append(background.convert("RGB").tobytes())
            durations.append(duration)
        width, height = frame.size
    tick = math.gcd(*durations)
    raw = b"".join(frame * (duration // tick) for frame, duration in zip(frames, durations))
    with tempfile.TemporaryDirectory(prefix="sprited-video-") as directory:
        output = Path(directory) / (path.stem + ".mp4")
        subprocess.run([
            "ffmpeg", "-v", "error", "-f", "rawvideo", "-pix_fmt", "rgb24",
            "-s", f"{width}x{height}", "-r", f"1000/{tick}", "-i", "pipe:0",
            "-an", "-vf", "pad=ceil(iw/2)*2:ceil(ih/2)*2",
            "-c:v", "libx264", "-preset", "fast", "-crf", "20",
            "-threads", "1", "-pix_fmt", "yuv420p", "-movflags", "+faststart",
            str(output),
        ], input=raw, check=True, capture_output=True)
        return {"bytes": output.read_bytes(), "path": output.name}


def matting_rows():
    for path in sorted((DATA / "expanded").rglob("*.png")):
        relative = path.relative_to(DATA / "expanded")
        match = re.fullmatch(r"(sample-\d+)-(\d+)-f(\d+)", path.stem)
        if not match:
            raise ValueError(f"Unexpected frame name: {path}")
        source, shot, frame = match.groups()
        paired = {key: DATA / folder / relative for key, folder in (
            ("image", "expanded"), ("matte", "automatte"),
            ("foreground", "fgr"), ("cutout", "masked"),
        )}
        sizes = set()
        for key, image_path in paired.items():
            with Image.open(image_path) as image:
                image.load()
                sizes.add(image.size)
                if key == "cutout" and image.mode != "RGBA":
                    raise ValueError(f"Missing alpha: {image_path}")
        if len(sizes) != 1:
            raise ValueError(f"Unaligned image sizes: {relative}")
        width, height = sizes.pop()
        yield {
            **{key: image_bytes(p) for key, p in paired.items()},
            "id": str(relative.with_suffix("")), "frame_id": path.stem,
            "source_id": source, "shot_index": int(shot), "frame_index": int(frame),
            "collection": relative.parts[0], "width": width, "height": height,
            "source_path": str(path.relative_to(ROOT)),
        }


def loop_rows():
    for path in sorted((DATA / "loops").glob("*.loop.hf.json")):
        shot_id = path.name.split(".")[0]
        annotation = json.loads(path.read_text())
        start, end_inclusive = annotation["best_cut"]
        end = end_inclusive + 1
        source, shot = shot_id.rsplit("-", 1)
        shot_path = DATA / "shots" / (shot_id + ".webp")
        preview, n = strip(shot_path, start, end)
        with Image.open(shot_path) as image:
            width, height = image.size
        yield {
            "video": video_bytes(shot_path, start, end),
            "preview": preview, "id": shot_id, "source_id": source,
            "shot_index": int(shot), "is_loop": annotation["loop"],
            "start_frame": start, "end_frame_exclusive": end,
            "num_frames": n, "width": width, "height": height,
            "animation_url": BASE_URL + str(shot_path.relative_to(ROOT)),
            "annotation_path": str(path.relative_to(ROOT)),
        }


def scene_rows():
    for path in sorted((DATA / "animations").glob("*.hf.json")):
        source = path.name.split(".")[0]
        animation_path = DATA / "animations" / (source + ".webp")
        cuts = json.loads(path.read_text())["scene_change_indices"]
        preview, n = strip(animation_path)
        if cuts != sorted(set(cuts)) or any(c < 0 or c >= n - 1 for c in cuts):
            raise ValueError(f"Invalid scene boundaries: {path}")
        with Image.open(animation_path) as image:
            width, height = image.size
        yield {
            "video": video_bytes(animation_path),
            "preview": preview, "id": source, "source_id": source,
            "num_frames": n, "width": width, "height": height,
            "scene_end_frames": cuts, "num_shots": len(cuts) + 1,
            "animation_url": BASE_URL + str(animation_path.relative_to(ROOT)),
            "annotation_path": str(path.relative_to(ROOT)),
        }


def features(images, strings, integers, extra=None):
    return Features({
        **({"video": extra["video"]} if extra and "video" in extra else {}),
        **{key: HFImage() for key in images},
        **{key: Value("string") for key in strings},
        **{key: Value("int32") for key in integers},
        **(extra or {}),
    })


SCHEMAS = {
    "matting": features(
        ["image", "matte", "foreground", "cutout"],
        ["id", "frame_id", "source_id", "collection", "source_path"],
        ["shot_index", "frame_index", "width", "height"],
    ),
    "loops": features(
        ["preview"], ["id", "source_id", "animation_url", "annotation_path"],
        ["shot_index", "start_frame", "end_frame_exclusive", "num_frames", "width", "height"],
        {"video": Video(), "is_loop": Value("bool")},
    ),
    "scene_boundaries": features(
        ["preview"], ["id", "source_id", "animation_url", "annotation_path"],
        ["num_frames", "width", "height", "num_shots"],
        {"video": Video(), "scene_end_frames": List(Value("int32"))},
    ),
}


def write_subset(name, rows):
    destination = OUT / name
    destination.mkdir(parents=True, exist_ok=True)
    if list(destination.glob("*.parquet")):
        raise RuntimeError(f"{destination} already contains a release; use a fresh output directory")
    schema = SCHEMAS[name].arrow_schema
    ids, sources, frames, labels = set(), set(), set(), Counter()
    batch, shards, count = [], [], 0

    def write_batch():
        output = destination / f"train-{len(shards):04d}.parquet"
        table = pa.Table.from_pylist(batch, schema=schema)
        pq.write_table(table, output, compression="zstd", row_group_size=32, write_page_index=True)
        shards.append({"path": str(output.relative_to(ROOT)), "rows": len(batch),
                       "bytes": output.stat().st_size,
                       "sha256": hashlib.sha256(output.read_bytes()).hexdigest()})
        batch.clear()

    for row in rows:
        if row["id"] in ids:
            raise ValueError(f"Duplicate row: {row['id']}")
        ids.add(row["id"])
        sources.add(row["source_id"])
        if "frame_id" in row:
            frames.add(row["frame_id"])
        if "is_loop" in row:
            labels[str(row["is_loop"]).lower()] += 1
        batch.append(row)
        count += 1
        if len(batch) == 200:
            write_batch()
    if batch:
        write_batch()
    print(f"{name}: {count} rows, {len(shards)} shards", flush=True)
    return {"rows": count, "source_animations": len(sources),
            "unique_frame_ids": len(frames) if frames else None,
            "loop_labels": dict(labels) if labels else None, "shards": shards}


def main():
    OUT.mkdir(exist_ok=True)
    report = {"source_revision": REVISION, "subsets": {}}
    for name, rows in (("matting", matting_rows()), ("loops", loop_rows()),
                       ("scene_boundaries", scene_rows())):
        report["subsets"][name] = write_subset(name, rows)
    (OUT / "manifest.json").write_text(json.dumps(report, indent=2) + "\n")


if __name__ == "__main__":
    main()