#!/usr/bin/env python3
"""
Master orchestrator for Saudi healthcare data generation.
Runs all data generators in the correct dependency order.
"""

import os
import sys
import argparse
from datetime import datetime

# Add current directory to path for imports
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

from data_utils.base import DataGenerationOrchestrator
from data_utils.helpers import validate_dependencies


def create_orchestrator():
    """Create and configure the data generation orchestrator"""
    orchestrator = DataGenerationOrchestrator()

    # Import and register all generators
    try:
        from core_data import SaudiCoreDataGenerator
        orchestrator.register_generator('core', SaudiCoreDataGenerator)
    except ImportError:
        print("Warning: core_data.py not found or not refactored yet")

    try:
        from accounts_data import SaudiAccountsDataGenerator
        orchestrator.register_generator('accounts', SaudiAccountsDataGenerator)
    except ImportError:
        print("Warning: accounts_data.py not found or not refactored yet")

    try:
        from hr_data import SaudiHRDataGenerator
        orchestrator.register_generator('hr', SaudiHRDataGenerator)
    except ImportError:
        print("Warning: hr_data.py not found or not refactored yet")

    try:
        from patients_data import SaudiPatientsDataGenerator
        orchestrator.register_generator('patients', SaudiPatientsDataGenerator)
    except ImportError:
        print("Warning: patients_data.py not found or not refactored yet")

    try:
        from emr_data import SaudiEMRDataGenerator
        orchestrator.register_generator('emr', SaudiEMRDataGenerator)
    except ImportError:
        print("Warning: emr_data.py not found or not refactored yet")

    try:
        from lab_data import SaudiLabDataGenerator
        orchestrator.register_generator('lab', SaudiLabDataGenerator)
    except ImportError:
        print("Warning: lab_data.py not found or not refactored yet")

    try:
        from radiology_data import SaudiRadiologyDataGenerator
        orchestrator.register_generator('radiology', SaudiRadiologyDataGenerator)
    except ImportError:
        print("Warning: radiology_data.py not found or not refactored yet")

    try:
        from pharmacy_data import SaudiPharmacyDataGenerator
        orchestrator.register_generator('pharmacy', SaudiPharmacyDataGenerator)
    except ImportError:
        print("Warning: pharmacy_data.py not found or not refactored yet")

    try:
        from appointments_data import SaudiAppointmentsDataGenerator
        orchestrator.register_generator('appointments', SaudiAppointmentsDataGenerator)
    except ImportError:
        print("Warning: appointments_data.py not found or not refactored yet")

    try:
        from billing_data import SaudiBillingDataGenerator
        orchestrator.register_generator('billing', SaudiBillingDataGenerator)
    except ImportError:
        print("Warning: billing_data.py not found or not refactored yet")

    try:
        from inpatients_data import SaudiInpatientsDataGenerator
        orchestrator.register_generator('inpatients', SaudiInpatientsDataGenerator)
    except ImportError:
        print("Warning: inpatients_data.py not found or not refactored yet")

    try:
        from inventory_data import SaudiInventoryDataGenerator
        orchestrator.register_generator('inventory', SaudiInventoryDataGenerator)
    except ImportError:
        print("Warning: inventory_data.py not found or not refactored yet")

    # Facility management uses management command
    try:
        from facility_management.management.commands.seed_facility import Command as FacilityCommand
        orchestrator.register_generator('facility_management', FacilityCommand)
    except ImportError:
        print("Warning: facility_management command not available")

    return orchestrator


def main():
    """Main function to run data generation"""
    parser = argparse.ArgumentParser(description='Generate Saudi healthcare test data')
    parser.add_argument('--generators', nargs='*',
                       help='Specific generators to run (default: all in dependency order)')
    parser.add_argument('--list-generators', action='store_true',
                       help='List available generators and exit')
    parser.add_argument('--show-plan', action='store_true',
                       help='Show execution plan and exit')
    parser.add_argument('--validate-only', action='store_true',
                       help='Validate dependencies and exit')
    parser.add_argument('--tenant-id', type=int,
                       help='Tenant ID to generate data for (default: all active tenants)')
    parser.add_argument('--tenant-slug', type=str,
                       help='Tenant slug to generate data for')
    parser.add_argument('--skip-validation', action='store_true',
                       help='Skip dependency validation')

    args = parser.parse_args()

    print("🏥 Saudi Healthcare Data Generation Orchestrator")
    print("=" * 55)

    # Create orchestrator
    orchestrator = create_orchestrator()

    # List generators if requested
    if args.list_generators:
        print("\n📋 Available Generators:")
        for gen in orchestrator.get_available_generators():
            print(f"  - {gen}")
        return

    # Show execution plan if requested
    if args.show_plan:
        generators_to_run = args.generators or orchestrator.execution_order
        plan = orchestrator.get_execution_plan(generators_to_run)

        print("\n📋 Execution Plan:")
        for item in plan:
            deps = ', '.join(item['dependencies']) if item['dependencies'] else 'None'
            print(f"  {item['name']} ({item['class']})")
            print(f"    Dependencies: {deps}")
        return

    # Validate dependencies
    if not args.skip_validation:
        try:
            deps = validate_dependencies()
            print(f"✅ Dependencies validated: {deps['tenants']} tenants, {deps['users']} users")
        except ValueError as e:
            print(f"❌ Dependency validation failed: {e}")
            return

    # Validate only if requested
    if args.validate_only:
        print("✅ Validation complete - all dependencies satisfied")
        return

    # Determine generators to run
    generators_to_run = args.generators or orchestrator.execution_order

    # Prepare kwargs for generators
    generator_kwargs = {}
    if args.tenant_id:
        generator_kwargs['tenant_id'] = args.tenant_id
    if args.tenant_slug:
        generator_kwargs['tenant_slug'] = args.tenant_slug

    # Run generators
    start_time = datetime.now()
    print(f"\n🚀 Starting data generation at {start_time}")
    print(f"📦 Generators to run: {', '.join(generators_to_run)}")

    results = orchestrator.run_all(generators_to_run, **generator_kwargs)

    # Print summary
    end_time = datetime.now()
    duration = end_time - start_time

    print(f"\n🎉 Data generation completed at {end_time}")
    print(f"⏱️  Total duration: {duration}")

    if results:
        print(f"\n📊 Generation Summary:")
        total_created = 0
        for generator_name, result in results.items():
            if isinstance(result, dict):
                count = sum(result.values()) if all(isinstance(v, int) for v in result.values()) else len(result)
                print(f"  {generator_name}: {count} records")
                total_created += count
            else:
                print(f"  {generator_name}: {result}")

        print(f"\n💡 Total records created: {total_created}")
    else:
        print("\n⚠️  No data was generated")

    print("\n✅ Saudi healthcare data generation orchestrator completed successfully!")


if __name__ == "__main__":
    main()