"""
African Medical Multimodal Dataset Loading Script
Easy interface for loading the dataset components
"""

import json
import pandas as pd
import numpy as np
from pathlib import Path
from typing import Dict, List, Tuple, Optional
import cv2

class AfricanMedicalDataset:
    def __init__(self, dataset_path: str = "."):
        self.dataset_path = Path(dataset_path)
        self.records = None
        self.features = None
        self.splits = None
        
    def load_multimodal_records(self) -> List[Dict]:
        """Load complete multimodal records"""
        with open(self.dataset_path / "data" / "multimodal_records.json", 'r', encoding='utf-8') as f:
            self.records = json.load(f)
        return self.records
    
    def load_feature_matrices(self) -> Dict[str, np.ndarray]:
        """Load ML-ready feature matrices"""
        self.features = dict(np.load(self.dataset_path / "data" / "feature_matrices.npz"))
        return self.features
    
    def load_data_splits(self) -> Dict:
        """Load train/validation/test splits"""
        with open(self.dataset_path / "data" / "data_splits.json", 'r') as f:
            self.splits = json.load(f)
        return self.splits
    
    def get_record_by_id(self, record_id: str) -> Optional[Dict]:
        """Get specific record by ID"""
        if not self.records:
            self.load_multimodal_records()
        
        for record in self.records:
            if record.get("record_id") == record_id:
                return record
        return None
    
    def get_records_by_country(self, country: str) -> List[Dict]:
        """Get all records from specific country"""
        if not self.records:
            self.load_multimodal_records()
        
        return [r for r in self.records 
                if r.get("demographics", {}).get("country") == country]
    
    def get_records_by_language(self, language: str) -> List[Dict]:
        """Get all records in specific language"""
        if not self.records:
            self.load_multimodal_records()
        
        return [r for r in self.records 
                if r.get("demographics", {}).get("primary_language") == language]
    
    def get_records_by_fracture_type(self, fracture_type: str) -> List[Dict]:
        """Get all records of specific fracture type"""
        if not self.records:
            self.load_multimodal_records()
        
        return [r for r in self.records if r.get("fracture_type") == fracture_type]
    
    def get_summary_statistics(self) -> Dict:
        """Get dataset summary statistics"""
        if not self.records:
            self.load_multimodal_records()
        
        countries = [r.get("demographics", {}).get("country") for r in self.records]
        languages = [r.get("demographics", {}).get("primary_language") for r in self.records]
        regions = [r.get("demographics", {}).get("region_type") for r in self.records]
        fractures = [r.get("fracture_type") for r in self.records]
        
        return {
            "total_records": len(self.records),
            "countries": len(set(countries)),
            "languages": len(set(languages)),
            "country_distribution": pd.Series(countries).value_counts().to_dict(),
            "language_distribution": pd.Series(languages).value_counts().to_dict(),
            "region_distribution": pd.Series(regions).value_counts().to_dict(),
            "fracture_distribution": pd.Series(fractures).value_counts().to_dict()
        }
    
    def export_subset(self, condition_func, output_path: str):
        """Export subset of data based on condition function"""
        if not self.records:
            self.load_multimodal_records()
        
        subset = [r for r in self.records if condition_func(r)]
        
        with open(output_path, 'w', encoding='utf-8') as f:
            json.dump(subset, f, indent=2, ensure_ascii=False)
        
        print(f"Exported {len(subset)} records to {output_path}")

# Example usage
if __name__ == "__main__":
    # Load dataset
    dataset = AfricanMedicalDataset()
    
    # Load all components
    records = dataset.load_multimodal_records()
    features = dataset.load_feature_matrices()
    splits = dataset.load_data_splits()
    
    # Get summary
    stats = dataset.get_summary_statistics()
    print("Dataset Statistics:")
    print(f"Total records: {stats['total_records']}")
    print(f"Countries: {stats['countries']}")
    print(f"Languages: {stats['languages']}")
    
    # Example queries
    nigeria_cases = dataset.get_records_by_country("Nigeria")
    swahili_cases = dataset.get_records_by_language("Swahili")
    fracture_cases = dataset.get_records_by_fracture_type("Comminuted fracture")
    
    print(f"\nNigeria cases: {len(nigeria_cases)}")
    print(f"Swahili cases: {len(swahili_cases)}")
    print(f"Comminuted fractures: {len(fracture_cases)}")