use anyhow::Result;
use axum::{Router, routing::get};
use std::net::SocketAddr;
use std::sync::Arc;
use tracing::{info, error};

use llm_proxy::{
    config::AppConfig, 
    state::AppState,
    providers::{
        ProviderManager, 
        openai::OpenAIProvider,
        gemini::GeminiProvider,
        deepseek::DeepSeekProvider,
        grok::GrokProvider,
    },
    database,
    server,
    dashboard,
    rate_limiting::{RateLimitManager, RateLimiterConfig, CircuitBreakerConfig},
};

#[tokio::main]
async fn main() -> Result<()> {
    // Initialize tracing (logging)
    tracing_subscriber::fmt()
        .with_max_level(tracing::Level::INFO)
        .with_target(false)
        .init();

    info!("Starting LLM Proxy Gateway v{}", env!("CARGO_PKG_VERSION"));

    // Load configuration
    let config = AppConfig::load().await?;
    info!("Configuration loaded from {:?}", config.config_path);

    // Initialize database connection pool
    let db_pool = database::init(&config.database).await?;
    info!("Database initialized at {:?}", config.database.path);

    // Initialize provider manager with configured providers
    let mut provider_manager = ProviderManager::new();
    
    // Initialize OpenAI
    if config.providers.openai.enabled {
        match OpenAIProvider::new(&config.providers.openai, &config) {
            Ok(p) => {
                provider_manager.add_provider(Arc::new(p));
                info!("OpenAI provider initialized");
            }
            Err(e) => error!("Failed to initialize OpenAI provider: {}", e),
        }
    }
    
    // Initialize Gemini
    if config.providers.gemini.enabled {
        match GeminiProvider::new(&config.providers.gemini, &config) {
            Ok(p) => {
                provider_manager.add_provider(Arc::new(p));
                info!("Gemini provider initialized");
            }
            Err(e) => error!("Failed to initialize Gemini provider: {}", e),
        }
    }
    
    // Initialize DeepSeek
    if config.providers.deepseek.enabled {
        match DeepSeekProvider::new(&config.providers.deepseek, &config) {
            Ok(p) => {
                provider_manager.add_provider(Arc::new(p));
                info!("DeepSeek provider initialized");
            }
            Err(e) => error!("Failed to initialize DeepSeek provider: {}", e),
        }
    }
    
    // Initialize Grok
    if config.providers.grok.enabled {
        match GrokProvider::new(&config.providers.grok, &config) {
            Ok(p) => {
                provider_manager.add_provider(Arc::new(p));
                info!("Grok provider initialized");
            }
            Err(e) => error!("Failed to initialize Grok provider: {}", e),
        }
    }

    // Create rate limit manager
    let rate_limit_manager = RateLimitManager::new(
        RateLimiterConfig::default(),
        CircuitBreakerConfig::default(),
    );
    
    // Fetch model registry from models.dev
    let model_registry = match llm_proxy::utils::registry::fetch_registry().await {
        Ok(registry) => registry,
        Err(e) => {
            error!("Failed to fetch model registry: {}. Using empty registry.", e);
            llm_proxy::models::registry::ModelRegistry { providers: std::collections::HashMap::new() }
        }
    };
    
    // Create application state
    let state = AppState::new(provider_manager, db_pool, rate_limit_manager, model_registry);

    // Create application router
    let app = Router::new()
        .route("/health", get(health_check))
        .route("/", get(root))
        .merge(server::router(state.clone()))
        .merge(dashboard::router(state.clone()));

    // Start server
    let addr = SocketAddr::from(([0, 0, 0, 0], config.server.port));
    info!("Server listening on http://{}", addr);

    let listener = tokio::net::TcpListener::bind(&addr).await?;
    axum::serve(listener, app).await?;

    Ok(())
}

async fn health_check() -> &'static str {
    "OK"
}

async fn root() -> &'static str {
    "LLM Proxy Gateway - Unified interface for OpenAI, Gemini, DeepSeek, and Grok"
}