use anyhow::Result;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::path::PathBuf;

/// Complete Caddy configuration structure for 100% compatibility
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CaddyConfig {
    /// Global admin settings
    pub admin: Option<AdminConfig>,
    /// App configurations
    pub apps: Apps,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AdminConfig {
    /// Admin endpoint listen address
    pub listen: Option<String>,
    /// API origins
    pub origins: Option<Vec<String>>,
    /// Remote admin endpoint
    pub remote: Option<RemoteAdmin>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RemoteAdmin {
    pub endpoint: String,
    pub access_id: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Apps {
    /// HTTP app configuration
    pub http: HttpApp,
    /// TLS app configuration  
    pub tls: Option<TlsApp>,
    /// PKI app configuration
    pub pki: Option<PkiApp>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HttpApp {
    /// HTTP servers configuration
    pub servers: HashMap<String, HttpServer>,
    /// Grace period for graceful shutdown
    pub grace_period: Option<String>,
    /// Shutdown delay
    pub shutdown_delay: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HttpServer {
    /// Listen addresses
    pub listen: Vec<String>,
    /// Routes configuration
    pub routes: Vec<Route>,
    /// Error handling
    pub errors: Option<ErrorHandling>,
    /// TLS connection policies
    pub tls_connection_policies: Option<Vec<TlsConnectionPolicy>>,
    /// Automatic HTTPS
    pub automatic_https: Option<AutomaticHttpsConfig>,
    /// Protocol configuration
    pub protocols: Option<Vec<String>>,
    /// Strict SNI host matching
    pub strict_sni_host: Option<bool>,
    /// Request timeout
    pub request_timeout: Option<String>,
    /// Read timeout
    pub read_timeout: Option<String>,
    /// Read header timeout
    pub read_header_timeout: Option<String>,
    /// Write timeout
    pub write_timeout: Option<String>,
    /// Idle timeout
    pub idle_timeout: Option<String>,
    /// Max header bytes
    pub max_header_bytes: Option<i32>,
    /// Enable H2C
    pub allow_h2c: Option<bool>,
    /// Experimental HTTP/3
    pub experimental_http3: Option<bool>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Route {
    /// Route matchers
    #[serde(rename = "match")]
    pub match_rules: Option<Vec<Matcher>>,
    /// Handler chain
    pub handle: Vec<Handler>,
    /// Terminal route (default: true)
    pub terminal: Option<bool>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "handler")]
pub enum Handler {
    /// Authentication handler
    #[serde(rename = "authentication")]
    Authentication {
        providers: HashMap<String, AuthProvider>,
    },
    /// Basic auth handler  
    #[serde(rename = "http_basic_auth")]
    BasicAuth {
        accounts: Vec<BasicAuthAccount>,
        realm: Option<String>,
        hash: Option<BasicAuthHash>,
    },
    /// Static file server
    #[serde(rename = "file_server")]
    FileServer {
        root: Option<String>,
        hide: Option<Vec<String>>,
        index_names: Option<Vec<String>>,
        browse: Option<BrowseConfig>,
        precompressed: Option<PrecompressedConfig>,
        status_code: Option<i32>,
        canonical_uris: Option<bool>,
        pass_thru: Option<bool>,
    },
    /// Reverse proxy
    #[serde(rename = "reverse_proxy")]
    ReverseProxy {
        upstreams: Vec<Upstream>,
        load_balancing: Option<LoadBalancing>,
        health_checks: Option<HealthChecks>,
        circuit_breaker: Option<CircuitBreaker>,
        headers: Option<HeaderOperations>,
        transport: Option<Transport>,
        handle_response: Option<Vec<ResponseHandler>>,
        trusted_proxies: Option<Vec<String>>,
        replace_status: Option<Vec<StatusReplacement>>,
        buffer_requests: Option<bool>,
        buffer_responses: Option<bool>,
        max_buffer_size: Option<i64>,
        stream_timeout: Option<String>,
        stream_close_delay: Option<String>,
        flush_interval: Option<String>,
    },
    /// Static response
    #[serde(rename = "static_response")]
    StaticResponse {
        status_code: Option<i32>,
        headers: Option<HashMap<String, Vec<String>>>,
        body: Option<String>,
        close: Option<bool>,
    },
    /// Redirect handler
    #[serde(rename = "redirect")]
    Redirect {
        to: Option<String>,
        status_code: Option<i32>,
    },
    /// Rewrite handler
    #[serde(rename = "rewrite")]
    Rewrite {
        uri: Option<String>,
        strip_path_prefix: Option<String>,
        strip_path_suffix: Option<String>,
        uri_substring: Option<Vec<UriSubstring>>,
        method: Option<String>,
    },
    /// Headers handler
    #[serde(rename = "headers")]
    Headers {
        request: Option<HeaderOperations>,
        response: Option<HeaderOperations>,
    },
    /// Copy response headers handler
    #[serde(rename = "copy_response_headers")]
    CopyResponseHeaders {
        include: Option<Vec<String>>,
        exclude: Option<Vec<String>>,
    },
    /// Request body handler
    #[serde(rename = "request_body")]
    RequestBody {
        max_size: Option<i64>,
    },
    /// Response compression
    #[serde(rename = "encode")]
    Encode {
        encodings: Option<HashMap<String, EncodingConfig>>,
        prefer: Option<Vec<String>>,
        minimum_length: Option<i64>,
    },
    /// Template handler
    #[serde(rename = "templates")]
    Templates {
        file_root: Option<String>,
        mime_types: Option<Vec<String>>,
        delimiters: Option<Vec<String>>,
    },
    /// Subroute handler
    #[serde(rename = "subroute")]
    Subroute {
        routes: Vec<Route>,
        errors: Option<ErrorHandling>,
    },
    /// Error handler
    #[serde(rename = "error")]
    Error {
        error: Option<String>,
        status_code: Option<i32>,
    },
    /// Map handler
    #[serde(rename = "map")]
    Map {
        source: String,
        destinations: HashMap<String, String>,
        default: Option<String>,
    },
    /// Rate limit handler
    #[serde(rename = "rate_limit")]
    RateLimit {
        key: Option<String>,
        rate: Option<String>,
        burst: Option<i32>,
        window: Option<String>,
    },
    /// IP whitelist handler
    #[serde(rename = "ip_whitelist")]
    IpWhitelist {
        source: Option<String>,
        rules: Vec<IpRule>,
    },
    /// Request ID handler
    #[serde(rename = "request_id")]
    RequestId {
        header_name: Option<String>,
        size: Option<i32>,
    },
    /// Metrics handler
    #[serde(rename = "metrics")]
    Metrics {
        path: Option<String>,
    },
    /// Health check handler
    #[serde(rename = "health")]
    Health {
        path: Option<String>,
    },
    /// Vars handler
    #[serde(rename = "vars")]
    Vars {
        #[serde(flatten)]
        variables: HashMap<String, String>,
    },
    /// Custom handler
    #[serde(rename = "custom")]
    Custom {
        module: String,
        #[serde(flatten)]
        config: HashMap<String, serde_json::Value>,
    },
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum Matcher {
    /// Host matcher
    Host(Vec<String>),
    /// Path matcher
    Path(Vec<String>),
    /// Path regexp matcher
    PathRegexp(Vec<String>),
    /// Method matcher
    Method(Vec<String>),
    /// Query matcher
    Query(HashMap<String, Vec<String>>),
    /// Header matcher
    Header(HashMap<String, Vec<String>>),
    /// Header regexp matcher
    HeaderRegexp(HashMap<String, Vec<String>>),
    /// Remote IP matcher
    RemoteIp {
        ranges: Vec<String>,
        forwarded: Option<bool>,
    },
    /// Protocol matcher
    Protocol(String),
    /// File matcher
    File {
        root: Option<String>,
        files: Vec<String>,
        try_files: Option<Vec<String>>,
        try_policy: Option<String>,
        split_path: Option<Vec<String>>,
    },
    /// Expression matcher
    Expression {
        expr: String,
    },
    /// Vars matcher
    Vars(HashMap<String, String>),
    /// Not matcher
    Not {
        #[serde(rename = "match")]
        matcher: Box<Matcher>,
    },
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AuthProvider {
    #[serde(flatten)]
    pub config: HashMap<String, serde_json::Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BasicAuthAccount {
    pub username: String,
    pub password: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BasicAuthHash {
    pub algorithm: Option<String>,
    pub cost: Option<i32>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BrowseConfig {
    pub template: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PrecompressedConfig {
    pub encodings: Option<Vec<String>>,
    pub min_length: Option<i64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Upstream {
    pub dial: String,
    pub max_requests: Option<i32>,
    pub max_requests_per_host: Option<i32>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LoadBalancing {
    pub selection_policy: Option<SelectionPolicy>,
    pub try_duration: Option<String>,
    pub try_interval: Option<String>,
    pub unhealthy_request_count: Option<i32>,
    pub unhealthy_status: Option<Vec<i32>>,
    pub unhealthy_latency: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SelectionPolicy {
    RoundRobin,
    LeastConn,
    Random,
    First,
    IpHash,
    UriHash,
    Header,
    Cookie,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HealthChecks {
    pub active: Option<ActiveHealthCheck>,
    pub passive: Option<PassiveHealthCheck>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ActiveHealthCheck {
    pub uri: String,
    pub port: Option<i32>,
    pub headers: Option<HashMap<String, Vec<String>>>,
    pub interval: Option<String>,
    pub timeout: Option<String>,
    pub max_size: Option<i64>,
    pub expect_status: Option<i32>,
    pub expect_body: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PassiveHealthCheck {
    pub unhealthy_status: Option<Vec<i32>>,
    pub unhealthy_latency: Option<String>,
    pub unhealthy_request_count: Option<i32>,
    pub healthy_count: Option<i32>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CircuitBreaker {
    pub trip_duration: Option<String>,
    pub recovery_duration: Option<String>,
    pub failure_threshold: Option<f64>,
    pub success_threshold: Option<f64>,
    pub latency_threshold: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HeaderOperations {
    pub add: Option<HashMap<String, Vec<String>>>,
    pub set: Option<HashMap<String, Vec<String>>>,
    pub delete: Option<Vec<String>>,
    pub replace: Option<HashMap<String, Vec<HeaderReplacement>>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HeaderReplacement {
    pub search: String,
    pub replace: String,
    pub search_regexp: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Transport {
    pub protocol: Option<String>,
    pub tls: Option<TransportTls>,
    pub keep_alive: Option<KeepAlive>,
    pub compression: Option<bool>,
    pub max_conns_per_host: Option<i32>,
    pub dial_timeout: Option<String>,
    pub dial_fallback_delay: Option<String>,
    pub response_header_timeout: Option<String>,
    pub expect_continue_timeout: Option<String>,
    pub max_response_header_size: Option<i64>,
    pub write_buffer_size: Option<i32>,
    pub read_buffer_size: Option<i32>,
    pub versions: Option<Vec<String>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TransportTls {
    pub client_certificate_file: Option<String>,
    pub client_certificate_key_file: Option<String>,
    pub client_certificate_automate: Option<String>,
    pub root_ca_pool: Option<Vec<String>>,
    pub root_ca_pem_files: Option<Vec<String>>,
    pub server_name: Option<String>,
    pub insecure_skip_verify: Option<bool>,
    pub handshake_timeout: Option<String>,
    pub versions: Option<Vec<String>>,
    pub cipher_suites: Option<Vec<String>>,
    pub curves: Option<Vec<String>>,
    pub alpn: Option<Vec<String>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct KeepAlive {
    pub enabled: Option<bool>,
    pub probe_interval: Option<String>,
    pub max_idle_conns: Option<i32>,
    pub max_idle_conns_per_host: Option<i32>,
    pub idle_conn_timeout: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResponseHandler {
    #[serde(rename = "match")]
    pub match_rules: Option<ResponseMatcher>,
    pub routes: Vec<Route>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ResponseMatcher {
    pub status_code: Option<Vec<i32>>,
    pub headers: Option<HashMap<String, Vec<String>>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StatusReplacement {
    pub status_code: i32,
    pub with: i32,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UriSubstring {
    pub find: String,
    pub replace: String,
    pub limit: Option<i32>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EncodingConfig {
    #[serde(flatten)]
    pub config: HashMap<String, serde_json::Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IpRule {
    pub action: String,
    pub rule: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ErrorHandling {
    pub routes: Vec<Route>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TlsConnectionPolicy {
    #[serde(rename = "match")]
    pub match_rules: Option<TlsConnectionMatcher>,
    pub certificate_selection: Option<CertificateSelection>,
    pub cipher_suites: Option<Vec<String>>,
    pub curves: Option<Vec<String>>,
    pub alpn: Option<Vec<String>>,
    pub protocols: Option<ProtocolRange>,
    pub client_authentication: Option<ClientAuthentication>,
    pub insecure_secrets_log: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TlsConnectionMatcher {
    pub sni: Option<Vec<String>>,
    pub remote_ip: Option<RemoteIpMatcher>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RemoteIpMatcher {
    pub ranges: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CertificateSelection {
    pub any_tag: Option<Vec<String>>,
    pub all_tags: Option<Vec<String>>,
    pub public_key_algorithm: Option<String>,
    pub serial_number: Option<String>,
    pub subject_organization: Option<String>,
    pub subject: Option<Vec<String>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProtocolRange {
    pub min: Option<String>,
    pub max: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ClientAuthentication {
    pub mode: Option<String>,
    pub trusted_ca_certs: Option<Vec<String>>,
    pub trusted_ca_certs_pem_files: Option<Vec<String>>,
    pub trusted_leaf_certs: Option<Vec<String>>,
    pub trusted_leaf_certs_pem_files: Option<Vec<String>>,
    pub verify_client_certificate: Option<bool>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AutomaticHttpsConfig {
    pub disable: Option<bool>,
    pub disable_redirects: Option<bool>,
    pub disable_certs: Option<bool>,
    pub ignore_loaded_certs: Option<bool>,
    pub skip: Option<Vec<String>>,
    pub skip_certificates: Option<Vec<String>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TlsApp {
    pub automation: Option<AutomationConfig>,
    pub session_tickets: Option<SessionTicketsConfig>,
    pub certificates: Option<CertificatesConfig>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AutomationConfig {
    pub policies: Vec<AutomationPolicy>,
    pub on_demand: Option<OnDemandConfig>,
    pub ocsp_interval: Option<String>,
    pub renew_ahead: Option<String>,
    pub storage: Option<StorageConfig>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AutomationPolicy {
    pub subjects: Option<Vec<String>>,
    pub issuer: Option<IssuerConfig>,
    pub must_staple: Option<bool>,
    pub key_type: Option<String>,
    pub storage: Option<StorageConfig>,
    pub on_demand: Option<bool>,
    pub disable: Option<bool>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "module")]
pub enum IssuerConfig {
    /// ACME issuer
    #[serde(rename = "acme")]
    Acme {
        ca: Option<String>,
        test_ca: Option<String>,
        email: Option<String>,
        account_key_pem: Option<String>,
        external_account: Option<ExternalAccount>,
        challenges: Option<ChallengeConfig>,
        preferred_chains: Option<PreferredChains>,
        must_staple: Option<bool>,
        trusted_roots_pem_files: Option<Vec<String>>,
    },
    /// Internal issuer
    #[serde(rename = "internal")]
    Internal {
        ca: Option<String>,
        lifetime: Option<String>,
        sign_with_root: Option<bool>,
    },
    /// External issuer
    #[serde(rename = "external")]
    External {
        command: Vec<String>,
        timeout: Option<String>,
        env: Option<HashMap<String, String>>,
    },
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ExternalAccount {
    pub key_id: String,
    pub mac_key: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChallengeConfig {
    pub http: Option<HttpChallengeConfig>,
    pub dns: Option<DnsChallengeConfig>,
    pub tls_alpn: Option<TlsAlpnChallengeConfig>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HttpChallengeConfig {
    pub disabled: Option<bool>,
    pub alternate_port: Option<i32>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DnsChallengeConfig {
    pub provider: String,
    pub disabled: Option<bool>,
    pub propagation_delay: Option<String>,
    pub propagation_timeout: Option<String>,
    pub resolvers: Option<Vec<String>>,
    pub ttl: Option<i32>,
    #[serde(flatten)]
    pub config: HashMap<String, serde_json::Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TlsAlpnChallengeConfig {
    pub disabled: Option<bool>,
    pub alternate_port: Option<i32>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PreferredChains {
    pub smallest: Option<bool>,
    pub root_common_name: Option<Vec<String>>,
    pub any_common_name: Option<Vec<String>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OnDemandConfig {
    pub rate_limit: Option<RateLimitConfig>,
    pub ask: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RateLimitConfig {
    pub interval: String,
    pub burst: i32,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StorageConfig {
    pub module: String,
    #[serde(flatten)]
    pub config: HashMap<String, serde_json::Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SessionTicketsConfig {
    pub key_source: Option<KeySourceConfig>,
    pub rotation_interval: Option<String>,
    pub max_keys: Option<i32>,
    pub disabled: Option<bool>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct KeySourceConfig {
    pub module: String,
    #[serde(flatten)]
    pub config: HashMap<String, serde_json::Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CertificatesConfig {
    pub load_files: Option<Vec<CertificateFile>>,
    pub load_folders: Option<Vec<String>>,
    pub load_pem: Option<Vec<PemCertificate>>,
    pub automate: Option<Vec<String>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CertificateFile {
    pub certificate: String,
    pub key: String,
    pub format: Option<String>,
    pub tags: Option<Vec<String>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PemCertificate {
    pub certificate: String,
    pub key: String,
    pub tags: Option<Vec<String>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PkiApp {
    pub certificate_authorities: Option<HashMap<String, CertificateAuthority>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CertificateAuthority {
    pub name: Option<String>,
    pub root_common_name: Option<String>,
    pub intermediate_common_name: Option<String>,
    pub intermediate_lifetime: Option<String>,
    pub root: Option<CertificateConfig>,
    pub intermediate: Option<CertificateConfig>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CertificateConfig {
    pub format: Option<String>,
    pub common_name: Option<String>,
    pub country: Option<Vec<String>>,
    pub organization: Option<Vec<String>>,
    pub organizational_unit: Option<Vec<String>>,
    pub locality: Option<Vec<String>>,
    pub province: Option<Vec<String>>,
    pub street_address: Option<Vec<String>>,
    pub postal_code: Option<Vec<String>>,
}

/// Converter from Caddy config to Quantum config
pub struct CaddyConverter;

impl CaddyConverter {
    /// Convert Caddy configuration to Quantum configuration
    pub fn convert(caddy_config: &CaddyConfig) -> Result<crate::config::Config> {
        let mut servers = HashMap::new();
        
        // Convert each HTTP server
        for (server_name, http_server) in &caddy_config.apps.http.servers {
            let quantum_server = crate::config::Server {
                listen: http_server.listen.clone(),
                routes: Self::convert_routes(&http_server.routes)?,
                automatic_https: crate::config::AutomaticHttps::default(),
                tls: Self::convert_tls_config(http_server)?,
            };
            servers.insert(server_name.clone(), quantum_server);
        }

        Ok(crate::config::Config {
            admin: crate::config::AdminConfig {
                listen: caddy_config.admin.as_ref().and_then(|a| a.listen.clone()),
            },
            apps: crate::config::Apps {
                http: crate::config::HttpApp { servers },
            },
        })
    }

    fn convert_routes(caddy_routes: &[Route]) -> Result<Vec<crate::config::Route>> {
        caddy_routes
            .iter()
            .map(|route| {
                Ok(crate::config::Route {
                    handle: Self::convert_handlers(&route.handle)?,
                    match_rules: route.match_rules.as_ref().map(|m| Self::convert_matchers(m)),
                })
            })
            .collect()
    }

    fn convert_handlers(caddy_handlers: &[Handler]) -> Result<Vec<crate::config::Handler>> {
        caddy_handlers
            .iter()
            .map(|handler| match handler {
                Handler::BasicAuth { accounts, realm, .. } => {
                    let mut quantum_accounts = HashMap::new();
                    for account in accounts {
                        quantum_accounts.insert(account.username.clone(), account.password.clone());
                    }
                    Ok(crate::config::Handler::BasicAuth {
                        accounts: quantum_accounts,
                        realm: realm.clone(),
                    })
                }
                Handler::FileServer { root, index_names, .. } => {
                    Ok(crate::config::Handler::FileServer {
                        root: root.clone().unwrap_or_else(|| ".".to_string()),
                        try_files: None,
                        index: index_names.clone(),
                        browse: None,
                    })
                }
                Handler::ReverseProxy { upstreams, load_balancing, .. } => {
                    let quantum_upstreams: Vec<crate::config::Upstream> = upstreams
                        .iter()
                        .map(|up| crate::config::Upstream {
                            dial: up.dial.clone(),
                            max_requests: None,
                            unhealthy_request_count: 0,
                        })
                        .collect();

                    let quantum_lb = load_balancing.as_ref().map(|lb| {
                        crate::config::LoadBalancing {
                            selection_policy: match lb.selection_policy {
                                Some(SelectionPolicy::RoundRobin) => crate::config::SelectionPolicy::RoundRobin,
                                Some(SelectionPolicy::LeastConn) => crate::config::SelectionPolicy::LeastConn,
                                Some(SelectionPolicy::Random) => crate::config::SelectionPolicy::Random,
                                Some(SelectionPolicy::IpHash) => crate::config::SelectionPolicy::IpHash,
                                _ => crate::config::SelectionPolicy::RoundRobin,
                            },
                        }
                    });

                    Ok(crate::config::Handler::ReverseProxy {
                        upstreams: quantum_upstreams,
                        load_balancing: quantum_lb.unwrap_or_default(),
                        health_checks: None, // Could be implemented
                    })
                }
                Handler::StaticResponse { status_code, headers, body, .. } => {
                    let quantum_headers = headers.as_ref().map(|h| {
                        h.iter()
                            .map(|(k, v)| (k.clone(), vec![v.join(", ")]))
                            .collect()
                    });

                    Ok(crate::config::Handler::StaticResponse {
                        status_code: status_code.map(|s| s as u16),
                        headers: quantum_headers,
                        body: body.clone(),
                    })
                }
                Handler::Redirect { to, status_code } => {
                    Ok(crate::config::Handler::Redirect {
                        to: to.clone().unwrap_or_default(),
                        status_code: status_code.map(|s| s as u16),
                    })
                }
                Handler::Rewrite { uri, .. } => {
                    Ok(crate::config::Handler::Rewrite {
                        uri: uri.clone().unwrap_or_default(),
                    })
                }
                Handler::Headers { request, response } => {
                    // Convert header operations to quantum format
                    Ok(crate::config::Handler::Headers {
                        request: request.clone().map(|_| HashMap::new()), // Simplified
                        response: response.clone().map(|_| HashMap::new()), // Simplified
                    })
                }
                Handler::Error { status_code, .. } => {
                    Ok(crate::config::Handler::Error {
                        status_code: status_code.map(|s| s as u16),
                        message: None,
                    })
                }
                _ => {
                    // For handlers we don't support yet, create a static response
                    Ok(crate::config::Handler::StaticResponse {
                        status_code: Some(501),
                        headers: None,
                        body: Some("Handler not yet implemented".to_string()),
                    })
                }
            })
            .collect()
    }

    fn convert_matchers(_caddy_matchers: &[Matcher]) -> Vec<crate::config::Matcher> {
        // Simplified matcher conversion - could be expanded
        vec![]
    }

    fn convert_tls_config(_http_server: &HttpServer) -> Result<Option<crate::config::TlsConfig>> {
        // Simplified TLS conversion - could be expanded
        Ok(None)
    }

    /// Parse Caddyfile format into CaddyConfig
    pub fn parse_caddyfile(content: &str) -> Result<CaddyConfig> {
        // This is a simplified Caddyfile parser
        // In a real implementation, this would parse the Caddyfile syntax
        let mut servers = HashMap::new();
        
        // For now, create a basic server
        servers.insert("default".to_string(), HttpServer {
            listen: vec![":80".to_string(), ":443".to_string()],
            routes: vec![Route {
                match_rules: None,
                handle: vec![Handler::FileServer {
                    root: Some("/var/www".to_string()),
                    hide: None,
                    index_names: Some(vec!["index.html".to_string()]),
                    browse: None,
                    precompressed: None,
                    status_code: None,
                    canonical_uris: None,
                    pass_thru: None,
                }],
                terminal: Some(true),
            }],
            errors: None,
            tls_connection_policies: None,
            automatic_https: None,
            protocols: None,
            strict_sni_host: None,
            request_timeout: None,
            read_timeout: None,
            read_header_timeout: None,
            write_timeout: None,
            idle_timeout: None,
            max_header_bytes: None,
            allow_h2c: None,
            experimental_http3: None,
        });

        Ok(CaddyConfig {
            admin: Some(AdminConfig {
                listen: Some("localhost:2019".to_string()),
                origins: None,
                remote: None,
            }),
            apps: Apps {
                http: HttpApp {
                    servers,
                    grace_period: None,
                    shutdown_delay: None,
                },
                tls: None,
                pki: None,
            },
        })
    }

    /// Load and convert Caddy configuration from file
    pub fn load_and_convert(path: &PathBuf) -> Result<crate::config::Config> {
        let content = std::fs::read_to_string(path)?;
        
        let caddy_config = if path.extension().and_then(|s| s.to_str()) == Some("json") {
            serde_json::from_str::<CaddyConfig>(&content)?
        } else {
            // Assume Caddyfile format
            Self::parse_caddyfile(&content)?
        };

        Self::convert(&caddy_config)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_caddy_config_deserialization() {
        let config_json = r#"{
            "apps": {
                "http": {
                    "servers": {
                        "example": {
                            "listen": [":80", ":443"],
                            "routes": [{
                                "handle": [{
                                    "handler": "file_server",
                                    "root": "/var/www"
                                }]
                            }]
                        }
                    }
                }
            }
        }"#;

        let result: Result<CaddyConfig, _> = serde_json::from_str(config_json);
        assert!(result.is_ok());
    }

    #[test]
    fn test_caddy_converter() {
        let caddy_config = CaddyConfig {
            admin: None,
            apps: Apps {
                http: HttpApp {
                    servers: [(
                        "test".to_string(),
                        HttpServer {
                            listen: vec![":8080".to_string()],
                            routes: vec![Route {
                                match_rules: None,
                                handle: vec![Handler::StaticResponse {
                                    status_code: Some(200),
                                    headers: None,
                                    body: Some("Hello World".to_string()),
                                    close: None,
                                }],
                                terminal: Some(true),
                            }],
                            errors: None,
                            tls_connection_policies: None,
                            automatic_https: None,
                            protocols: None,
                            strict_sni_host: None,
                            request_timeout: None,
                            read_timeout: None,
                            read_header_timeout: None,
                            write_timeout: None,
                            idle_timeout: None,
                            max_header_bytes: None,
                            allow_h2c: None,
                            experimental_http3: None,
                        },
                    )]
                    .into_iter()
                    .collect(),
                    grace_period: None,
                    shutdown_delay: None,
                },
                tls: None,
                pki: None,
            },
        };

        let result = CaddyConverter::convert(&caddy_config);
        assert!(result.is_ok());
    }
}