import hashlib
import json
import random
from collections import Counter
from pathlib import Path

import pyarrow.parquet as pq
from huggingface_hub import hf_hub_download
from alea.genbase import emit, q_choice, validate_row, write_jsonl

ROOT = Path("/root/alea/external/data/train")
SOURCES = {
    "nvidia/Nemotron-RL-Agentic-Conversational-Tool-Use-Pivot-v1": 5000,
    "nvidia/Nemotron-RL-Agentic-Function-Calling-Pivot-v1": 3500,
    "nvidia/Nemotron-SFT-Agentic-v2": 6000,
    "nvidia/Open-SWE-Traces": 6000,
}
MAX_OPTIONS = 12
MAX_PER_TRAJECTORY = 2


def decode_json(value):
    if not isinstance(value, str):
        return value
    try:
        return json.loads(value)
    except Exception:
        return value


def state_for(rec):
    raw = rec.get("state") or {}
    history = raw.get("history") or []
    messages = []
    for h in history[-3:]:
        payload = decode_json(h.get("payload_json"))
        if isinstance(payload, (dict, list)):
            text = json.dumps(payload, ensure_ascii=False)
            payload = payload if len(text) <= 700 else text[:700]
        elif isinstance(payload, str):
            payload = payload[:700]
        messages.append({"role": h.get("role"), "content": payload})
    env = decode_json(raw.get("environment_json"))
    if isinstance(env, (dict, list)) and len(json.dumps(env, ensure_ascii=False)) > 1000:
        env = json.dumps(env, ensure_ascii=False)[:1000]
    elif isinstance(env, str):
        env = env[:1000]
    state = {"system": (raw.get("system") or "")[:1000],
             "user_goal": (raw.get("user_goal") or "")[:1800],
             "history": messages,
             "environment": env}
    while messages and len(json.dumps(state, ensure_ascii=False)) > 5200:
        messages.pop(0)
        state["history"] = messages
    if len(json.dumps(state, ensure_ascii=False)) > 5200:
        state["user_goal"] = state["user_goal"][:1200]
    return state


def candidate_text(c):
    name = (c.get("name") or c.get("id") or "action").strip()
    desc = (c.get("description") or "").strip().replace("\n", " ")[:220]
    params = decode_json(c.get("parameters_json")) or {}
    props = params.get("properties", {}) if isinstance(params, dict) else {}
    required = params.get("required", []) if isinstance(params, dict) else []
    fields = []
    for k in list(props)[:8]:
        fields.append(k + (" (required)" if k in required else ""))
    suffix = (" Inputs: " + ", ".join(fields)) if fields else ""
    return f"{name}: {desc}{suffix}".strip()


def convert(rec, idx, seen_content, trajectory_counts, expected_split="train"):
    source = rec.get("source", "")
    training = rec.get("training") or {}
    if rec.get("decision_type") != "tool_choice":
        return None
    if not training.get("choice_eligible") or not training.get("use_for_bc"):
        return None
    if rec.get("training_split") != expected_split:
        return None
    target = rec.get("target") or {}
    target_id = target.get("candidate_id")
    candidates = rec.get("candidates") or []
    if not target_id or not 2 <= len(candidates) <= MAX_OPTIONS:
        return None
    cand_ids = [c.get("id") for c in candidates]
    if len(set(cand_ids)) != len(cand_ids) or target_id not in cand_ids:
        return None
    opts = [candidate_text(c) for c in candidates]
    if len(set(opts)) != len(opts):
        return None
    target_index = cand_ids.index(target_id)
    order = list(range(len(opts)))
    random.shuffle(order)
    opts = [opts[i] for i in order]
    target_index = order.index(target_index)
    group = source + ":" + str((rec.get("provenance") or {}).get("trajectory_id") or rec.get("id"))
    if trajectory_counts[group] >= MAX_PER_TRAJECTORY:
        return None
    state = state_for(rec)
    question = "Given the system instructions, user goal, recent history, and current environment, which available action should be taken next?"
    q = q_choice("action", question, opts,
                 [1.0 if i == target_index else 0.0 for i in range(len(opts))])
    row = emit("jevdec_" + source.split("/")[-1].replace("-", "_"), idx,
               state, [q])
    row["id"] = "jevdec-" + str(rec.get("id", idx))
    row["provenance"] = {
        "dataset": "samatv256/jev-decisions-v1",
        "source": source,
        "source_config": (rec.get("provenance") or {}).get("source_config"),
        "trajectory_id": group,
        "decision_ordinal": (rec.get("provenance") or {}).get("decision_ordinal"),
        "quality_weight": training.get("quality_weight"),
        "supervision_evidence": training.get("supervision_evidence"),
    }
    validate_row(row)
    fingerprint = hashlib.sha256((json.dumps(state,sort_keys=True,ensure_ascii=False)
                                  + json.dumps(row["questions"],sort_keys=True,ensure_ascii=False)).encode()).hexdigest()
    if fingerprint in seen_content:
        return None
    seen_content.add(fingerprint)
    trajectory_counts[group] += 1
    return row


def process(path, expected_split, quotas, seed):
    rng = random.Random(seed)
    pf = pq.ParquetFile(path)
    needed = ["id", "source", "decision_type", "state", "candidates", "target",
              "provenance", "training", "training_split"]
    chosen = {s: [] for s in quotas}
    seen, trajectory_counts = set(), Counter()
    row_index = 0
    rgs = list(range(pf.metadata.num_row_groups))
    rng.shuffle(rgs)
    for rg in rgs:
        batch = pf.read_row_group(rg, columns=needed).to_pylist()
        for rec in batch:
            source = rec.get("source", "")
            if source not in quotas or len(chosen[source]) >= quotas[source]:
                row_index += 1
                continue
            if rec.get("training_split") != expected_split:
                row_index += 1
                continue
            row = convert(rec, row_index, seen, trajectory_counts, expected_split)
            if row is not None:
                chosen[source].append(row)
            row_index += 1
        if all(len(chosen[s]) >= quotas[s] for s in quotas):
            break
    return chosen


def main():
    random.seed(20260923)
    val_path = hf_hub_download(
        "samatv256/jev-decisions-v1",
        "data/validation/validation-00000-of-00001.parquet",
        repo_type="dataset", local_dir="/root/alea/external")
    train_paths = [ROOT / f"train-{i:05d}-of-00011.parquet" for i in (0, 1, 9, 10)]
    train_quotas = {
        "nvidia/Nemotron-RL-Agentic-Conversational-Tool-Use-Pivot-v1": 5000,
        "nvidia/Nemotron-RL-Agentic-Function-Calling-Pivot-v1": 3500,
        "nvidia/Nemotron-SFT-Agentic-v2": 6000,
        "nvidia/Open-SWE-Traces": 6000,
    }
    # Route canonical shard ranges by source. These are verified from the source column.
    train_rows, seen, traj_counts, idx = [], set(), Counter(), 0
    quotas_left = dict(train_quotas)
    ranges = [
        (train_paths[0], [(0, 136, "nvidia/Nemotron-RL-Agentic-Conversational-Tool-Use-Pivot-v1"),
                          (136, 146, "nvidia/Nemotron-RL-Agentic-Function-Calling-Pivot-v1"),
                          (146, 2392, "nvidia/Nemotron-SFT-Agentic-v2")]),
        (train_paths[1], [(0, 2365, "nvidia/Nemotron-SFT-Agentic-v2")]),
        (train_paths[2], [(0, 2407, "nvidia/Open-SWE-Traces")]),
        (train_paths[3], [(0, 45, "nvidia/Open-SWE-Traces")]),
    ]
    rng = random.Random(20260923)
    for path, source_ranges in ranges:
        pf = pq.ParquetFile(path)
        groups = []
        for lo, hi, src in source_ranges:
            rgs = list(range(lo, min(hi, pf.metadata.num_row_groups)))
            rng.shuffle(rgs)
            groups.extend((rg, src) for rg in rgs)
        for rg, expected_source in groups:
            if quotas_left.get(expected_source, 0) <= 0:
                continue
            batch = pf.read_row_group(rg, columns=["id", "source", "decision_type", "state", "candidates", "target", "provenance", "training", "training_split"]).to_pylist()
            for rec in batch:
                idx += 1
                if rec.get("source") != expected_source or rec.get("training_split") != "train":
                    continue
                if rec.get("training", {}).get("choice_eligible") is not True or rec.get("training", {}).get("use_for_bc") is not True:
                    continue
                row = convert(rec, idx, seen, traj_counts)
                if row is None:
                    continue
                train_rows.append(row)
                quotas_left[expected_source] -= 1
        if not any(quotas_left.values()):
            break
    if any(quotas_left.values()):
        print("quota shortfall", quotas_left)
    # Validation split is sampled from the official group-disjoint validation partition.
    val_quotas = {s: min(500, max(100, q // 10)) for s, q in train_quotas.items()}
    val_chosen = process(val_path, "val", val_quotas, 20260924)
    val_rows = [r for src in val_quotas for r in val_chosen[src]]
    train_groups = {r["provenance"]["trajectory_id"] for r in train_rows}
    val_rows = [r for r in val_rows if r["provenance"]["trajectory_id"] not in train_groups]
    # Drop exact train/dev input collisions, retaining train.
    train_fps = {hashlib.sha256((json.dumps(r["state"],sort_keys=True,ensure_ascii=False)+json.dumps(r["questions"],sort_keys=True,ensure_ascii=False)).encode()).hexdigest() for r in train_rows}
    val_rows = [r for r in val_rows if hashlib.sha256((json.dumps(r["state"],sort_keys=True,ensure_ascii=False)+json.dumps(r["questions"],sort_keys=True,ensure_ascii=False)).encode()).hexdigest() not in train_fps]
    write_jsonl(train_rows,"data/jevdec_train_v2.jsonl")
    write_jsonl(val_rows,"data/jevdec_validation_v2.jsonl")
    print("train",len(train_rows),Counter(r["provenance"]["source"] for r in train_rows))
    print("validation",len(val_rows),Counter(r["provenance"]["source"] for r in val_rows))
    print("trajectory overlap",len(train_groups & {r["provenance"]["trajectory_id"] for r in val_rows}))


if __name__ == "__main__":
    main()