#!/usr/bin/env python3
"""
Elizabeth Main Entry Point
Central hub for all Elizabeth versions and capabilities
"""

import os
import sys
import json
from pathlib import Path
from typing import Dict, Any

# Add versions to path
sys.path.insert(0, str(Path(__file__).parent.parent / "versions"))

def load_version(version: str = "v0.0.2") -> Any:
    """Load specific Elizabeth version"""
    try:
        if version == "v0.0.1":
            from v0_0_1.elizabeth_full import ElizabethFull
            return ElizabethFull()
        elif version == "v0.0.2":
            from v0_0_2.elizabeth_enhanced import ElizabethEnhanced
            return ElizabethEnhanced()
        else:
            raise ValueError(f"Unknown version: {version}")
    except ImportError as e:
        print(f"Error loading version {version}: {e}")
        return None

def list_available_versions() -> Dict[str, Any]:
    """List all available Elizabeth versions"""
    versions_dir = Path(__file__).parent.parent / "versions"
    versions = {}
    
    for version_dir in versions_dir.iterdir():
        if version_dir.is_dir():
            version_name = version_dir.name
            version_files = [f.name for f in version_dir.iterdir() if f.is_file()]
            versions[version_name] = {
                "files": version_files,
                "path": str(version_dir)
            }
    
    return versions

def main():
    """Main entry point"""
    import argparse
    
    parser = argparse.ArgumentParser(description="Elizabeth AI System")
    parser.add_argument("--version", "-v", default="v0.0.2", 
                       help="Elizabeth version to use (v0.0.1, v0.0.2)")
    parser.add_argument("--interactive", "-i", action="store_true",
                       help="Run in interactive mode")
    parser.add_argument("--status", "-s", action="store_true",
                       help="Show system status")
    parser.add_argument("--list-versions", "-l", action="store_true",
                       help="List available versions")
    parser.add_argument("message", nargs="*", help="Message to send to Elizabeth")
    
    args = parser.parse_args()
    
    if args.list_versions:
        versions = list_available_versions()
        print("Available Elizabeth Versions:")
        for version, info in versions.items():
            print(f"  {version}: {info['files']}")
        return
    
    # Load requested version
    elizabeth = load_version(args.version)
    if not elizabeth:
        print(f"Failed to load version {args.version}")
        return 1
    
    if args.status:
        status = elizabeth.get_system_status()
        print(json.dumps(status, indent=2))
        return
    
    if args.interactive or not args.message:
        if hasattr(elizabeth, 'run_enhanced_interactive'):
            elizabeth.run_enhanced_interactive()
        elif hasattr(elizabeth, 'run_interactive'):
            elizabeth.run_interactive()
        else:
            print("Error: No interactive method found for this version")
    else:
        message = " ".join(args.message)
        thinking_blocks, response = elizabeth.chat_with_full_capabilities(message)
        elizabeth.display_response(thinking_blocks, response)

if __name__ == "__main__":
    main()