#!/usr/bin/env python3
"""Bundle HumanCollab data into the Almanac Hugging Face release folder."""

from __future__ import annotations

import json
import shutil
from pathlib import Path
from typing import Any

ROOT = Path(__file__).resolve().parents[1]
REPO_ROOT = ROOT.parent
EXP_DATA = REPO_ROOT / "benchmark_experiment" / "exp_data"
GROUNDING_DATA = REPO_ROOT / "benchmark_experiment" / "grounding_data"
SFT_DATA = REPO_ROOT / "sft_data"

C1_TRAIN = (
    "study3", "study9", "study12", "study14", "study18",
    "study24", "study27", "study30", "study31",
)
C2_TRAIN = (
    "study2", "study4", "study6", "study10", "study11",
    "study13", "study20", "study22", "study35", "study37",
)
C1_TEST = ("study8", "study21", "study25")
C2_TEST = ("study15", "study17", "study36")

SFT_CONFIGS = (
    "follower_next_action",
    "guide_next_action",
    "follower_mental_model",
    "guide_mental_model",
)

SESSION_FILES = (
    "guide_timeline",
    "follower_timeline",
    "actions_and_annotations",
    "score_board",
)


def study_split(study: str) -> str:
    if study in C1_TRAIN or study in C2_TRAIN:
        return "train"
    if study in C1_TEST or study in C2_TEST:
        return "test"
    raise ValueError(f"Unknown study: {study}")


def list_studies(exp_root: Path) -> list[tuple[str, str]]:
    out: list[tuple[str, str]] = []
    for cond_dir in sorted(exp_root.iterdir()):
        if not cond_dir.is_dir() or not cond_dir.name.startswith("c"):
            continue
        for study_dir in sorted(cond_dir.iterdir()):
            if study_dir.is_dir() and study_dir.name.startswith("study"):
                out.append((cond_dir.name, study_dir.name))
    return out


def copy_session_files(src_study: Path, dst_study: Path) -> list[str]:
    dst_study.mkdir(parents=True, exist_ok=True)
    copied: list[str] = []
    study = src_study.name
    for kind in SESSION_FILES:
        if kind == "score_board":
            src = src_study / "score_board.txt"
            dst = dst_study / "score_board.txt"
        else:
            src = src_study / f"{study}_{kind}.json"
            dst = dst_study / f"{study}_{kind}.json"
        if src.exists():
            shutil.copy2(src, dst)
            copied.append(dst.relative_to(ROOT).as_posix())
    return copied


def flatten_timeline(
    timeline: list[dict[str, Any]],
    *,
    condition: str,
    study: str,
    role: str,
    include_grounding: bool,
) -> list[dict[str, Any]]:
    rows: list[dict[str, Any]] = []
    for idx, ev in enumerate(timeline):
        row: dict[str, Any] = {
            "condition": condition,
            "study_name": study,
            "split": study_split(study),
            "role": role,
            "timeline_index": idx,
            "timestamp": ev.get("timestamp", ""),
            "action_type": ev.get("action_type", ""),
            "action_content": ev.get("action_content", ""),
            "map_canvas": ev.get("map_canvas", ""),
            "drawing_accuracy": ev.get("drawing_accuracy", ""),
            "mental_model": json.dumps(ev.get("mental_model") or {}, ensure_ascii=False),
        }
        if include_grounding:
            row["grounding_act"] = ev.get("grounding_act", "")
            row["grounding_rationale"] = ev.get("grounding_rationale", "")
        rows.append(row)
    return rows


def write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open("w", encoding="utf-8") as f:
        for row in rows:
            f.write(json.dumps(row, ensure_ascii=False) + "\n")


def copy_sft_configs() -> dict[str, dict[str, int]]:
    stats: dict[str, dict[str, int]] = {}
    for cfg in SFT_CONFIGS:
        stats[cfg] = {}
        for split in ("train", "test"):
            src_name = "training.jsonl" if split == "train" else "test.jsonl"
            src = SFT_DATA / cfg / src_name
            dst = ROOT / "data" / "sft" / cfg / f"{split}.jsonl"
            dst.parent.mkdir(parents=True, exist_ok=True)
            shutil.copy2(src, dst)
            n = sum(1 for _ in dst.open(encoding="utf-8"))
            stats[cfg][split] = n
    return stats


def build_flat_tables(studies: list[tuple[str, str]]) -> tuple[int, int]:
    raw_rows: list[dict[str, Any]] = []
    grounding_rows: list[dict[str, Any]] = []

    for condition, study in studies:
        raw_study = ROOT / "data" / "raw_sessions" / condition / study
        g_study = ROOT / "data" / "grounding" / condition / study

        for role in ("guide", "follower"):
            raw_path = raw_study / f"{study}_{role}_timeline.json"
            if raw_path.exists():
                timeline = json.loads(raw_path.read_text(encoding="utf-8"))
                raw_rows.extend(
                    flatten_timeline(
                        timeline,
                        condition=condition,
                        study=study,
                        role=role,
                        include_grounding=False,
                    )
                )

            g_path = g_study / f"{study}_{role}.json"
            if g_path.exists():
                timeline = json.loads(g_path.read_text(encoding="utf-8"))
                grounding_rows.extend(
                    flatten_timeline(
                        timeline,
                        condition=condition,
                        study=study,
                        role=role,
                        include_grounding=True,
                    )
                )

    write_jsonl(ROOT / "data" / "raw_timeline" / "all.jsonl", raw_rows)
    write_jsonl(ROOT / "data" / "grounding_timeline" / "all.jsonl", grounding_rows)
    for split in ("train", "test"):
        write_jsonl(
            ROOT / "data" / "raw_timeline" / f"{split}.jsonl",
            [r for r in raw_rows if r["split"] == split],
        )
        write_jsonl(
            ROOT / "data" / "grounding_timeline" / f"{split}.jsonl",
            [r for r in grounding_rows if r["split"] == split],
        )
    return len(raw_rows), len(grounding_rows)


def build_studies_index(studies: list[tuple[str, str]]) -> list[dict[str, Any]]:
    index: list[dict[str, Any]] = []
    for condition, study in studies:
        meta_path = ROOT / "data" / "grounding" / condition / study / f"{study}_grounding_meta.json"
        entry: dict[str, Any] = {
            "condition": condition,
            "study_name": study,
            "split": study_split(study),
            "files": {},
        }
        if meta_path.exists():
            meta = json.loads(meta_path.read_text(encoding="utf-8"))
            entry["n_actions"] = meta.get("n_actions")
            entry["n_guide_actions"] = meta.get("n_guide_actions")
            entry["n_follower_actions"] = meta.get("n_follower_actions")
            entry["canvas_condition"] = meta.get("canvas_condition")
            entry["llm_meta"] = meta.get("llm_meta")
        study_dir = ROOT / "data" / "raw_sessions" / condition / study
        for p in sorted(study_dir.iterdir()):
            entry["files"][p.name] = f"data/raw_sessions/{condition}/{study}/{p.name}"
        g_dir = ROOT / "data" / "grounding" / condition / study
        for p in sorted(g_dir.iterdir()):
            entry.setdefault("grounding_files", {})[p.name] = (
                f"data/grounding/{condition}/{study}/{p.name}"
            )
        index.append(entry)
    return index


def build_grounding_manifest(studies: list[tuple[str, str]]) -> dict[str, Any]:
    return {
        "n_studies": len(studies),
        "llm_meta": {
            "llm_provider": "azure",
            "llm_model": "gpt-5.5",
        },
        "note": "Grounding labels were produced with the prompt in Grounding Acts Human Annotation/llm_propmt.txt",
        "studies": [
            {
                "condition": c,
                "study": s,
                "split": study_split(s),
                "paths": {
                    "guide": f"data/grounding/{c}/{s}/{s}_guide.json",
                    "follower": f"data/grounding/{c}/{s}/{s}_follower.json",
                    "meta": f"data/grounding/{c}/{s}/{s}_grounding_meta.json",
                },
            }
            for c, s in studies
        ],
    }


def main() -> None:
    studies = list_studies(EXP_DATA)
    print(f"Found {len(studies)} sessions")

    for condition, study in studies:
        src = EXP_DATA / condition / study
        dst = ROOT / "data" / "raw_sessions" / condition / study
        copy_session_files(src, dst)

        g_src = GROUNDING_DATA / condition / study
        g_dst = ROOT / "data" / "grounding" / condition / study
        if g_src.exists():
            g_dst.mkdir(parents=True, exist_ok=True)
            for f in g_src.iterdir():
                if f.is_file():
                    shutil.copy2(f, g_dst / f.name)

    sft_stats = copy_sft_configs()
    n_raw, n_ground = build_flat_tables(studies)

    split_protocol = {
        "split_unit": "study",
        "train": {"c1": list(C1_TRAIN), "c2": list(C2_TRAIN)},
        "test": {"c1": list(C1_TEST), "c2": list(C2_TEST)},
        "sft_configs": list(SFT_CONFIGS),
    }
    meta_dir = ROOT / "metadata"
    meta_dir.mkdir(parents=True, exist_ok=True)
    (meta_dir / "split_protocol.json").write_text(
        json.dumps(split_protocol, indent=2, ensure_ascii=False) + "\n",
        encoding="utf-8",
    )
    (meta_dir / "studies_index.json").write_text(
        json.dumps(build_studies_index(studies), indent=2, ensure_ascii=False) + "\n",
        encoding="utf-8",
    )
    (meta_dir / "grounding_manifest.json").write_text(
        json.dumps(build_grounding_manifest(studies), indent=2, ensure_ascii=False) + "\n",
        encoding="utf-8",
    )

    summary = {
        "n_studies": len(studies),
        "n_raw_timeline_rows": n_raw,
        "n_grounding_timeline_rows": n_ground,
        "sft": sft_stats,
    }
    (meta_dir / "bundle_summary.json").write_text(
        json.dumps(summary, indent=2, ensure_ascii=False) + "\n",
        encoding="utf-8",
    )
    print(json.dumps(summary, indent=2))


if __name__ == "__main__":
    main()