#!/usr/bin/env python3
"""
Compute comprehensive dataset statistics for UnsolvedAstronomy v1.1.0 and write statistics.json.
"""
import json
from collections import Counter
from pathlib import Path

ROOT = Path(__file__).resolve().parent.parent
PROBLEMS_FILE = ROOT / "problems.json"
ARCHIVED_FILE = ROOT / "archived_problems.json"
RELATIONS_FILE = ROOT / "relations.jsonl"
SOURCES_FILE = ROOT / "source_registry.json"
STATS_ROOT = ROOT / "statistics.json"


def load_jsonl(path: Path) -> list[dict]:
    if not path.exists():
        return []
    return [json.loads(line) for line in path.open("r", encoding="utf-8") if line.strip()]


def load_json_array(path: Path) -> list[dict]:
    if not path.exists():
        return []
    return json.loads(path.read_text(encoding="utf-8"))


def compute_stats() -> dict:
    published = load_json_array(PROBLEMS_FILE)
    archived = load_json_array(ARCHIVED_FILE)
    all_problems = published + archived
    sources = load_json_array(SOURCES_FILE)
    relations = load_jsonl(RELATIONS_FILE)

    gold = [p for p in published if p.get("is_gold_seed")]

    cat_counts = Counter()
    gold_cat_counts = Counter()
    subcat_counts = Counter()
    qtype_counts = Counter()
    status_counts = Counter(p["status"] for p in all_problems)
    pub_status_counts = Counter(p["status"] for p in published)
    ev_counts = Counter(p["evidence_state"] for p in published)
    cons_counts = Counter(p["consensus_state"] for p in published)
    vmode_counts = Counter(p["verification_mode"] for p in published)
    vhor_counts = Counter(p["verification_horizon"] for p in published)
    diff_counts = Counter(p["difficulty_level"] for p in published)
    obj_counts = Counter()
    scale_counts = Counter()
    wave_counts = Counter()
    source_usage = Counter()
    cross_domain_counts = Counter()

    for p in published:
        key = f"{p['category_number']:02d}_{p['category']}"
        cat_counts[key] += 1
        if p.get("is_gold_seed"):
            gold_cat_counts[key] += 1
        subcat_counts[p["subcategory"]] += 1
        qtype_counts[p["question_type"]] += 1
        for o in p.get("object_classes", []):
            obj_counts[o] += 1
        for sc in p.get("scales", []):
            scale_counts[sc] += 1
        for w in p.get("wavelengths_and_messengers", []):
            wave_counts[w] += 1
        if p.get("sources"):
            source_usage[p["sources"][0]["source_id"]] += 1
        for cd in p.get("cross_domain_links", []):
            cross_domain_counts[cd["dataset"]] += 1

    max_src_id, max_src_cnt = source_usage.most_common(1)[0] if source_usage else ("NONE", 0)
    src_len_counts = Counter(len({s["source_id"] for s in p.get("sources", [])}) for p in published)
    total_src_links = sum(len({s["source_id"] for s in p.get("sources", [])}) for p in published)
    unique_titles = len({(p.get("title") or "").strip().lower() for p in published})
    stats = {
        "dataset_name": "UnsolvedAstronomy",
        "version": "1.1.0",
        "release_date": "2026-10-16",
        "total_records_all_statuses": len(all_problems),
        "published_problems_count": len(published),
        "unique_titles_published_count": unique_titles,
        "gold_seed_problems_count": len(gold),
        "archived_and_excluded_count": len(archived),
        "distinct_sources_count": len(sources),
        "relations_count": len(relations),
        "min_sources_per_published_problem": min(src_len_counts.keys()) if src_len_counts else 0,
        "max_sources_per_published_problem": max(src_len_counts.keys()) if src_len_counts else 0,
        "average_sources_per_published_problem": round(total_src_links / max(1, len(published)), 3),
        "sources_count_distribution_published": dict(sorted(src_len_counts.items())),
        "max_single_source_id": max_src_id,
        "max_single_source_published_count": max_src_cnt,
        "max_single_source_share_percent": round(100.0 * max_src_cnt / max(1, len(published)), 3),
        "status_distribution_all": dict(status_counts),
        "status_distribution_published": dict(pub_status_counts),
        "category_distribution_published": dict(sorted(cat_counts.items())),
        "gold_seed_category_distribution": dict(sorted(gold_cat_counts.items())),
        "subcategory_distribution_published": dict(sorted(subcat_counts.items())),
        "question_type_distribution": dict(qtype_counts.most_common()),
        "evidence_state_distribution": dict(ev_counts.most_common()),
        "consensus_state_distribution": dict(cons_counts.most_common()),
        "object_class_distribution": dict(obj_counts.most_common()),
        "scale_distribution": dict(scale_counts.most_common()),
        "wavelength_and_messenger_distribution": dict(wave_counts.most_common()),
        "verification_mode_distribution": dict(vmode_counts.most_common()),
        "verification_horizon_distribution": dict(vhor_counts.most_common()),
        "difficulty_level_distribution": dict(sorted(diff_counts.items())),
        "source_tier_distribution": dict(Counter(s.get("tier") for s in sources)),
        "source_type_distribution": dict(Counter(s.get("source_type") for s in sources)),
        "cross_domain_links_distribution": dict(cross_domain_counts),
    }

    STATS_ROOT.write_text(json.dumps(stats, indent=2) + "\n", encoding="utf-8")
    print(f"Wrote statistics to {STATS_ROOT}")
    return stats


if __name__ == "__main__":
    compute_stats()