/// GET /health - Overall health status
async fn health_check(
    State(state): State<Arc<AppState>>,
) -> Result<Json<HealthStatus>, StatusCode> {
    let mut status = HealthStatus {
        status: "healthy".to_string(),
        version: env!("CARGO_PKG_VERSION").to_string(),
        uptime_seconds: state.start_time.elapsed().as_secs(),
        checks: HashMap::new(),
    };
    
    // Check Redis
    let redis_check = check_redis(&state.session_manager).await;
    if redis_check.status != "ok" {
        status.status = "degraded".to_string();
    }
    status.checks.insert("redis".to_string(), redis_check);
    
    // Check NATS
    let nats_check = check_nats(&state.media_metrics).await;
    if nats_check.status != "ok" {
        status.status = "degraded".to_string();
    }
    status.checks.insert("nats".to_string(), nats_check);
    
    // Check FairPlay SDK
    #[cfg(feature = "fairplay")]
    if let Some(handler) = &state.media_api_state.fairplay_handler {
        let fairplay_check = check_fairplay(handler).await;
        if fairplay_check.status != "ok" {
            status.status = "degraded".to_string();
        }
        status.checks.insert("fairplay".to_string(), fairplay_check);
    }
    
    if status.status == "healthy" {
        Ok(Json(status))
    } else {
        Err(StatusCode::SERVICE_UNAVAILABLE)
    }
}

/// GET /health/ready - Readiness probe
async fn readiness_check(
    State(state): State<Arc<AppState>>,
) -> Result<Json<ReadinessStatus>, StatusCode> {
    // Check if application is ready to serve traffic
    
    // Check Redis connection
    if state.session_manager.health_check().await.is_err() {
        return Ok(Json(ReadinessStatus {
            ready: false,
            reason: Some("Redis not available".to_string()),
        }));
    }
    
    // Check if shutting down
    if state.is_shutting_down.load(Ordering::Relaxed) {
        return Ok(Json(ReadinessStatus {
            ready: false,
            reason: Some("Server is shutting down".to_string()),
        }));
    }
    
    Ok(Json(ReadinessStatus {
        ready: true,
        reason: None,
    }))
}

/// GET /health/live - Liveness probe
async fn liveness_check() -> Json<LivenessStatus> {
    Json(LivenessStatus { alive: true })
}

use tokio::signal;
use std::sync::atomic::{AtomicBool, Ordering};

async fn shutdown_signal(is_shutting_down: Arc<AtomicBool>) {
    let ctrl_c = async {
        signal::ctrl_c()
            .await
            .expect("failed to install Ctrl+C handler");
    };
    
    #[cfg(unix)]
    let terminate = async {
        signal::unix::signal(signal::unix::SignalKind::terminate())
            .expect("failed to install signal handler")
            .recv()
            .await;
    };
    
    tokio::select! {
        _ = ctrl_c => {
            log::info!("Received Ctrl+C signal");
        },
        _ = terminate => {
            log::info!("Received SIGTERM signal");
        },
    }
    
    is_shutting_down.store(true, Ordering::Relaxed);
    log::info!("Shutdown signal received, starting graceful shutdown");
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // ... initialization ...
    
    let is_shutting_down = Arc::new(AtomicBool::new(false));
    
    // Start server with graceful shutdown
    let server = axum::Server::bind(&addr)
        .serve(app.into_make_service_with_connect_info::<SocketAddr>())
        .with_graceful_shutdown(shutdown_signal(is_shutting_down.clone()));
    
    log::info!("Server listening on {}", addr);
    
    if let Err(e) = server.await {
        log::error!("Server error: {}", e);
    }
    
    // Graceful shutdown sequence
    log::info!("Server stopped accepting new connections");
    
    // Wait for active sessions to complete (with timeout)
    let shutdown_timeout = Duration::from_secs(30);
    log::info!("Waiting up to {:?} for active sessions to complete...", shutdown_timeout);
    
    tokio::select! {
        _ = session_manager.wait_for_completion() => {
            log::info!("All sessions completed gracefully");
        }
        _ = tokio::time::sleep(shutdown_timeout) => {
            let remaining = session_manager.get_active_session_count().await?;
            log::warn!("Shutdown timeout reached, {} sessions still active", remaining);
        }
    }
    
    log::info!("Graceful shutdown complete");
    Ok(())
}