use std::sync::Arc;

use axum_test::TestServer;

use crate::routes::api::{ApiState, LocalApiState};
use crate::service::proxy::*;
use crate::service::proxy::{
    access_rule::MockAccessRuleService,
    cache_zone::MockCacheZoneService,
    config_inheritance::MockConfigInheritanceService,
    limit_rule::MockLimitRuleService,
    limit_zone::MockLimitZoneService,
    location_block::MockLocationBlockService,
    log_setting::MockLogSettingService,
    proxy_setting::MockProxySettingService,
    rewrite_rule::MockRewriteRuleService,
    server_block::MockServerBlockService,
    ssl_certificate::MockSslCertificateService,
    upstream::MockUpstreamService,
};

pub(crate) struct TestProxyApiBuilder {
    proxy_service: Option<MockProxyServiceTrait>,
    server_block_service: Option<MockServerBlockService>,
    upstream_service: Option<MockUpstreamService>,
    location_block_service: Option<MockLocationBlockService>,
    access_rule_service: Option<MockAccessRuleService>,
    cache_zone_service: Option<MockCacheZoneService>,
    limit_rule_service: Option<MockLimitRuleService>,
    limit_zone_service: Option<MockLimitZoneService>,
    log_setting_service: Option<MockLogSettingService>,
    proxy_setting_service: Option<MockProxySettingService>,
    rewrite_rule_service: Option<MockRewriteRuleService>,
    ssl_certificate_service: Option<MockSslCertificateService>,
    config_inheritance_service: Option<MockConfigInheritanceService>,
}

impl TestProxyApiBuilder {
    pub fn new() -> Self {
        Self {
            proxy_service: None,
            server_block_service: None,
            upstream_service: None,
            location_block_service: None,
            access_rule_service: None,
            cache_zone_service: None,
            limit_rule_service: None,
            limit_zone_service: None,
            log_setting_service: None,
            proxy_setting_service: None,
            rewrite_rule_service: None,
            ssl_certificate_service: None,
            config_inheritance_service: None,
        }
    }

    pub fn with_proxy(mut self, mock: MockProxyServiceTrait) -> Self {
        self.proxy_service = Some(mock);
        self
    }

    pub fn with_server_block(mut self, mock: MockServerBlockService) -> Self {
        self.server_block_service = Some(mock);
        self
    }

    pub fn with_upstream(mut self, mock: MockUpstreamService) -> Self {
        self.upstream_service = Some(mock);
        self
    }

    pub fn with_location_block(mut self, mock: MockLocationBlockService) -> Self {
        self.location_block_service = Some(mock);
        self
    }

    pub fn with_access_rule(mut self, mock: MockAccessRuleService) -> Self {
        self.access_rule_service = Some(mock);
        self
    }

    pub fn with_cache_zone(mut self, mock: MockCacheZoneService) -> Self {
        self.cache_zone_service = Some(mock);
        self
    }

    pub fn with_limit_rule(mut self, mock: MockLimitRuleService) -> Self {
        self.limit_rule_service = Some(mock);
        self
    }

    pub fn with_limit_zone(mut self, mock: MockLimitZoneService) -> Self {
        self.limit_zone_service = Some(mock);
        self
    }

    pub fn with_log_setting(mut self, mock: MockLogSettingService) -> Self {
        self.log_setting_service = Some(mock);
        self
    }

    pub fn with_proxy_setting(mut self, mock: MockProxySettingService) -> Self {
        self.proxy_setting_service = Some(mock);
        self
    }

    pub fn with_rewrite_rule(mut self, mock: MockRewriteRuleService) -> Self {
        self.rewrite_rule_service = Some(mock);
        self
    }

    pub fn with_ssl_certificate(mut self, mock: MockSslCertificateService) -> Self {
        self.ssl_certificate_service = Some(mock);
        self
    }

    pub fn with_config_inheritance(mut self, mock: MockConfigInheritanceService) -> Self {
        self.config_inheritance_service = Some(mock);
        self
    }

    pub async fn build(self) -> TestServer {
        let state = ApiState {
            proxy_service: Arc::new(self.proxy_service.unwrap_or_else(MockProxyServiceTrait::new)),
            server_block_service: Arc::new(
                self.server_block_service.unwrap_or_else(MockServerBlockService::new),
            ),
            upstream_service: Arc::new(
                self.upstream_service.unwrap_or_else(MockUpstreamService::new),
            ),
            location_block_service: Arc::new(
                self.location_block_service
                    .unwrap_or_else(MockLocationBlockService::new),
            ),
            access_rule_service: Arc::new(
                self.access_rule_service.unwrap_or_else(MockAccessRuleService::new),
            ),
            cache_zone_service: Arc::new(
                self.cache_zone_service.unwrap_or_else(MockCacheZoneService::new),
            ),
            limit_rule_service: Arc::new(
                self.limit_rule_service.unwrap_or_else(MockLimitRuleService::new),
            ),
            limit_zone_service: Arc::new(
                self.limit_zone_service.unwrap_or_else(MockLimitZoneService::new),
            ),
            log_setting_service: Arc::new(
                self.log_setting_service.unwrap_or_else(MockLogSettingService::new),
            ),
            proxy_setting_service: Arc::new(
                self.proxy_setting_service
                    .unwrap_or_else(MockProxySettingService::new),
            ),
            rewrite_rule_service: Arc::new(
                self.rewrite_rule_service
                    .unwrap_or_else(MockRewriteRuleService::new),
            ),
            ssl_certificate_service: Arc::new(
                self.ssl_certificate_service
                    .unwrap_or_else(MockSslCertificateService::new),
            ),
            config_inheritance_service: Arc::new(
                self.config_inheritance_service
                    .unwrap_or_else(MockConfigInheritanceService::new),
            ),
            // Keep agent_service for ApiState completeness; not used by proxy routes
            agent_service: Arc::new(crate::service::agent::MockAgentService::new()),
        };
        let app = super::get_router()
            .await
            .with_state(LocalApiState(Arc::new(state)));
        TestServer::new(app)
    }
}