#![allow(unused)]
fn main() {
    pub fn new(file: Option<String>) -> Result<Self, ConfigError> {
        // Start with default settings from the embedded TOML file
        let mut s = Config::builder()
            .add_source(File::from_str(DEFAULT_SETTINGS, config::FileFormat::Toml));

        // If a configuration file is provided, add it as a source
        s = match file {
            Some(x) => s.add_source(File::with_name(x.as_str())),
            None => s,
        };

        // Add environment variables as a source, prefixed with "BROKKR" and using "__" as a separator
        s = s.add_source(Environment::with_prefix("BROKKR").separator("__"));

        // Build the configuration
        let settings = s.build().unwrap();

        // Deserialize the configuration into a Settings instance
        settings.try_deserialize()
    }
}

#![allow(unused)]
fn main() {
    pub fn for_broker(&self) -> ResolvedTelemetry {
        ResolvedTelemetry {
            enabled: self.broker.enabled.unwrap_or(self.enabled),
            otlp_endpoint: self
                .broker
                .otlp_endpoint
                .clone()
                .unwrap_or_else(|| self.otlp_endpoint.clone()),
            service_name: self
                .broker
                .service_name
                .clone()
                .unwrap_or_else(|| self.service_name.clone()),
            sampling_rate: self.broker.sampling_rate.unwrap_or(self.sampling_rate),
        }
    }
}

#![allow(unused)]
fn main() {
    pub fn for_agent(&self) -> ResolvedTelemetry {
        ResolvedTelemetry {
            enabled: self.agent.enabled.unwrap_or(self.enabled),
            otlp_endpoint: self
                .agent
                .otlp_endpoint
                .clone()
                .unwrap_or_else(|| self.otlp_endpoint.clone()),
            service_name: self
                .agent
                .service_name
                .clone()
                .unwrap_or_else(|| self.service_name.clone()),
            sampling_rate: self.agent.sampling_rate.unwrap_or(self.sampling_rate),
        }
    }
}

#![allow(unused)]
fn main() {
    pub fn short_length_as_str(&mut self) {
        self.short_token_length_str = self.short_token_length.map(|v| v.to_string());
    }
}

#![allow(unused)]
fn main() {
    pub fn long_length_as_str(&mut self) {
        self.long_token_length_str = self.long_token_length.map(|v| v.to_string());
    }
}

#![allow(unused)]
fn main() {
    pub fn from_settings(settings: &Settings) -> Self {
        Self {
            log_level: settings.log.level.clone(),
            diagnostic_cleanup_interval_seconds: settings
                .broker
                .diagnostic_cleanup_interval_seconds
                .unwrap_or(900),
            diagnostic_max_age_hours: settings.broker.diagnostic_max_age_hours.unwrap_or(1),
            webhook_delivery_interval_seconds: settings
                .broker
                .webhook_delivery_interval_seconds
                .unwrap_or(5),
            webhook_delivery_batch_size: settings.broker.webhook_delivery_batch_size.unwrap_or(50),
            webhook_cleanup_retention_days: settings
                .broker
                .webhook_cleanup_retention_days
                .unwrap_or(7),
            cors_allowed_origins: settings.cors.allowed_origins.clone(),
            cors_max_age_seconds: settings.cors.max_age_seconds,
        }
    }
}

#![allow(unused)]
fn main() {
    pub fn new(file: Option<String>) -> Result<Self, ConfigError> {
        let settings = Settings::new(file.clone())?;
        let dynamic = DynamicConfig::from_settings(&settings);

        Ok(Self {
            static_config: settings,
            dynamic: Arc::new(RwLock::new(dynamic)),
            config_file: file,
        })
    }
}

#![allow(unused)]
fn main() {
    pub fn from_settings(settings: Settings, config_file: Option<String>) -> Self {
        let dynamic = DynamicConfig::from_settings(&settings);

        Self {
            static_config: settings,
            dynamic: Arc::new(RwLock::new(dynamic)),
            config_file,
        }
    }
}

#![allow(unused)]
fn main() {
    pub fn static_config(&self) -> &Settings {
        &self.static_config
    }
}

#![allow(unused)]
fn main() {
    pub fn reload(&self) -> Result<Vec<ConfigChange>, ConfigError> {
        // Load fresh settings from sources
        let new_settings = Settings::new(self.config_file.clone())?;
        let new_dynamic = DynamicConfig::from_settings(&new_settings);

        // Acquire write lock and compute changes
        let mut dynamic = self
            .dynamic
            .write()
            .map_err(|e| ConfigError::Message(format!("Failed to acquire write lock: {}", e)))?;

        let mut changes = Vec::new();

        // Check each field for changes
        if dynamic.log_level != new_dynamic.log_level {
            changes.push(ConfigChange {
                key: "log.level".to_string(),
                old_value: dynamic.log_level.clone(),
                new_value: new_dynamic.log_level.clone(),
            });
        }
        if dynamic.diagnostic_cleanup_interval_seconds
            != new_dynamic.diagnostic_cleanup_interval_seconds
        {
            changes.push(ConfigChange {
                key: "broker.diagnostic_cleanup_interval_seconds".to_string(),
                old_value: dynamic.diagnostic_cleanup_interval_seconds.to_string(),
                new_value: new_dynamic.diagnostic_cleanup_interval_seconds.to_string(),
            });
        }
        if dynamic.diagnostic_max_age_hours != new_dynamic.diagnostic_max_age_hours {
            changes.push(ConfigChange {
                key: "broker.diagnostic_max_age_hours".to_string(),
                old_value: dynamic.diagnostic_max_age_hours.to_string(),
                new_value: new_dynamic.diagnostic_max_age_hours.to_string(),
            });
        }
        if dynamic.webhook_delivery_interval_seconds
            != new_dynamic.webhook_delivery_interval_seconds
        {
            changes.push(ConfigChange {
                key: "broker.webhook_delivery_interval_seconds".to_string(),
                old_value: dynamic.webhook_delivery_interval_seconds.to_string(),
                new_value: new_dynamic.webhook_delivery_interval_seconds.to_string(),
            });
        }
        if dynamic.webhook_delivery_batch_size != new_dynamic.webhook_delivery_batch_size {
            changes.push(ConfigChange {
                key: "broker.webhook_delivery_batch_size".to_string(),
                old_value: dynamic.webhook_delivery_batch_size.to_string(),
                new_value: new_dynamic.webhook_delivery_batch_size.to_string(),
            });
        }
        if dynamic.webhook_cleanup_retention_days != new_dynamic.webhook_cleanup_retention_days {
            changes.push(ConfigChange {
                key: "broker.webhook_cleanup_retention_days".to_string(),
                old_value: dynamic.webhook_cleanup_retention_days.to_string(),
                new_value: new_dynamic.webhook_cleanup_retention_days.to_string(),
            });
        }
        if dynamic.cors_allowed_origins != new_dynamic.cors_allowed_origins {
            changes.push(ConfigChange {
                key: "cors.allowed_origins".to_string(),
                old_value: format!("{:?}", dynamic.cors_allowed_origins),
                new_value: format!("{:?}", new_dynamic.cors_allowed_origins),
            });
        }
        if dynamic.cors_max_age_seconds != new_dynamic.cors_max_age_seconds {
            changes.push(ConfigChange {
                key: "cors.max_age_seconds".to_string(),
                old_value: dynamic.cors_max_age_seconds.to_string(),
                new_value: new_dynamic.cors_max_age_seconds.to_string(),
            });
        }

        // Apply the new configuration
        *dynamic = new_dynamic;

        Ok(changes)
    }
}

#![allow(unused)]
fn main() {
    pub fn log_level(&self) -> String {
        self.dynamic
            .read()
            .map(|d| d.log_level.clone())
            .unwrap_or_else(|_| "info".to_string())
    }
}

#![allow(unused)]
fn main() {
    pub fn diagnostic_cleanup_interval_seconds(&self) -> u64 {
        self.dynamic
            .read()
            .map(|d| d.diagnostic_cleanup_interval_seconds)
            .unwrap_or(900)
    }
}

#![allow(unused)]
fn main() {
    pub fn diagnostic_max_age_hours(&self) -> i64 {
        self.dynamic
            .read()
            .map(|d| d.diagnostic_max_age_hours)
            .unwrap_or(1)
    }
}

#![allow(unused)]
fn main() {
    pub fn webhook_delivery_interval_seconds(&self) -> u64 {
        self.dynamic
            .read()
            .map(|d| d.webhook_delivery_interval_seconds)
            .unwrap_or(5)
    }
}

#![allow(unused)]
fn main() {
    pub fn webhook_delivery_batch_size(&self) -> i64 {
        self.dynamic
            .read()
            .map(|d| d.webhook_delivery_batch_size)
            .unwrap_or(50)
    }
}

#![allow(unused)]
fn main() {
    pub fn webhook_cleanup_retention_days(&self) -> i64 {
        self.dynamic
            .read()
            .map(|d| d.webhook_cleanup_retention_days)
            .unwrap_or(7)
    }
}

#![allow(unused)]
fn main() {
    pub fn cors_allowed_origins(&self) -> Vec<String> {
        self.dynamic
            .read()
            .map(|d| d.cors_allowed_origins.clone())
            .unwrap_or_else(|_| vec!["*".to_string()])
    }
}

#![allow(unused)]
fn main() {
    pub fn cors_max_age_seconds(&self) -> u64 {
        self.dynamic
            .read()
            .map(|d| d.cors_max_age_seconds)
            .unwrap_or(3600)
    }
}

#![allow(unused)]
fn main() {
    pub fn dynamic_snapshot(&self) -> Option<DynamicConfig> {
        self.dynamic.read().ok().map(|d| d.clone())
    }
}

#![allow(unused)]
fn main() {
fn deserialize_string_or_vec<'de, D>(deserializer: D) -> Result<Vec<String>, D::Error>
where
    D: Deserializer<'de>,
{
    use serde::de::{self, SeqAccess, Visitor};
    use std::fmt;

    struct StringOrVec;

    impl<'de> Visitor<'de> for StringOrVec {
        type Value = Vec<String>;

        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
            formatter.write_str("a string or sequence of strings")
        }

        fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
        where
            E: de::Error,
        {
            // Split by comma and trim whitespace
            Ok(value.split(',').map(|s| s.trim().to_string()).collect())
        }

        fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
        where
            A: SeqAccess<'de>,
        {
            let mut vec = Vec::new();
            while let Some(item) = seq.next_element::<String>()? {
                vec.push(item);
            }
            Ok(vec)
        }
    }

    deserializer.deserialize_any(StringOrVec)
}
}

#![allow(unused)]
fn main() {
fn default_log_format() -> String {
    "text".to_string()
}
}

#![allow(unused)]
fn main() {
fn default_otlp_endpoint() -> String {
    "http://localhost:4317".to_string()
}
}

#![allow(unused)]
fn main() {
fn default_service_name() -> String {
    "brokkr".to_string()
}
}

#![allow(unused)]
fn main() {
fn default_sampling_rate() -> f64 {
    0.1
}
}