#!/usr/bin/env python
"""
Generate training CSV files from the splits JSON files.

This script reads the PDB ID lists from splits/*.json and creates 
the CSV files needed for training, matching them with the mmCIF files.

Usage:
    python generate_training_csv_from_splits.py \
        --mmcif_dir /path/to/mmcif_files \
        --splits_dir /path/to/splits \
        --output_dir /path/to/output

Example:
    cd /root/autodl-tmp/PH-NA-MPNN/data
    python generate_training_csv_from_splits.py \
        --mmcif_dir ./pdb_mmcif \
        --splits_dir ../splits \
        --output_dir ./datasets/diffusion_na_full
"""

import os
import sys
import json
import glob
import argparse
import pandas as pd
from tqdm import tqdm



def find_structure_path(pdb_id, mmcif_dir):
    """Find the structure file path for a given PDB ID."""
    pdb_id_lower = pdb_id.lower()
    
    # Try different possible locations and extensions
    patterns = [
        os.path.join(mmcif_dir, f"{pdb_id_lower}.cif"),
        os.path.join(mmcif_dir, f"{pdb_id_lower}.cif.gz"),
        os.path.join(mmcif_dir, pdb_id_lower[1:3], f"{pdb_id_lower}.cif"),
        os.path.join(mmcif_dir, pdb_id_lower[1:3], f"{pdb_id_lower}.cif.gz"),
    ]
    
    for pattern in patterns:
        if os.path.exists(pattern):
            return pattern
    
    return None


def load_json(path):
    """Load a JSON file."""
    with open(path, 'r') as f:
        return json.load(f)


def create_training_csv(pdb_ids, mmcif_dir, output_path, dataset_name="diffusion_na"):
    """Create a training CSV file from PDB IDs."""
    
    data = []
    missing_count = 0
    
    for pdb_id in tqdm(pdb_ids, desc=f"Processing {os.path.basename(output_path)}"):
        structure_path = find_structure_path(pdb_id, mmcif_dir)

        if structure_path is None:
            missing_count += 1
            continue
        
        data.append({
            'id': pdb_id.lower(),
            'structure_path': os.path.abspath(structure_path),
            'date': '2024-01-01',  # Default date
            'dataset_name': dataset_name,
            'sampling_probability': 1.0,
            'ppm_paths': '[]',
        })
    
    df = pd.DataFrame(data)
    df.to_csv(output_path, index=False)
    
    print(f"Created {output_path}")
    print(f"  Total PDB IDs:     {len(pdb_ids)}")
    print(f"  Found:             {len(data)}")
    print(f"  Missing:           {missing_count}")
    
    return df


def main():
    parser = argparse.ArgumentParser(
        description="Generate training CSVs from splits JSON files"
    )
    parser.add_argument('--mmcif_dir', type=str, required=True,
                        help='Path to mmCIF files directory')
    parser.add_argument('--splits_dir', type=str, required=True,
                        help='Path to splits directory containing JSON files')
    parser.add_argument('--output_dir', type=str, required=True,
                        help='Output directory for CSV files')
    parser.add_argument('--split_type', type=str, default='design',
                        choices=['design', 'specificity'],
                        help='Which split type to use (default: design)')
    
    args = parser.parse_args()
    
    # Create output directory
    os.makedirs(args.output_dir, exist_ok=True)
    
    # Load split files
    train_json = os.path.join(args.splits_dir, f'{args.split_type}_train.json')
    valid_json = os.path.join(args.splits_dir, f'{args.split_type}_valid.json')
    test_json = os.path.join(args.splits_dir, f'{args.split_type}_test.json')
    
    print(f"Loading splits from {args.splits_dir}...")
    train_ids = load_json(train_json)
    valid_ids = load_json(valid_json)
    test_ids = load_json(test_json) if os.path.exists(test_json) else []
    
    print(f"  Train: {len(train_ids)} PDB IDs")
    print(f"  Valid: {len(valid_ids)} PDB IDs")
    print(f"  Test: {len(test_ids)} PDB IDs")
    
    # Check mmcif directory
    print(f"\nSearching for mmCIF files in {args.mmcif_dir}...")
    mmcif_files = glob.glob(os.path.join(args.mmcif_dir, '*.cif'))
    mmcif_files += glob.glob(os.path.join(args.mmcif_dir, '*.cif.gz'))
    print(f"  Found {len(mmcif_files)} mmCIF files")
    
    # Generate CSVs
    print("\nGenerating CSV files...")
    
    train_csv = os.path.join(args.output_dir, 'train.csv')
    valid_csv = os.path.join(args.output_dir, 'valid.csv')
    test_csv = os.path.join(args.output_dir, 'test.csv')
    
    create_training_csv(train_ids, args.mmcif_dir, train_csv)
    create_training_csv(valid_ids, args.mmcif_dir, valid_csv)
    if test_ids:
        create_training_csv(test_ids, args.mmcif_dir, test_csv)
    
    print("\n" + "="*60)
    print("Done! Update your config with:")
    print(f'  "DF_PATH_TRAIN": "{os.path.abspath(train_csv)}",')
    print(f'  "DF_PATH_VALID": "{os.path.abspath(valid_csv)}",')
    print("="*60)


if __name__ == "__main__":
    main()