#!/usr/bin/env python3
"""
Build graph→system index for each enhanced dataset + global split assignment.

Two outputs:

1. Per-method graph→system mapping (needed to know which graph belongs to which system):
    datasets_all/{method}_system_index.json
        { "graph_to_system": ["cdk2_lig_1", ...], "systems": [...], ... }

2. Global split assignment (shared across ALL methods, generated once):
    datasets_all/system_split_assignment.json
        { "train": ["cdk2_lig_1", ...],
          "val": ["mcl1_lig_5", ...],
          "calib": ["syk_lig_10", ...],
          "test": ["cdk8_lig_3", ...],
          "seed": 42,
          "ratios": {"train": 0.70, "val": 0.10, "calib": 0.10, "test": 0.10} }

The split assignment uses the FULL system list from autodock_vina (as reference)
to ensure all 4 methods use the exact same split.

Usage:
    python build_system_index.py
"""

import os
import json
import time
from collections import defaultdict

import numpy as np
import torch
from torch_geometric.data import Data

SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))

from build_graph_unified_enhanced import load_pdb_clean_models

torch.serialization.add_safe_globals([Data])

# Data directories: siblings of system_split/
# Structure: parent_dir/system_split/ (this), parent_dir/filtered_output/, parent_dir/datasets_all/
PARENT_DIR = os.path.dirname(SCRIPT_DIR)
DATA_DIR = os.path.join(PARENT_DIR, "filtered_output")
DATASETS_DIR = os.path.join(PARENT_DIR, "datasets_all")

METHODS = {
    "autodock_vina": "autodock_vina_enhanced_graphs.pt",
    "diffdock": "diffdock_enhanced_graphs.pt",
    "medusagraph": "medusagraph_enhanced_graphs.pt",
    "protenix": "protenix_enhanced_graphs.pt",
}


def compute_fingerprint(graph):
    """(n_lig_atoms, (cx, cy, cz)) from ligand ground truth centroid."""
    is_prot = graph.is_protein.squeeze(-1)
    lig_mask = is_prot == 0
    n_lig = int(lig_mask.sum().item())
    if n_lig == 0:
        return (0, (0.0, 0.0, 0.0))
    lig_grt = graph.y_grt[lig_mask]
    centroid = lig_grt.mean(dim=0)
    return (n_lig, (round(centroid[0].item(), 2),
                    round(centroid[1].item(), 2),
                    round(centroid[2].item(), 2)))


def read_native_centroid(pdb_path):
    """Read native ligand PDB → (n_heavy_atoms, (cx, cy, cz))."""
    u = load_pdb_clean_models(pdb_path)
    atoms = u.select_atoms("not name H*")
    coords = atoms.positions.astype(np.float32)
    n = coords.shape[0]
    c = coords.mean(axis=0)
    return (n, (round(float(c[0]), 2), round(float(c[1]), 2), round(float(c[2]), 2)))


def build_fp_to_system(method_subdir):
    """Build fingerprint → system name mapping from PDB files."""
    method_dir = os.path.join(DATA_DIR, method_subdir)
    systems = sorted([d for d in os.listdir(method_dir)
                      if os.path.isdir(os.path.join(method_dir, d))])

    fp_to_system = {}
    for system in systems:
        native_path = os.path.join(method_dir, system, "ligands.pdb")
        if not os.path.exists(native_path):
            continue
        try:
            fp = read_native_centroid(native_path)
            fp_to_system[fp] = system
        except Exception:
            continue

    return fp_to_system


def match_graph_to_system(graph_fp, fp_to_system):
    """Exact match, then fuzzy match (same n_atoms, closest centroid < 0.5 Å)."""
    if graph_fp in fp_to_system:
        return fp_to_system[graph_fp]

    n_lig, (cx, cy, cz) = graph_fp
    best_dist = 999.0
    best_sys = None
    for fp, sys_name in fp_to_system.items():
        fn, (fx, fy, fz) = fp
        if fn != n_lig:
            continue
        dist = ((cx - fx)**2 + (cy - fy)**2 + (cz - fz)**2) ** 0.5
        if dist < best_dist:
            best_dist = dist
            best_sys = sys_name
    if best_dist < 0.5:
        return best_sys
    return None


def process_method(method_name, dataset_filename):
    """Build system index for one method."""
    dataset_path = os.path.join(DATASETS_DIR, dataset_filename)
    if not os.path.exists(dataset_path):
        print(f"  [SKIP] {dataset_path} not found")
        return

    print(f"\n{'='*60}")
    print(f"  {method_name}")
    print(f"{'='*60}")

    # Load dataset
    print(f"  Loading {dataset_path} ...")
    t0 = time.time()
    graphs = torch.load(dataset_path, weights_only=False)
    n = len(graphs)
    print(f"  Loaded {n} graphs in {time.time()-t0:.1f}s")

    # Build fingerprint → system mapping
    print(f"  Building fingerprint map from PDB files...")
    fp_to_system = build_fp_to_system(method_name)
    print(f"  {len(fp_to_system)} systems from PDB files")

    # Match each graph
    print(f"  Matching graphs to systems...")
    graph_to_system = []
    matched = 0
    unmatched = 0

    for i, g in enumerate(graphs):
        fp = compute_fingerprint(g)
        system = match_graph_to_system(fp, fp_to_system)
        if system:
            graph_to_system.append(system)
            matched += 1
        else:
            graph_to_system.append("UNKNOWN")
            unmatched += 1

    print(f"  Matched: {matched}/{n}, Unmatched: {unmatched}")

    # Verify: count per system
    system_counts = defaultdict(int)
    for s in graph_to_system:
        system_counts[s] += 1

    systems = sorted([s for s in system_counts.keys() if s != "UNKNOWN"])
    print(f"  Unique systems: {len(systems)}")

    counts = [system_counts[s] for s in systems]
    print(f"  Poses per system: min={min(counts)}, max={max(counts)}, "
          f"median={sorted(counts)[len(counts)//2]}")

    # Save
    index_filename = dataset_filename.replace("_enhanced_graphs.pt", "_system_index.json")
    index_path = os.path.join(DATASETS_DIR, index_filename)

    index_data = {
        "graph_to_system": graph_to_system,
        "systems": systems,
        "n_graphs": n,
        "n_systems": len(systems),
        "system_counts": dict(sorted(system_counts.items())),
    }

    with open(index_path, 'w') as f:
        json.dump(index_data, f, indent=2)
    print(f"  Saved: {index_path}")

    del graphs
    return index_data


SPLIT_SEED = 42
TRAIN_RATIO = 0.70
VAL_RATIO = 0.10
CALIB_RATIO = 0.10


def generate_split_assignment(all_systems, seed=SPLIT_SEED):
    """
    Generate a global system-level split assignment.
    Uses a canonical sorted list of all systems, shuffles with fixed seed,
    then splits 70/10/10/10.

    Returns dict with train/val/calib/test system lists.
    """
    import random as _random

    systems = sorted(all_systems)
    n = len(systems)

    rng = _random.Random(seed)
    rng.shuffle(systems)

    train_end = int(n * TRAIN_RATIO)
    val_end = train_end + int(n * VAL_RATIO)
    calib_end = val_end + int(n * CALIB_RATIO)

    assignment = {
        "train": sorted(systems[:train_end]),
        "val": sorted(systems[train_end:val_end]),
        "calib": sorted(systems[val_end:calib_end]),
        "test": sorted(systems[calib_end:]),
        "seed": seed,
        "ratios": {
            "train": TRAIN_RATIO,
            "val": VAL_RATIO,
            "calib": CALIB_RATIO,
            "test": round(1.0 - TRAIN_RATIO - VAL_RATIO - CALIB_RATIO, 2),
        },
        "n_systems": n,
        "n_train": train_end,
        "n_val": val_end - train_end,
        "n_calib": calib_end - val_end,
        "n_test": n - calib_end,
    }

    return assignment


def main():
    print("Building system indices for all datasets")
    print(f"Data dir: {DATA_DIR}")
    print(f"Datasets dir: {DATASETS_DIR}")

    all_method_systems = {}
    for method_name, dataset_filename in METHODS.items():
        result = process_method(method_name, dataset_filename)
        if result:
            all_method_systems[method_name] = result["systems"]

    # ---- Generate global split assignment ----
    # Use the full system list (intersection of all methods to be safe)
    if all_method_systems:
        common_systems = set(all_method_systems[list(all_method_systems.keys())[0]])
        for systems in all_method_systems.values():
            common_systems &= set(systems)
        common_systems = sorted(common_systems)

        print(f"\n{'='*60}")
        print(f"  Global Split Assignment")
        print(f"{'='*60}")
        print(f"  Common systems across all methods: {len(common_systems)}")

        # Check if all methods have the same systems
        for method, systems in all_method_systems.items():
            diff = set(systems) - set(common_systems)
            if diff:
                print(f"  [WARN] {method} has extra systems: {diff}")

        assignment = generate_split_assignment(common_systems)

        print(f"  Train: {assignment['n_train']} systems")
        print(f"  Val:   {assignment['n_val']} systems")
        print(f"  Calib: {assignment['n_calib']} systems")
        print(f"  Test:  {assignment['n_test']} systems")

        # Show per-target distribution in test set
        target_counts = defaultdict(int)
        for s in assignment["test"]:
            target = s.rsplit("_lig_", 1)[0]
            target_counts[target] += 1
        print(f"\n  Test set targets: {dict(sorted(target_counts.items()))}")

        assignment_path = os.path.join(DATASETS_DIR, "system_split_assignment.json")
        with open(assignment_path, 'w') as f:
            json.dump(assignment, f, indent=2)
        print(f"  Saved: {assignment_path}")

    print("\nDone!")


if __name__ == "__main__":
    main()