use crate::config::Config;
use crate::database::Database;
use crate::keys::KeyManager;
use crate::repositories::*;
use crate::services::implementations::*;
use crate::services::*;
use anyhow::Result;
use std::sync::{Arc, Mutex};

/// Dependency injection container for all services and repositories
pub struct ServiceContainer {
    // Repositories
    pub client_repository: Arc<dyn ClientRepository>,
    pub auth_code_repository: Arc<dyn AuthCodeRepository>,
    pub token_repository: Arc<dyn TokenRepository>,
    pub audit_repository: Arc<dyn AuditRepository>,
    pub rate_repository: Arc<dyn RateRepository>,

    // Services
    pub client_authenticator: Arc<dyn ClientAuthenticator>,
    pub rate_limiter: Arc<dyn RateLimiter>,
    pub audit_logger: Arc<dyn AuditLogger>,
    pub token_generator: Arc<dyn TokenGenerator>,

    // Core components
    pub key_manager: Arc<Mutex<KeyManager>>,
    pub config: Config,
}

impl ServiceContainer {
    pub fn new(config: Config, database: Arc<Mutex<Database>>) -> Result<Self> {
        // Create repositories
        let client_repository: Arc<dyn ClientRepository> =
            Arc::new(SqliteClientRepository::new(database.clone()));
        let auth_code_repository: Arc<dyn AuthCodeRepository> =
            Arc::new(SqliteAuthCodeRepository::new(database.clone()));
        let token_repository: Arc<dyn TokenRepository> =
            Arc::new(SqliteTokenRepository::new(database.clone()));
        let audit_repository: Arc<dyn AuditRepository> =
            Arc::new(SqliteAuditRepository::new(database.clone()));
        let rate_repository: Arc<dyn RateRepository> =
            Arc::new(SqliteRateRepository::new(database.clone()));

        // Create key manager
        let key_manager = Arc::new(Mutex::new(KeyManager::new(database.clone())?));

        // Create services
        let client_authenticator: Arc<dyn ClientAuthenticator> =
            Arc::new(DefaultClientAuthenticator::new(client_repository.clone()));
        let rate_limiter: Arc<dyn RateLimiter> = Arc::new(DefaultRateLimiter::new(
            rate_repository.clone(),
            config.clone(),
        ));
        let audit_logger: Arc<dyn AuditLogger> = Arc::new(DefaultAuditLogger::new(
            audit_repository.clone(),
            config.clone(),
        ));
        let token_generator: Arc<dyn TokenGenerator> = Arc::new(DefaultTokenGenerator::new(
            key_manager.clone(),
            config.clone(),
        ));

        Ok(Self {
            client_repository,
            auth_code_repository,
            token_repository,
            audit_repository,
            rate_repository,
            client_authenticator,
            rate_limiter,
            audit_logger,
            token_generator,
            key_manager,
            config,
        })
    }

    /// Get JWKS from the key manager
    pub fn get_jwks(&self) -> String {
        let key_manager = self.key_manager.lock().unwrap();
        match key_manager.get_jwks() {
            Ok(jwks) => serde_json::to_string(&jwks).unwrap_or_else(|_| "{}".to_string()),
            Err(_) => serde_json::json!({"keys": []}).to_string(),
        }
    }

    /// Cleanup expired data
    pub fn cleanup_expired_data(&self) -> Result<()> {
        // Cleanup expired authorization codes
        let _ = self.auth_code_repository.cleanup_expired_codes();

        // Cleanup expired tokens
        let _ = self.token_repository.cleanup_expired_tokens();

        // Cleanup old audit logs (keep for 30 days)
        let _ = self.audit_repository.cleanup_old_audit_logs(30);

        // Cleanup old rate limits
        let _ = self.rate_repository.cleanup_old_rate_limits();

        Ok(())
    }
}