#!/usr/bin/env python3
"""Fetch current registered TIFXYZ metadata and quantify UUID reuse."""

from __future__ import annotations

import argparse
import concurrent.futures
import hashlib
import json
from collections import Counter, defaultdict
from datetime import datetime, timezone
from pathlib import Path

import requests


HTTPS_ROOT = "https://vesuvius-challenge-open-data.s3.amazonaws.com/"


def fetch(root: dict) -> dict:
    url = HTTPS_ROOT + root["prefix"] + "meta.json"
    response = requests.get(url, timeout=60)
    response.raise_for_status()
    metadata = response.json()
    return {
        "sample": root["sample"],
        "segment": root["segment"],
        "artifact": root["artifact"],
        "prefix": root["prefix"],
        "url": url,
        "sha256": hashlib.sha256(response.content).hexdigest(),
        "metadata": metadata,
    }


def run(manifest_path: Path, output: Path, workers: int) -> None:
    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
    with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as pool:
        records = list(pool.map(fetch, manifest["roots"]))
    uuid_counts = Counter(str(item["metadata"].get("uuid")) for item in records)
    by_artifact = defaultdict(Counter)
    scales = defaultdict(Counter)
    keysets = defaultdict(Counter)
    for item in records:
        artifact = item["artifact"]
        metadata = item["metadata"]
        by_artifact[artifact][str(metadata.get("uuid"))] += 1
        scales[artifact][json.dumps(metadata.get("scale"), separators=(",", ":"))] += 1
        keysets[artifact][",".join(sorted(metadata))] += 1

    pairs = defaultdict(dict)
    for item in records:
        pairs[(item["sample"], item["segment"])][item["artifact"]] = item
    paired = [value for value in pairs.values() if set(value) == {"tifxyz_original", "tifxyz_normalized"}]
    normalized_literal_pairs = 0
    source_specific_original_pairs = 0
    for pair in paired:
        normalized_uuid = str(pair["tifxyz_normalized"]["metadata"].get("uuid"))
        original_uuid = str(pair["tifxyz_original"]["metadata"].get("uuid"))
        normalized_literal_pairs += normalized_uuid == "output_tifxyz"
        source_specific_original_pairs += original_uuid not in {"None", "output_tifxyz"}

    result = {
        "schema_version": "1.0",
        "generated_at": datetime.now(timezone.utc).isoformat(),
        "manifest_sha256": hashlib.sha256(manifest_path.read_bytes()).hexdigest(),
        "observations": {
            "registered_roots": len(records),
            "distinct_uuid_values": len(uuid_counts),
            "uuid_counts_top20": uuid_counts.most_common(20),
            "uuid_counts_by_artifact": {
                key: value.most_common() for key, value in sorted(by_artifact.items())
            },
            "scale_counts_by_artifact": {
                key: value.most_common() for key, value in sorted(scales.items())
            },
            "metadata_keysets_by_artifact": {
                key: value.most_common() for key, value in sorted(keysets.items())
            },
            "paired_original_normalized_segments": len(paired),
            "pairs_with_normalized_uuid_output_tifxyz": normalized_literal_pairs,
            "pairs_with_source_specific_original_uuid": source_specific_original_pairs,
        },
        "source_inference": {
            "claim": (
                "The normalized metadata fingerprint is consistent with Villa's "
                "vc_obj2tifxyz_legacy defaults: scale 1/20 = 0.05 and UUID copied "
                "from the temporary output-directory basename. This does not prove "
                "that a private workflow invoked that executable."
            ),
            "public_source_locations": {
                "legacy_default_step_and_scale": "volume-cartographer/apps/src/vc_obj2tifxyz_legacy.cpp",
                "legacy_uuid_from_output_basename": "volume-cartographer/apps/src/vc_obj2tifxyz_legacy.cpp",
                "shared_metadata_writer": "volume-cartographer/core/src/QuadSurface.cpp",
            },
        },
        "records": records,
    }
    output.parent.mkdir(parents=True, exist_ok=True)
    output.write_text(json.dumps(result, indent=2) + "\n", encoding="utf-8")
    print(json.dumps(result["observations"], indent=2))
    print(f"wrote {output}")


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--manifest", type=Path, required=True)
    parser.add_argument("--output", type=Path, required=True)
    parser.add_argument("--workers", type=int, default=24)
    args = parser.parse_args()
    run(args.manifest, args.output, args.workers)
    return 0


if __name__ == "__main__":
    raise SystemExit(main())