#!/usr/bin/env python3
"""Exercise pinned Label Studio YOLO label-file retention on invented judgments."""

import ast
from collections import defaultdict
from copy import deepcopy
from datetime import datetime
from hashlib import sha256
import io
import itertools
import json
import logging
import os
from pathlib import Path
import re
from tempfile import TemporaryDirectory
from types import SimpleNamespace
from typing import Optional
from urllib.request import urlopen


REVISION = "c20c899aaaa302740dacd46a47e5774bb677561f"
SOURCE = (
    "https://raw.githubusercontent.com/HumanSignal/label-studio-sdk/"
    f"{REVISION}/src/label_studio_sdk/converter/"
)
SOURCES = {
    "converter.py": (57_809, "1531673019c44e9b94e8e3826f880ddc677f7c835565dc4e82fe2baa463a9204"),
    "utils.py": (22_844, "cd54ec4833d50bbdf288400165ff40d5d87597a85f947404ae2e172140a961e3"),
    "keypoints.py": (5_104, "374d3df1c9034afeb3a3fa44633c2f424fbd6c75cbc8f8196f21aaff15eb1d5f"),
    "exports/yolo.py": (6_666, "c7865b7a72982e90db7452c74558309fe4665182c0d5404c829c69c1134e0c09"),
}


def read_source(name):
    size, digest = SOURCES[name]
    with urlopen(SOURCE + name, timeout=12) as response:
        raw = response.read(size + 1)
    if len(raw) != size or sha256(raw).hexdigest() != digest:
        raise ValueError(f"Pinned source changed for {name}")
    return ast.parse(raw, filename=name)


def select_functions(nodes, names):
    selected = [node for node in nodes if isinstance(node, ast.FunctionDef) and node.name in names]
    if {node.name for node in selected} != names:
        raise ValueError(f"Missing pinned functions in {names}")
    return selected


def load_converter():
    tree = read_source("converter.py")
    converter, = (
        node for node in tree.body if isinstance(node, ast.ClassDef) and node.name == "Converter"
    )
    converter.body = select_functions(converter.body, {
        "iter_from_json_file", "_maybe_matching_tag_from_schema", "annotation_result_from_task",
        "get_data", "_check_format", "_get_labels", "convert_to_yolo",
    })
    helpers = select_functions(
        read_source("utils.py").body, {"get_json_root_type", "convert_annotation_to_yolo"}
    )
    helpers += select_functions(read_source("keypoints.py").body, {"keypoints_in_label_config"})
    helpers += select_functions(read_source("exports/yolo.py").body, {"process_and_save_yolo_annotations"})
    namespace = {
        "Format": SimpleNamespace(YOLO="YOLO"),
        "Optional": Optional,
        "datetime": datetime,
        "defaultdict": defaultdict,
        "deepcopy": deepcopy,
        "ensure_dir": lambda path: Path(path).mkdir(parents=True, exist_ok=True),
        "io": io,
        "itertools": itertools,
        "json": json,
        "logger": logging.getLogger(__name__),
        "os": os,
        "re": re,
    }
    module = ast.Module(body=helpers + [converter], type_ignores=[])
    exec(compile(module, "pinned-yolo-converter-slice", "exec"), namespace)
    instance = namespace["Converter"]()
    instance.is_keypoints = False
    instance._data_keys = ["image"]
    instance._schema = {"box": {"type": "RectangleLabels", "labels": ["A", "B"], "labels_attrs": {}}}
    return instance


def annotation(identifier, actor, minute, label):
    result = [] if label is None else [{
        "from_name": "box",
        "original_width": 100,
        "original_height": 100,
        "value": {"rectanglelabels": [label], "x": 0, "y": 25, "width": 25, "height": 25},
    }]
    return {
        "id": identifier,
        "completed_by": actor,
        "created_at": f"2026-01-01T00:{minute:02}:00Z",
        "result": result,
    }


def export_case(converter, image, case_dir, annotations, split_labelers):
    case_dir.mkdir()
    source = case_dir / "task.json"
    source.write_text(json.dumps({
        "id": 7,
        "data": {"image": str(image)},
        "annotations": annotations,
    }))
    projection = list(converter.iter_from_json_file(str(source)))
    destination = case_dir / "yolo"
    options = {"split_labelers": True} if split_labelers else {}
    converter.convert_to_yolo(str(source), str(destination), is_dir=False, **options)
    labels = destination / "labels"
    return {
        "split_labelers": split_labelers,
        "input_annotation_ids": [value["id"] for value in annotations],
        "converter_annotation_order": [value["annotation_id"] for value in projection],
        "classes": (destination / "classes.txt").read_text().splitlines(),
        "label_files": {
            str(path.relative_to(labels)): path.read_text().splitlines()
            for path in sorted(labels.rglob("*.txt"))
        },
    }


def main():
    converter = load_converter()
    older = annotation(101, 11, 1, "A")
    newer = annotation(102, 12, 2, "B")
    cases = (
        ("default_input_order", [older, newer], False),
        ("default_reversed_input", [newer, older], False),
        ("default_swapped_times", [annotation(101, 11, 2, "A"), annotation(102, 12, 1, "B")], False),
        ("split_distinct_actors", [older, newer], True),
        ("split_same_actor", [older, annotation(102, 11, 2, "B")], True),
        ("default_older_empty", [annotation(101, 11, 1, None), newer], False),
    )
    with TemporaryDirectory(prefix="sapien1-yolo-retention-") as folder:
        root = Path(folder)
        image = root / "sample.pgm"
        image.write_text("P2\n1 1\n255\n0\n")
        results = {
            name: export_case(converter, image, root / name, rows, split)
            for name, rows, split in cases
        }

    row_a = ["0 0.125 0.375 0.25 0.25"]
    row_b = ["1 0.125 0.375 0.25 0.25"]
    expected = {
        "default_input_order": {"sample.txt": row_a},
        "default_reversed_input": {"sample.txt": row_a},
        "default_swapped_times": {"sample.txt": row_b},
        "split_distinct_actors": {"11/sample.txt": row_a, "12/sample.txt": row_b},
        "split_same_actor": {"11/sample.txt": row_a},
        "default_older_empty": {"sample.txt": row_b},
    }
    if any(result["classes"] != ["A", "B"] for result in results.values()):
        raise ValueError("Class ordering changed in the fixture")
    if any(results[name]["label_files"] != files for name, files in expected.items()):
        raise ValueError("YOLO label files differ from the expected retention outcomes")
    if any(result["converter_annotation_order"] != ([101, 102] if name == "default_swapped_times" else [102, 101])
           for name, result in results.items()):
        raise ValueError("Creation-time ordering changed in the fixture")
    print(json.dumps({
        "sdk_revision": REVISION,
        "sources": {name: {"bytes": size, "sha256": digest} for name, (size, digest) in SOURCES.items()},
        "cases": results,
    }, indent=2))


if __name__ == "__main__":
    main()
