#!/usr/bin/env python3
"""
Download AlphaFold structures from AlphaFold Database.
Part of APED - African Protein Engineering Dataset
"""

import argparse
import os
import time
import requests
from pathlib import Path


ALPHAFOLD_DB_URL = "https://alphafold.ebi.ac.uk/files/AF-{uniprot_id}-F1-model_v4.pdb"
UNIPROT_API_URL = "https://rest.uniprot.org/uniprotkb/search"


def get_uniprot_ids_by_taxonomy(taxonomy_ids: list, limit: int = 500) -> list:
    """Fetch UniProt IDs for given taxonomy IDs."""
    all_ids = []
    
    for tax_id in taxonomy_ids:
        print(f"Fetching proteins for taxonomy ID: {tax_id}")
        
        query = f"(taxonomy_id:{tax_id}) AND (reviewed:true)"
        params = {
            "query": query,
            "format": "list",
            "size": limit
        }
        
        try:
            response = requests.get(UNIPROT_API_URL, params=params, timeout=30)
            response.raise_for_status()
            ids = response.text.strip().split('\n')
            ids = [i for i in ids if i]
            all_ids.extend(ids)
            print(f"  Found {len(ids)} proteins")
        except requests.RequestException as e:
            print(f"  Error fetching taxonomy {tax_id}: {e}")
        
        time.sleep(0.5)  # Rate limiting
    
    return list(set(all_ids))


def download_alphafold_structure(uniprot_id: str, output_dir: Path) -> bool:
    """Download a single AlphaFold structure."""
    output_file = output_dir / f"AF-{uniprot_id}-F1-model_v4.pdb"
    
    if output_file.exists():
        return True
    
    url = ALPHAFOLD_DB_URL.format(uniprot_id=uniprot_id)
    
    try:
        response = requests.get(url, timeout=30)
        response.raise_for_status()
        
        with open(output_file, 'w') as f:
            f.write(response.text)
        return True
        
    except requests.RequestException:
        return False


def main():
    parser = argparse.ArgumentParser(
        description="Download AlphaFold structures for thermophilic organisms"
    )
    parser.add_argument(
        "--taxonomy-ids",
        type=str,
        required=True,
        help="Comma-separated taxonomy IDs (e.g., 274,69014,2287)"
    )
    parser.add_argument(
        "--output-dir",
        type=str,
        default="data/structures/alphafold_db/",
        help="Output directory for PDB files"
    )
    parser.add_argument(
        "--limit",
        type=int,
        default=500,
        help="Max proteins per organism"
    )
    parser.add_argument(
        "--uniprot-ids-file",
        type=str,
        help="Optional: File with UniProt IDs (one per line)"
    )
    
    args = parser.parse_args()
    
    output_dir = Path(args.output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)
    
    # Get UniProt IDs
    if args.uniprot_ids_file:
        with open(args.uniprot_ids_file) as f:
            uniprot_ids = [line.strip() for line in f if line.strip()]
    else:
        taxonomy_ids = [int(t.strip()) for t in args.taxonomy_ids.split(',')]
        uniprot_ids = get_uniprot_ids_by_taxonomy(taxonomy_ids, args.limit)
    
    print(f"\nDownloading {len(uniprot_ids)} structures...")
    
    success = 0
    failed = 0
    
    for i, uid in enumerate(uniprot_ids):
        if download_alphafold_structure(uid, output_dir):
            success += 1
        else:
            failed += 1
        
        if (i + 1) % 50 == 0:
            print(f"  Progress: {i + 1}/{len(uniprot_ids)} (success: {success}, failed: {failed})")
        
        time.sleep(0.1)  # Rate limiting
    
    print(f"\nComplete!")
    print(f"  Downloaded: {success}")
    print(f"  Failed: {failed}")
    print(f"  Output: {output_dir}")


if __name__ == "__main__":
    main()