code/compact_v1/build_graph_unified_enhanced.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Build Graph Unified Enhanced
=============================

整合版构图脚本，用于批量处理蛋白-配体数据并构建增强版图数据集

功能:
1. 批量处理多个 docking 结果
2. 构建增强版图特征 (82维节点特征 + 4维边特征)
3. 计算预测误差标签 (y_true, y_pred, y_grt)
4. 保存为 PyTorch Geometric 格式

使用方法:
    python build_graph_unified_enhanced.py \\
        --data_dir ./docking_results \\
        --output ./datasets_x/protenix_enhanced_graphs.pt \\
        --docking_type protenix

数据目录结构 (示例):
    data_dir/
    ├── 1a30/
    │   ├── protein.pdb          # 蛋白结构
    │   ├── ligand_native.pdb    # 配体真实结构 (ground truth)
    │   ├── 1a30_pose_01.pdb     # Docking 预测 pose 1
    │   ├── 1a30_pose_02.pdb     # Docking 预测 pose 2
    │   └── ...
    ├── 1b38/
    │   └── ...
    └── ...
"""

import os
import glob
import argparse
from typing import Sequence, List, Dict, Tuple, Optional
from collections import defaultdict

import numpy as np
import torch
from torch_geometric.data import Data
import MDAnalysis as mda
from io import StringIO
from scipy.spatial.distance import cdist
from tqdm import tqdm


# =============================================================================
# 基础字典
# =============================================================================

ELEMENTS = ["C", "N", "O", "S", "P", "F", "Cl", "Br", "I", "H", "Other"]
ELEMENT2IDX = {e: i for i, e in enumerate(ELEMENTS)}

AA3 = [
    "ALA", "ARG", "ASN", "ASP", "CYS", "GLN", "GLU", "GLY", "HIS", "ILE",
    "LEU", "LYS", "MET", "PHE", "PRO", "SER", "THR", "TRP", "TYR", "VAL"
]
AA3_2IDX = {aa: i for i, aa in enumerate(AA3)}
AA_DIM = len(AA3) + 1

# 化学属性
ELECTRONEGATIVITY = {
    "C": 2.55, "N": 3.04, "O": 3.44, "S": 2.58, "P": 2.19,
    "F": 3.98, "Cl": 3.16, "Br": 2.96, "I": 2.66, "H": 2.20, "Other": 2.5
}

VDW_RADIUS = {
    "C": 1.70, "N": 1.55, "O": 1.52, "S": 1.80, "P": 1.80,
    "F": 1.47, "Cl": 1.75, "Br": 1.85, "I": 1.98, "H": 1.20, "Other": 1.70
}

ATOMIC_MASS = {
    "C": 12.0, "N": 14.0, "O": 16.0, "S": 32.0, "P": 31.0,
    "F": 19.0, "Cl": 35.5, "Br": 80.0, "I": 127.0, "H": 1.0, "Other": 12.0
}

HYDROPHOBICITY = {
    "ALA": 0.70, "ARG": 0.00, "ASN": 0.11, "ASP": 0.11, "CYS": 0.78,
    "GLN": 0.11, "GLU": 0.11, "GLY": 0.46, "HIS": 0.14, "ILE": 1.00,
    "LEU": 0.92, "LYS": 0.07, "MET": 0.71, "PHE": 0.81, "PRO": 0.32,
    "SER": 0.41, "THR": 0.42, "TRP": 0.40, "TYR": 0.36, "VAL": 0.97,
}

AROMATIC_RESIDUES = {"PHE", "TYR", "TRP", "HIS"}
CHARGED_RESIDUES = {"ARG": 1, "LYS": 1, "ASP": -1, "GLU": -1, "HIS": 0.5}
POLAR_RESIDUES = {"SER", "THR", "ASN", "GLN", "TYR", "CYS"}
BACKBONE_ATOMS = {"N", "CA", "C", "O"}


# =============================================================================
# 工具函数
# =============================================================================

def _one_hot(idx: int, dim: int) -> np.ndarray:
    v = np.zeros(dim, dtype=np.float32)
    if 0 <= idx < dim:
        v[idx] = 1.0
    return v


def _get_element(atom) -> str:
    elem = getattr(atom, "element", None)
    if elem:
        e = elem.strip().capitalize()
        if e.upper() in ["CL", "BR"]:
            return e.upper().title()
        return e[0].upper()
    name = atom.name.strip()
    if not name:
        return "Other"
    if name[0].isdigit():
        name = name[1:]
    if name[:2].upper() in ["CL", "BR"]:
        return name[:2].upper().title()
    return name[0].upper()


def load_pdb_clean_models(pdb_path: str) -> mda.Universe:
    """读取 PDB，忽略 MODEL/ENDMDL"""
    with open(pdb_path, "r") as f:
        lines = f.readlines()
    
    cleaned = []
    for line in lines:
        rec = line[:6].strip().upper()
        if rec in ("MODEL", "ENDMDL"):
            continue
        cleaned.append(line)
    
    text = "".join(cleaned)
    return mda.Universe(StringIO(text), format="PDB")


# =============================================================================
# 增强版特征计算
# =============================================================================

def compute_local_geometry_features(
    coords: np.ndarray,
    radii: Sequence[float] = (3.0, 5.0, 8.0),
) -> np.ndarray:
    """局部几何特征: 邻居数量、各向异性、重心偏移"""
    N = coords.shape[0]
    dist_matrix = cdist(coords, coords)
    
    features_list = []
    
    for r in radii:
        mask = (dist_matrix <= r) & (dist_matrix > 0)
        n_neighbors = mask.sum(axis=1).astype(np.float32)
        
        anisotropy = np.zeros(N, dtype=np.float32)
        centroid_dist = np.zeros(N, dtype=np.float32)
        
        for i in range(N):
            neighbor_idx = np.where(mask[i])[0]
            if len(neighbor_idx) < 3:
                continue
            
            neighbor_coords = coords[neighbor_idx] - coords[i]
            centroid = neighbor_coords.mean(axis=0)
            centroid_dist[i] = np.linalg.norm(centroid)
            
            if len(neighbor_idx) >= 3:
                cov = np.cov(neighbor_coords.T)
                try:
                    eigenvalues = np.linalg.eigvalsh(cov)
                    eigenvalues = np.sort(eigenvalues)[::-1]
                    total = eigenvalues.sum() + 1e-8
                    anisotropy[i] = (eigenvalues[0] - eigenvalues[-1]) / total
                except:
                    pass
        
        features_list.extend([
            n_neighbors.reshape(-1, 1),
            anisotropy.reshape(-1, 1),
            centroid_dist.reshape(-1, 1),
        ])
    
    return np.concatenate(features_list, axis=1)


def compute_distance_statistics(
    coords: np.ndarray,
    coords_prot: np.ndarray,
    coords_lig: np.ndarray,
) -> np.ndarray:
    """距离统计特征"""
    N = coords.shape[0]
    
    dist_to_prot = cdist(coords, coords_prot)
    prot_min = dist_to_prot.min(axis=1, keepdims=True)
    prot_mean = dist_to_prot.mean(axis=1, keepdims=True)
    prot_std = dist_to_prot.std(axis=1, keepdims=True)
    prot_q25 = np.percentile(dist_to_prot, 25, axis=1, keepdims=True)
    prot_q75 = np.percentile(dist_to_prot, 75, axis=1, keepdims=True)
    
    dist_to_lig = cdist(coords, coords_lig)
    lig_min = dist_to_lig.min(axis=1, keepdims=True)
    lig_mean = dist_to_lig.mean(axis=1, keepdims=True)
    lig_std = dist_to_lig.std(axis=1, keepdims=True)
    lig_q25 = np.percentile(dist_to_lig, 25, axis=1, keepdims=True)
    lig_q75 = np.percentile(dist_to_lig, 75, axis=1, keepdims=True)
    
    dist_all = cdist(coords, coords)
    shells = [(0, 3), (3, 5), (5, 8), (8, 12)]
    shell_counts = []
    for r_min, r_max in shells:
        mask = (dist_all > r_min) & (dist_all <= r_max)
        count = mask.sum(axis=1, keepdims=True).astype(np.float32)
        shell_counts.append(count)
    
    return np.concatenate([
        prot_min, prot_mean, prot_std, prot_q25, prot_q75,
        lig_min, lig_mean, lig_std, lig_q25, lig_q75,
        *shell_counts,
    ], axis=1)


def compute_chemical_features(atoms, elements: List[str]) -> np.ndarray:
    """化学特征"""
    N = len(atoms)
    
    electroneg = np.zeros((N, 1), dtype=np.float32)
    vdw = np.zeros((N, 1), dtype=np.float32)
    mass = np.zeros((N, 1), dtype=np.float32)
    hbond_donor = np.zeros((N, 1), dtype=np.float32)
    hbond_acceptor = np.zeros((N, 1), dtype=np.float32)
    
    for i, (atom, elem) in enumerate(zip(atoms, elements)):
        electroneg[i] = ELECTRONEGATIVITY.get(elem, 2.5)
        vdw[i] = VDW_RADIUS.get(elem, 1.7)
        mass[i] = ATOMIC_MASS.get(elem, 12.0)
        
        if elem in ["N", "O"]:
            hbond_donor[i] = 1.0
            hbond_acceptor[i] = 1.0
        elif elem == "S":
            hbond_acceptor[i] = 0.5
    
    electroneg = (electroneg - 2.0) / 2.0
    vdw = (vdw - 1.2) / 0.8
    mass = np.log1p(mass) / 5.0
    
    return np.concatenate([electroneg, vdw, mass, hbond_donor, hbond_acceptor], axis=1)


def compute_protein_specific_features(atoms, is_protein: np.ndarray) -> np.ndarray:
    """蛋白质特定特征"""
    N = len(atoms)
    
    is_backbone = np.zeros((N, 1), dtype=np.float32)
    hydrophobicity = np.zeros((N, 1), dtype=np.float32)
    aromaticity = np.zeros((N, 1), dtype=np.float32)
    charge = np.zeros((N, 1), dtype=np.float32)
    polarity = np.zeros((N, 1), dtype=np.float32)
    
    for i, atom in enumerate(atoms):
        if is_protein[i, 0] < 0.5:
            hydrophobicity[i] = 0.5
            continue
        
        resname = atom.resname.strip().upper()
        atomname = atom.name.strip().upper()
        
        if atomname in BACKBONE_ATOMS:
            is_backbone[i] = 1.0
        
        hydrophobicity[i] = HYDROPHOBICITY.get(resname, 0.5)
        aromaticity[i] = 1.0 if resname in AROMATIC_RESIDUES else 0.0
        charge[i] = CHARGED_RESIDUES.get(resname, 0.0)
        polarity[i] = 1.0 if resname in POLAR_RESIDUES else 0.0
    
    return np.concatenate([is_backbone, hydrophobicity, aromaticity, charge, polarity], axis=1)


def compute_topology_features(dist_matrix: np.ndarray, cutoff: float = 6.0) -> np.ndarray:
    """拓扑特征"""
    N = dist_matrix.shape[0]
    adj = (dist_matrix <= cutoff) & (dist_matrix > 0)
    
    degree = adj.sum(axis=1).astype(np.float32)
    
    clustering = np.zeros(N, dtype=np.float32)
    for i in range(N):
        neighbors = np.where(adj[i])[0]
        k = len(neighbors)
        if k < 2:
            continue
        subgraph = adj[np.ix_(neighbors, neighbors)]
        edges = subgraph.sum() / 2
        max_edges = k * (k - 1) / 2
        clustering[i] = edges / max_edges if max_edges > 0 else 0
    
    adj2 = adj @ adj
    np.fill_diagonal(adj2, 0)
    second_degree = (adj2 > 0).sum(axis=1).astype(np.float32)
    
    degree_norm = degree / (degree.max() + 1e-8)
    second_degree_norm = second_degree / (second_degree.max() + 1e-8)
    
    return np.stack([degree_norm, clustering, second_degree_norm], axis=1)


def compute_interface_features(coords: np.ndarray, is_protein: np.ndarray, cutoff: float = 5.0) -> np.ndarray:
    """界面特征"""
    N = coords.shape[0]
    prot_mask = is_protein.flatten() > 0.5
    
    coords_prot = coords[prot_mask]
    coords_lig = coords[~prot_mask]
    
    dist_prot_to_lig = cdist(coords_prot, coords_lig)
    prot_min_dist = dist_prot_to_lig.min(axis=1)
    
    dist_lig_to_prot = cdist(coords_lig, coords_prot)
    lig_min_dist = dist_lig_to_prot.min(axis=1)
    
    is_interface = np.zeros((N, 1), dtype=np.float32)
    interface_distance = np.zeros((N, 1), dtype=np.float32)
    
    prot_idx = np.where(prot_mask)[0]
    lig_idx = np.where(~prot_mask)[0]
    
    for i, idx in enumerate(prot_idx):
        is_interface[idx] = 1.0 if prot_min_dist[i] <= cutoff else 0.0
        interface_distance[idx] = prot_min_dist[i]
    
    for i, idx in enumerate(lig_idx):
        is_interface[idx] = 1.0 if lig_min_dist[i] <= cutoff else 0.0
        interface_distance[idx] = lig_min_dist[i]
    
    interface_distance = np.clip(interface_distance / 10.0, 0, 1)
    
    return np.concatenate([is_interface, interface_distance], axis=1)


def compute_local_environment_features(coords: np.ndarray, elements: List[str], cutoff: float = 5.0) -> np.ndarray:
    """局部环境特征"""
    N = coords.shape[0]
    dist_matrix = cdist(coords, coords)
    mask = (dist_matrix <= cutoff) & (dist_matrix > 0)
    
    elem_to_idx = {"C": 0, "N": 1, "O": 2, "S": 3}
    
    neighbor_composition = np.zeros((N, 4), dtype=np.float32)
    neighbor_electroneg = np.zeros((N, 1), dtype=np.float32)
    neighbor_mass = np.zeros((N, 1), dtype=np.float32)
    
    for i in range(N):
        neighbor_idx = np.where(mask[i])[0]
        if len(neighbor_idx) == 0:
            continue
        
        for j in neighbor_idx:
            elem = elements[j]
            if elem in elem_to_idx:
                neighbor_composition[i, elem_to_idx[elem]] += 1
            neighbor_electroneg[i] += ELECTRONEGATIVITY.get(elem, 2.5)
            neighbor_mass[i] += ATOMIC_MASS.get(elem, 12.0)
        
        n = len(neighbor_idx)
        neighbor_composition[i] /= n
        neighbor_electroneg[i] /= n
        neighbor_mass[i] /= n
    
    neighbor_electroneg = (neighbor_electroneg - 2.5) / 1.5
    neighbor_mass = np.log1p(neighbor_mass) / 5.0
    
    return np.concatenate([neighbor_composition, neighbor_electroneg, neighbor_mass], axis=1)


# =============================================================================
# 核心构图函数
# =============================================================================

def build_graph_enhanced(
    protein_pdb: str,
    ligand_pred_pdb: str,
    ligand_native_pdb: str,
    cutoff: float = 6.0,
    neighbor_radii: Sequence[float] = (3.0, 5.0, 8.0),
    use_enhanced_features: bool = True,
) -> Data:
    """
    构建增强版蛋白-配体图
    
    Args:
        protein_pdb: 蛋白结构文件
        ligand_pred_pdb: 配体预测结构 (docking pose)
        ligand_native_pdb: 配体真实结构 (ground truth)
        cutoff: 构图距离阈值
        neighbor_radii: 邻居统计的距离半径
        use_enhanced_features: 是否使用增强特征 (82维)，否则使用基础特征 (~40维)
    
    Returns:
        Data: 包含节点特征、边、标签的图数据
    """
    # ---- 1. 读取文件 ----
    u_p = load_pdb_clean_models(protein_pdb)
    u_l_pred = load_pdb_clean_models(ligand_pred_pdb)
    u_l_native = load_pdb_clean_models(ligand_native_pdb)
    
    prot_atoms = u_p.select_atoms("not name H*")
    lig_pred_atoms = u_l_pred.select_atoms("not name H*")
    lig_native_atoms = u_l_native.select_atoms("not name H*")
    
    coords_prot = prot_atoms.positions.astype(np.float32)
    coords_lig_pred = lig_pred_atoms.positions.astype(np.float32)
    coords_lig_native = lig_native_atoms.positions.astype(np.float32)
    
    Np = coords_prot.shape[0]
    Nl = coords_lig_pred.shape[0]
    N = Np + Nl
    
    # 检查配体原子数是否匹配
    if coords_lig_pred.shape[0] != coords_lig_native.shape[0]:
        raise ValueError(f"配体原子数不匹配: pred={coords_lig_pred.shape[0]}, native={coords_lig_native.shape[0]}")
    
    # ---- 2. 计算误差标签 ----
    # 蛋白原子误差 = 0 (蛋白位置固定)
    errors_prot = np.zeros(Np, dtype=np.float32)
    
    # 配体原子误差 = |pred - native|
    errors_lig = np.linalg.norm(coords_lig_pred - coords_lig_native, axis=1).astype(np.float32)
    
    y_true = np.concatenate([errors_prot, errors_lig])  # [N]
    
    # 预测坐标和真实坐标 (用于评估时计算区间)
    coords_all_pred = np.vstack([coords_prot, coords_lig_pred])  # [N, 3]
    coords_all_native = np.vstack([coords_prot, coords_lig_native])  # [N, 3]
    
    # y_pred 和 y_grt 存储完整的三维坐标
    # 评估时用 |y_pred - y_grt| 计算实际误差，检查是否 <= radius
    y_pred = coords_all_pred  # [N, 3]
    y_grt = coords_all_native  # [N, 3]
    
    # ---- 3. 合并原子列表 ----
    all_atoms = list(prot_atoms) + list(lig_pred_atoms)
    elements = [_get_element(atom) for atom in all_atoms]
    
    # ---- 4. 基础特征 ----
    # 元素 one-hot
    atom_type_oh = np.stack([
        _one_hot(ELEMENT2IDX.get(elem, ELEMENT2IDX["Other"]), len(ELEMENTS))
        for elem in elements
    ])
    
    # 残基类型 one-hot
    res_type_oh = []
    for i, atom in enumerate(all_atoms):
        if i < Np:
            resname = atom.resname.strip().upper()
            idx = AA3_2IDX.get(resname, len(AA3))
        else:
            idx = len(AA3)
        res_type_oh.append(_one_hot(idx, AA_DIM))
    res_type_oh = np.stack(res_type_oh)
    
    # is_protein / is_ligand
    is_protein = np.zeros((N, 1), dtype=np.float32)
    is_protein[:Np] = 1.0
    is_ligand = 1.0 - is_protein
    
    # ---- 5. 距离特征 ----
    prot_center = coords_prot.mean(axis=0, keepdims=True)
    lig_center = coords_lig_pred.mean(axis=0, keepdims=True)
    
    d_prot_center = np.linalg.norm(coords_all_pred - prot_center, axis=1, keepdims=True)
    d_lig_center = np.linalg.norm(coords_all_pred - lig_center, axis=1, keepdims=True)
    
    dist_all = cdist(coords_all_pred, coords_all_pred)
    d_min_prot = cdist(coords_all_pred, coords_prot).min(axis=1, keepdims=True)
    d_min_lig = cdist(coords_all_pred, coords_lig_pred).min(axis=1, keepdims=True)
    
    # 归一化
    d_prot_center_norm = d_prot_center / 50.0
    d_lig_center_norm = d_lig_center / 30.0
    d_min_prot_norm = d_min_prot / 20.0
    d_min_lig_norm = d_min_lig / 20.0
    
    # ---- 6. 构建特征 ----
    if use_enhanced_features:
        # 增强特征 (82维)
        local_geom_feat = compute_local_geometry_features(coords_all_pred, radii=neighbor_radii)
        dist_stat_feat = compute_distance_statistics(coords_all_pred, coords_prot, coords_lig_pred) / 20.0
        chem_feat = compute_chemical_features(all_atoms, elements)
        prot_specific_feat = compute_protein_specific_features(all_atoms, is_protein)
        topo_feat = compute_topology_features(dist_all, cutoff=cutoff)
        interface_feat = compute_interface_features(coords_all_pred, is_protein)
        local_env_feat = compute_local_environment_features(coords_all_pred, elements, cutoff=5.0)
        
        data_x = np.concatenate([
            atom_type_oh,           # 11
            res_type_oh,            # 21
            is_protein,             # 1
            is_ligand,              # 1
            d_prot_center_norm,     # 1
            d_lig_center_norm,      # 1
            d_min_prot_norm,        # 1
            d_min_lig_norm,         # 1
            local_geom_feat,        # 9
            dist_stat_feat,         # 14
            chem_feat,              # 5
            prot_specific_feat,     # 5
            topo_feat,              # 3
            interface_feat,         # 2
            local_env_feat,         # 6
        ], axis=1).astype(np.float32)
    else:
        # 基础特征 (~40维)
        neighbor_feats = []
        for r in neighbor_radii[:2]:  # 只用前两个半径
            mask = (dist_all <= r) & (~np.eye(N, dtype=bool))
            n_nb = mask.sum(axis=1, keepdims=True)
            neighbor_feats.append(n_nb.astype(np.float32))
        neighbor_feats = np.concatenate(neighbor_feats, axis=1)
        
        data_x = np.concatenate([
            atom_type_oh,
            res_type_oh,
            is_protein,
            is_ligand,
            d_prot_center_norm,
            d_lig_center_norm,
            d_min_prot_norm,
            d_min_lig_norm,
            neighbor_feats,
        ], axis=1).astype(np.float32)
    
    # ---- 7. 构建边 ----
    mask = (dist_all <= cutoff) & (~np.eye(N, dtype=bool))
    src, dst = np.where(mask)
    edge_index = np.vstack([src, dst]).astype(np.int64)
    
    # ---- 8. 边特征 ----
    if use_enhanced_features:
        edge_dist = dist_all[src, dst]
        edge_attr = np.stack([
            edge_dist / cutoff,
            np.exp(-edge_dist / 3.0),
            (src < Np).astype(np.float32),
            (dst < Np).astype(np.float32),
        ], axis=1).astype(np.float32)
    else:
        edge_attr = None
    
    # ---- 9. 构建 Data ----
    data = Data(
        x=torch.from_numpy(data_x),
        edge_index=torch.from_numpy(edge_index),
        pos=torch.from_numpy(coords_all_pred),
        is_protein=torch.from_numpy(is_protein),
        y_true=torch.from_numpy(y_true).unsqueeze(-1),  # [N, 1] 误差
        y_pred=torch.from_numpy(y_pred),                 # [N, 3] 预测坐标
        y_grt=torch.from_numpy(y_grt),                   # [N, 3] 真实坐标
        num_nodes=N,
    )
    
    if edge_attr is not None:
        data.edge_attr = torch.from_numpy(edge_attr)
    
    return data


# =============================================================================
# 批量处理函数
# =============================================================================

def find_docking_poses(
    pdb_dir: str,
    docking_type: str = "protenix",
) -> List[Dict[str, str]]:
    """
    自动发现目录中的 docking poses
    
    支持的目录结构:
    - protenix: {target}_{lig_id}/lig_{id}_pose*.pdb 或 {pdb_id}_pose_*.pdb
    - diffdock: {pdb_id}/rank*_confidence*.sdf 或 *pose*.pdb
    - autodock_vina: {pdb_id}/vina_pose_*.pdb 或 *pose*.pdb
    - medusagraph: {pdb_id}/medusa_pose_*.pdb 或 *pose*.pdb
    
    Returns:
        List of dicts with keys: pdb_id, protein, ligand_pred, ligand_native
    """
    poses = []
    
    for pdb_id in os.listdir(pdb_dir):
        subdir = os.path.join(pdb_dir, pdb_id)
        if not os.path.isdir(subdir):
            continue
        
        # 找蛋白文件
        protein_file = None
        for name in ["protein.pdb", f"{pdb_id}_protein.pdb", "receptor.pdb"]:
            path = os.path.join(subdir, name)
            if os.path.exists(path):
                protein_file = path
                break
        
        if protein_file is None:
            continue
        
        # 找原生配体 (增加 ligands.pdb)
        native_file = None
        for name in ["ligands.pdb", "ligand.pdb", "ligand_native.pdb", f"{pdb_id}_ligand.pdb", "native.pdb"]:
            path = os.path.join(subdir, name)
            if os.path.exists(path):
                native_file = path
                break
        
        if native_file is None:
            continue
        
        # 找 docking poses (更灵活的匹配)
        pose_files = []
        
        if docking_type == "protenix":
            # 尝试多种模式
            patterns = [
                os.path.join(subdir, f"*_pose*.pdb"),      # lig_1_pose1.pdb, xxx_pose_01.pdb
                os.path.join(subdir, f"{pdb_id}_pose_*.pdb"),  # cdk2_lig_1_pose_01.pdb
            ]
        elif docking_type == "diffdock":
            patterns = [
                os.path.join(subdir, f"*_pose*.pdb"),
                os.path.join(subdir, f"rank*.pdb"),
                os.path.join(subdir, f"rank*_confidence*.sdf"),
            ]
        elif docking_type == "autodock_vina":
            patterns = [
                os.path.join(subdir, f"*_pose*.pdb"),
                os.path.join(subdir, "vina_pose_*.pdb"),
                os.path.join(subdir, "vina_out*.pdb"),
            ]
        elif docking_type == "medusagraph":
            patterns = [
                os.path.join(subdir, f"*_pose*.pdb"),
                os.path.join(subdir, "medusa_pose_*.pdb"),
            ]
        else:
            patterns = [os.path.join(subdir, f"*pose*.pdb")]
        
        for pattern in patterns:
            pose_files.extend(glob.glob(pattern))
        
        # 去重并排除原生配体文件
        pose_files = list(set(pose_files))
        pose_files = [f for f in pose_files if os.path.basename(f) not in ["ligands.pdb", "ligand.pdb", "native.pdb"]]
        
        for pose_file in pose_files:
            poses.append({
                'pdb_id': pdb_id,
                'protein': protein_file,
                'ligand_pred': pose_file,
                'ligand_native': native_file,
            })
    
    return poses


def _build_single_graph(args):
    """单个图构建函数 (用于多进程)"""
    pose, cutoff, use_enhanced_features, temp_dir = args
    try:
        data = build_graph_enhanced(
            protein_pdb=pose['protein'],
            ligand_pred_pdb=pose['ligand_pred'],
            ligand_native_pdb=pose['ligand_native'],
            cutoff=cutoff,
            use_enhanced_features=use_enhanced_features,
        )
        # 保存到临时文件，避免跨进程传输 PyTorch tensor
        temp_file = os.path.join(temp_dir, f"{pose['pdb_id']}_{os.path.basename(pose['ligand_pred'])}.pt")
        torch.save(data, temp_file)
        return ('success', temp_file)
    except Exception as e:
        return ('error', (pose['pdb_id'], str(e)))


def build_dataset(
    data_dir: str,
    output_path: str,
    docking_type: str = "protenix",
    cutoff: float = 6.0,
    use_enhanced_features: bool = True,
    max_samples: int = None,
    num_workers: int = 1,
) -> None:
    """
    批量构建数据集
    
    Args:
        data_dir: 数据目录
        output_path: 输出文件路径
        docking_type: docking 类型
        cutoff: 构图阈值
        use_enhanced_features: 是否使用增强特征
        max_samples: 最大样本数 (用于测试)
        num_workers: 并行进程数 (默认 1，设为 -1 使用所有 CPU)
    """
    import multiprocessing as mp
    import tempfile
    import shutil
    
    print(f"扫描目录: {data_dir}")
    poses = find_docking_poses(data_dir, docking_type)
    print(f"发现 {len(poses)} 个 docking poses")
    
    if max_samples is not None:
        poses = poses[:max_samples]
        print(f"限制为 {max_samples} 个样本")
    
    # 确定进程数
    if num_workers == -1:
        num_workers = mp.cpu_count()
    elif num_workers <= 0:
        num_workers = 1
    
    graphs = []
    errors = []
    
    if num_workers == 1:
        # 单进程模式
        for pose in tqdm(poses, desc="构建图"):
            try:
                data = build_graph_enhanced(
                    protein_pdb=pose['protein'],
                    ligand_pred_pdb=pose['ligand_pred'],
                    ligand_native_pdb=pose['ligand_native'],
                    cutoff=cutoff,
                    use_enhanced_features=use_enhanced_features,
                )
                graphs.append(data)
            except Exception as e:
                errors.append((pose['pdb_id'], str(e)))
    else:
        # 多进程模式 - 使用临时目录存储中间结果
        print(f"使用 {num_workers} 个进程并行构建")
        
        # 创建临时目录
        temp_dir = tempfile.mkdtemp(prefix="graph_build_")
        print(f"临时目录: {temp_dir}")
        
        try:
            # 准备参数
            args_list = [(pose, cutoff, use_enhanced_features, temp_dir) for pose in poses]
            
            # 使用进程池
            with mp.Pool(processes=num_workers) as pool:
                results = list(tqdm(
                    pool.imap(_build_single_graph, args_list),
                    total=len(args_list),
                    desc=f"构建图 ({num_workers} workers)"
                ))
            
            # 收集结果
            print("正在收集结果...")
            temp_files = []
            for result in results:
                if result[0] == 'success':
                    temp_files.append(result[1])
                else:
                    errors.append(result[1])
            
            # 从临时文件加载数据
            for temp_file in tqdm(temp_files, desc="加载图数据"):
                try:
                    data = torch.load(temp_file, weights_only=False)
                    graphs.append(data)
                except Exception as e:
                    errors.append(("load_error", str(e)))
        
        finally:
            # 清理临时目录
            print(f"清理临时目录...")
            shutil.rmtree(temp_dir, ignore_errors=True)
    
    print(f"\n成功: {len(graphs)} | 失败: {len(errors)}")
    
    if errors and len(errors) <= 10:
        print("失败样本:")
        for pdb_id, err in errors:
            print(f"  {pdb_id}: {err}")
    
    # 保存
    os.makedirs(os.path.dirname(output_path), exist_ok=True)
    torch.save(graphs, output_path)
    print(f"\n数据集已保存到: {output_path}")
    
    # 统计
    if graphs:
        n_nodes = sum(g.num_nodes for g in graphs)
        n_edges = sum(g.edge_index.shape[1] for g in graphs)
        feature_dim = graphs[0].x.shape[1]
        has_edge_attr = hasattr(graphs[0], 'edge_attr') and graphs[0].edge_attr is not None
        
        print(f"\n数据集统计:")
        print(f"  图数量: {len(graphs)}")
        print(f"  总节点数: {n_nodes}")
        print(f"  总边数: {n_edges}")
        print(f"  节点特征维度: {feature_dim}")
        print(f"  边特征: {'有' if has_edge_attr else '无'}")
        
        # 误差统计
        all_errors = []
        for g in graphs:
            is_prot = g.is_protein.squeeze(-1)
            y_true = g.y_true.squeeze(-1)
            lig_mask = (is_prot == 0)
            all_errors.append(y_true[lig_mask])
        
        all_errors = torch.cat(all_errors)
        print(f"\n误差统计 (配体原子):")
        print(f"  样本数: {len(all_errors)}")
        print(f"  均值: {all_errors.mean():.4f} Å")
        print(f"  中位数: {all_errors.median():.4f} Å")
        print(f"  标准差: {all_errors.std():.4f} Å")
        print(f"  范围: [{all_errors.min():.4f}, {all_errors.max():.4f}] Å")
        print(f"  90% 分位: {torch.quantile(all_errors, 0.9):.4f} Å")


# =============================================================================
# 命令行接口
# =============================================================================

def main():
    parser = argparse.ArgumentParser(description="构建增强版蛋白-配体图数据集")
    
    parser.add_argument("--data_dir", type=str, required=True, help="数据目录")
    parser.add_argument("--output", type=str, required=True, help="输出文件路径")
    parser.add_argument("--docking_type", type=str, default="protenix",
                       choices=["protenix", "diffdock", "autodock_vina", "medusagraph"],
                       help="Docking 类型")
    parser.add_argument("--cutoff", type=float, default=6.0, help="构图距离阈值")
    parser.add_argument("--no_enhanced", action="store_true", help="不使用增强特征")
    parser.add_argument("--max_samples", type=int, default=None, help="最大样本数")
    parser.add_argument("--num_workers", type=int, default=1, 
                       help="并行进程数 (默认 1，设为 -1 使用所有 CPU)")
    
    args = parser.parse_args()
    
    build_dataset(
        data_dir=args.data_dir,
        output_path=args.output,
        docking_type=args.docking_type,
        cutoff=args.cutoff,
        use_enhanced_features=not args.no_enhanced,
        max_samples=args.max_samples,
        num_workers=args.num_workers,
    )


if __name__ == "__main__":
    main()

# python build_graph_unified_enhanced.py --data_dir /work/nvme/bghp/hhao/gnncp/filtered_output/protenix --output /work/nvme/bghp/hhao/gnncp/datasets_all/protenix_enhanced_graphs.pt --docking_type protenix --num_workers -1
# python build_graph_unified_enhanced.py --data_dir /work/nvme/bghp/hhao/gnncp/filtered_output/diffdock --output /work/nvme/bghp/hhao/gnncp/datasets_all/diffdock_enhanced_graphs.pt --docking_type diffdock --num_workers -1
# python build_graph_unified_enhanced.py --data_dir /work/nvme/bghp/hhao/gnncp/filtered_output/medusagraph --output /work/nvme/bghp/hhao/gnncp/datasets_all/medusagraph_enhanced_graphs.pt --docking_type medusagraph --num_workers -1
# python build_graph_unified_enhanced.py --data_dir /work/nvme/bghp/hhao/gnncp/filtered_output/autodock_vina --output /work/nvme/bghp/hhao/gnncp/datasets_all/autodock_vina_enhanced_graphs.pt --docking_type autodock_vina --num_workers -1
# salloc -t 06:00:00 --mem=128g --account=beyd-delta-cpu --partition=cpu --nodes=1 --tasks=1 --tasks-per-node=1 --cpus-per-task=24
# salloc -t 03:00:00 --mem=64g --account=beyd-delta-cpu --partition=cpu --nodes=1 --tasks=1 --tasks-per-node=1 --cpus-per-task=16