#!/usr/bin/env python3
"""
ALwrity Backend Server - Comprehensive Startup Script
Handles setup, dependency installation, and server startup.
Run this from the backend directory to set up and start the FastAPI server.
"""

import os
import sys
import subprocess
import time
import argparse
from pathlib import Path

def install_requirements():
    """Install required Python packages."""
    print("📦 Installing required packages...")
    
    requirements_file = Path(__file__).parent / "requirements.txt"
    
    try:
        subprocess.check_call([
            sys.executable, "-m", "pip", "install", "-r", str(requirements_file)
        ])
        print("✅ All packages installed successfully!")
        return True
    except subprocess.CalledProcessError as e:
        print(f"❌ Error installing packages: {e}")
        return False

def create_env_file():
    """Create a .env file with default configuration."""
    env_file = Path(__file__).parent / ".env"
    
    if env_file.exists():
        print("ℹ️  .env file already exists")
        return True
    
    print("🔧 Creating .env file with default configuration...")
    
    env_content = """# ALwrity Backend Configuration

# API Keys (Configure these in the onboarding process)
# OPENAI_API_KEY=your_openai_api_key_here
# GEMINI_API_KEY=your_gemini_api_key_here
# ANTHROPIC_API_KEY=your_anthropic_api_key_here
# MISTRAL_API_KEY=your_mistral_api_key_here

# Research API Keys (Optional)
# TAVILY_API_KEY=your_tavily_api_key_here
# SERPER_API_KEY=your_serper_api_key_here
# METAPHOR_API_KEY=your_metaphor_api_key_here
# FIRECRAWL_API_KEY=your_firecrawl_api_key_here

# Server Configuration
HOST=0.0.0.0
PORT=8000
DEBUG=true

# Logging
LOG_LEVEL=INFO
"""
    
    try:
        with open(env_file, 'w') as f:
            f.write(env_content)
        print("✅ .env file created successfully!")
        return True
    except Exception as e:
        print(f"❌ Error creating .env file: {e}")
        return False

def setup_monitoring_tables():
    """Set up API monitoring database tables."""
    print("📊 Setting up API monitoring tables...")
    
    try:
        # Import and run the monitoring table creation
        sys.path.append(str(Path(__file__).parent))
        from scripts.create_monitoring_tables import create_monitoring_tables
        
        if create_monitoring_tables():
            print("✅ API monitoring tables created successfully!")
            return True
        else:
            print("⚠️  Warning: Failed to create monitoring tables, continuing anyway...")
            return True  # Don't fail startup for monitoring issues
            
    except Exception as e:
        print(f"⚠️  Warning: Could not set up monitoring tables: {e}")
        print("   Monitoring will be disabled. Continuing startup...")
        return True  # Don't fail startup for monitoring issues

def setup_monitoring_middleware():
    """Set up monitoring middleware in app.py if not already present."""
    print("🔍 Setting up API monitoring middleware...")
    
    app_file = Path(__file__).parent / "app.py"
    
    if not app_file.exists():
        print("⚠️  Warning: app.py not found, skipping middleware setup")
        return True
    
    try:
        with open(app_file, 'r') as f:
            content = f.read()
        
        # Check if monitoring middleware is already set up
        if "monitoring_middleware" in content:
            print("✅ Monitoring middleware already configured")
            return True
        
        # Add monitoring middleware import and setup
        monitoring_import = "from middleware.monitoring_middleware import monitoring_middleware\n"
        monitoring_setup = "app.middleware(\"http\")(monitoring_middleware)\n"
        
        # Find the right place to add the import (after other imports)
        lines = content.split('\n')
        import_end_index = 0
        
        for i, line in enumerate(lines):
            if line.strip().startswith('import ') or line.strip().startswith('from '):
                import_end_index = i + 1
            elif line.strip() and not line.strip().startswith('#'):
                break
        
        # Insert monitoring import
        lines.insert(import_end_index, monitoring_import)
        
        # Find the right place to add middleware setup (after app creation)
        app_creation_index = -1
        for i, line in enumerate(lines):
            if 'app = FastAPI(' in line or 'app = FastAPI()' in line:
                app_creation_index = i
                break
        
        if app_creation_index != -1:
            # Find the end of app configuration
            setup_index = app_creation_index + 1
            for i in range(app_creation_index + 1, len(lines)):
                if lines[i].strip() and not lines[i].strip().startswith('#'):
                    setup_index = i + 1
                    break
            
            lines.insert(setup_index, monitoring_setup)
        
        # Write back to file
        with open(app_file, 'w') as f:
            f.write('\n'.join(lines))
        
        print("✅ Monitoring middleware configured successfully!")
        return True
        
    except Exception as e:
        print(f"⚠️  Warning: Could not set up monitoring middleware: {e}")
        print("   Monitoring will be disabled. Continuing startup...")
        return True  # Don't fail startup for monitoring issues

def check_dependencies():
    """Check if required dependencies are installed."""
    print("🔍 Checking dependencies...")
    
    required_packages = [
        'fastapi',
        'uvicorn',
        'pydantic',
        'loguru',
        'openai',
        'google.generativeai',
        'anthropic',
        'mistralai'
    ]
    
    missing_packages = []
    
    for package in required_packages:
        try:
            __import__(package.replace('-', '_'))
            print(f"   ✅ {package}")
        except ImportError:
            print(f"   ❌ {package} - MISSING")
            missing_packages.append(package)
    
    if missing_packages:
        print(f"\n❌ Missing packages: {', '.join(missing_packages)}")
        print("Installing missing packages...")
        return install_requirements()
    else:
        print("\n✅ All dependencies are available!")
        return True

def setup_environment():
    """Set up the environment for the backend."""
    print("🔧 Setting up environment...")
    
    # Create necessary directories
    directories = [
        "lib/workspace/alwrity_content",
        "lib/workspace/alwrity_web_research", 
        "lib/workspace/alwrity_prompts",
        "lib/workspace/alwrity_config"
    ]
    
    for directory in directories:
        Path(directory).mkdir(parents=True, exist_ok=True)
        print(f"   ✅ Created directory: {directory}")
    
    # Create .env file if it doesn't exist
    create_env_file()
    
    # Set up monitoring
    setup_monitoring_tables()
    setup_monitoring_middleware()
    
    print("✅ Environment setup complete")

def start_backend(enable_reload=False):
    """Start the backend server."""
    print("🚀 Starting ALwrity Backend...")
    
    # Set environment variables
    os.environ.setdefault("HOST", "0.0.0.0")
    os.environ.setdefault("PORT", "8000")
    
    # Set reload based on argument or environment variable
    if enable_reload:
        os.environ.setdefault("RELOAD", "true")
        print("   🔄 Development mode: Auto-reload enabled")
    else:
        os.environ.setdefault("RELOAD", "false")
        print("   🏭 Production mode: Auto-reload disabled")
    
    host = os.getenv("HOST", "0.0.0.0")
    port = int(os.getenv("PORT", "8000"))
    reload = os.getenv("RELOAD", "false").lower() == "true"
    
    print(f"   📍 Host: {host}")
    print(f"   🔌 Port: {port}")
    print(f"   🔄 Reload: {reload}")
    
    try:
        # Import and run the app
        from app import app
        import uvicorn
        
        print("\n🌐 Backend is starting...")
        print("   📖 API Documentation: http://localhost:8000/api/docs")
        print("   🔍 Health Check: http://localhost:8000/health")
        print("   📊 ReDoc: http://localhost:8000/api/redoc")
        print("   📈 API Monitoring: http://localhost:8000/api/content-planning/monitoring/health")
        print("\n⏹️  Press Ctrl+C to stop the server")
        print("=" * 60)
        print("\n💡 Usage:")
        print("   Production mode (default): python start_alwrity_backend.py")
        print("   Development mode: python start_alwrity_backend.py --dev")
        print("   With auto-reload: python start_alwrity_backend.py --reload")
        print("=" * 60)
        
        uvicorn.run(
            "app:app",
            host=host,
            port=port,
            reload=reload,
            reload_excludes=[
                "*.pyc",
                "*.pyo", 
                "*.pyd",
                "__pycache__",
                "*.log",
                "*.sqlite",
                "*.db",
                "*.tmp",
                "*.temp",
                "test_*.py",
                "temp_*.py",
                "monitoring_data_service.py",
                "test_monitoring_save.py",
                "*.json",
                "*.yaml",
                "*.yml",
                ".env*",
                "logs/*",
                "cache/*",
                "tmp/*",
                "temp/*",
                "middleware/*",
                "models/*",
                "scripts/*"
            ],
            reload_includes=[
                "app.py",
                "api/**/*.py",
                "services/**/*.py"
            ],
            log_level="info"
        )
        
    except KeyboardInterrupt:
        print("\n\n🛑 Backend stopped by user")
    except Exception as e:
        print(f"\n❌ Error starting backend: {e}")
        return False
    
    return True

def main():
    """Main function to set up and start the backend."""
    # Parse command line arguments
    parser = argparse.ArgumentParser(description="ALwrity Backend Server")
    parser.add_argument("--reload", action="store_true", help="Enable auto-reload for development")
    parser.add_argument("--dev", action="store_true", help="Enable development mode (auto-reload)")
    args = parser.parse_args()
    
    print("🎯 ALwrity Backend Server")
    print("=" * 40)
    
    # Check if we're in the right directory
    if not os.path.exists("app.py"):
        print("❌ Error: app.py not found. Please run this script from the backend directory.")
        print("   Current directory:", os.getcwd())
        print("   Expected files:", [f for f in os.listdir('.') if f.endswith('.py')])
        return False
    
    # Check and install dependencies
    if not check_dependencies():
        print("❌ Failed to install dependencies")
        return False
    
    # Setup environment
    setup_environment()
    
    # Start backend with reload option
    enable_reload = args.reload or args.dev
    return start_backend(enable_reload=enable_reload)

if __name__ == "__main__":
    success = main()
    if not success:
        sys.exit(1)