use std::collections::HashMap;
use std::time::Duration;
use std::{env, fmt};

pub const DEFAULT_TIMEOUT: Duration = Duration::from_secs(10);
pub const DEFAULT_METRIC_INTERVAL: Duration = Duration::from_secs(60);
pub const DEFAULT_LOG_FILTER: &str = "info";

const TRACE_PATH: &str = "/v1/traces";
const LOG_PATH: &str = "/v1/logs";
const METRIC_PATH: &str = "/v1/metrics";

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SamplerKind {
    AlwaysOn,
    AlwaysOff,
    ParentBasedAlwaysOn,
    ParentBasedAlwaysOff,
    TraceIdRatio,
    ParentBasedTraceIdRatio,
}

impl SamplerKind {
    pub fn parse(raw: &str) -> Self {
        match raw.trim().to_ascii_lowercase().as_str() {
            "always_on" => Self::AlwaysOn,
            "always_off" => Self::AlwaysOff,
            "traceidratio" => Self::TraceIdRatio,
            "parentbased_always_off" => Self::ParentBasedAlwaysOff,
            "parentbased_traceidratio" => Self::ParentBasedTraceIdRatio,
            _ => Self::ParentBasedAlwaysOn,
        }
    }
}

#[derive(Clone)]
pub struct SignalConfig {
    pub enabled: bool,
    pub endpoint: Option<String>,
    pub headers: HashMap<String, String>,
}

// OTLP headers 常带 Authorization：Debug 输出里只能出现键名。
impl fmt::Debug for SignalConfig {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        let mut keys: Vec<&str> = self.headers.keys().map(String::as_str).collect();
        keys.sort_unstable();
        formatter
            .debug_struct("SignalConfig")
            .field("enabled", &self.enabled)
            .field("endpoint", &self.endpoint)
            .field("headers", &keys)
            .finish()
    }
}

impl SignalConfig {
    pub fn disabled() -> Self {
        Self {
            enabled: false,
            endpoint: None,
            headers: HashMap::new(),
        }
    }

    pub fn enabled(endpoint: impl Into<String>) -> Self {
        Self {
            enabled: true,
            endpoint: Some(endpoint.into()),
            headers: HashMap::new(),
        }
    }

    pub fn endpoint(mut self, endpoint: impl Into<String>) -> Self {
        self.endpoint = Some(endpoint.into());
        self.enabled = true;
        self
    }

    pub fn header(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
        self.headers.insert(key.into(), value.into());
        self
    }

    pub fn url(&self, path: &str) -> Option<String> {
        if !self.enabled {
            return None;
        }
        self.endpoint
            .as_deref()
            .map(|base| join_endpoint(base, path))
    }

    fn from_env(
        suffix: &str,
        common_endpoint: Option<&str>,
        common_headers: &HashMap<String, String>,
    ) -> Self {
        let endpoint = env_var(&format!("OTEL_EXPORTER_OTLP_{suffix}_ENDPOINT"))
            .or_else(|| common_endpoint.map(str::to_owned));
        let mut headers = common_headers.clone();
        headers.extend(parse_key_values(
            &env_var(&format!("OTEL_EXPORTER_OTLP_{suffix}_HEADERS")).unwrap_or_default(),
        ));
        Self {
            enabled: endpoint.is_some(),
            endpoint,
            headers,
        }
    }
}

#[derive(Debug, Clone)]
pub struct MetricsConfig {
    pub signal: SignalConfig,
    pub interval: Duration,
}

impl MetricsConfig {
    pub fn disabled() -> Self {
        Self {
            signal: SignalConfig::disabled(),
            interval: DEFAULT_METRIC_INTERVAL,
        }
    }

    pub fn enabled(endpoint: impl Into<String>) -> Self {
        Self {
            signal: SignalConfig::enabled(endpoint),
            interval: DEFAULT_METRIC_INTERVAL,
        }
    }

    pub fn endpoint(mut self, endpoint: impl Into<String>) -> Self {
        self.signal = self.signal.endpoint(endpoint);
        self
    }

    pub fn header(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
        self.signal = self.signal.header(key, value);
        self
    }

    pub fn interval(mut self, interval: Duration) -> Self {
        self.interval = interval;
        self
    }

    pub fn url(&self) -> Option<String> {
        self.signal.url(METRIC_PATH)
    }
}

#[derive(Clone)]
pub struct TelemetryConfig {
    pub disabled: bool,
    pub service_name: String,
    pub service_version: Option<String>,
    pub environment: Option<String>,
    pub attributes: Vec<(String, String)>,
    pub headers: HashMap<String, String>,
    pub timeout: Duration,
    pub sampler: SamplerKind,
    pub sample_ratio: f64,
    pub traces: SignalConfig,
    pub metrics: MetricsConfig,
    pub logs: SignalConfig,
    pub log_filter: String,
    pub stdout: bool,
}

impl fmt::Debug for TelemetryConfig {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        let mut keys: Vec<&str> = self.headers.keys().map(String::as_str).collect();
        keys.sort_unstable();
        formatter
            .debug_struct("TelemetryConfig")
            .field("disabled", &self.disabled)
            .field("service_name", &self.service_name)
            .field("service_version", &self.service_version)
            .field("environment", &self.environment)
            .field("attributes", &self.attributes)
            .field("headers", &keys)
            .field("timeout", &self.timeout)
            .field("sampler", &self.sampler)
            .field("sample_ratio", &self.sample_ratio)
            .field("traces", &self.traces)
            .field("metrics", &self.metrics)
            .field("logs", &self.logs)
            .field("log_filter", &self.log_filter)
            .field("stdout", &self.stdout)
            .finish()
    }
}

impl TelemetryConfig {
    pub fn new(service_name: impl Into<String>) -> Self {
        Self {
            disabled: false,
            service_name: service_name.into(),
            service_version: None,
            environment: None,
            attributes: Vec::new(),
            headers: HashMap::new(),
            timeout: DEFAULT_TIMEOUT,
            sampler: SamplerKind::ParentBasedAlwaysOn,
            sample_ratio: 1.0,
            traces: SignalConfig::disabled(),
            metrics: MetricsConfig::disabled(),
            logs: SignalConfig::disabled(),
            log_filter: DEFAULT_LOG_FILTER.to_owned(),
            stdout: true,
        }
    }

    pub fn from_env(service_name: impl Into<String>) -> Self {
        let mut config = Self::new(service_name);

        if env_bool("OTEL_SDK_DISABLED").unwrap_or(false) {
            config.disabled = true;
        }

        if let Some(name) = env_var("OTEL_SERVICE_NAME") {
            config.service_name = name;
        }

        config.attributes =
            parse_key_values(&env_var("OTEL_RESOURCE_ATTRIBUTES").unwrap_or_default());
        for (key, value) in &config.attributes {
            match key.as_str() {
                "service.version" => config.service_version = Some(value.clone()),
                "deployment.environment" => config.environment = Some(value.clone()),
                _ => {}
            }
        }

        let common_endpoint = env_var("OTEL_EXPORTER_OTLP_ENDPOINT");
        config.headers =
            parse_key_values(&env_var("OTEL_EXPORTER_OTLP_HEADERS").unwrap_or_default())
                .into_iter()
                .collect();
        config.timeout = env_u64("OTEL_EXPORTER_OTLP_TIMEOUT")
            .map(Duration::from_millis)
            .unwrap_or(DEFAULT_TIMEOUT);

        config.sampler = SamplerKind::parse(&env_var("OTEL_TRACES_SAMPLER").unwrap_or_default());
        config.sample_ratio = {
            let name = "OTEL_TRACES_SAMPLER_ARG";
            env_var(name).and_then(|value| value.parse().ok())
        }
        .unwrap_or(1.0);

        config.traces =
            SignalConfig::from_env("TRACES", common_endpoint.as_deref(), &config.headers);
        config.logs = SignalConfig::from_env("LOGS", common_endpoint.as_deref(), &config.headers);
        config.metrics = MetricsConfig {
            signal: SignalConfig::from_env("METRICS", common_endpoint.as_deref(), &config.headers),
            interval: env_u64("OTEL_METRIC_EXPORT_INTERVAL")
                .map(Duration::from_millis)
                .unwrap_or(DEFAULT_METRIC_INTERVAL),
        };

        config.log_filter = env_var("OTEL_LOG_FILTER")
            .or_else(|| env_var("RUST_LOG"))
            .unwrap_or_else(|| DEFAULT_LOG_FILTER.to_owned());
        config.stdout = env_bool("OTEL_LOG_STDOUT").unwrap_or(true);

        config
    }

    pub fn with_timeout(mut self, timeout: Duration) -> Self {
        self.timeout = timeout;
        self
    }

    pub fn traces_url(&self) -> Option<String> {
        if self.disabled {
            return None;
        }
        self.traces.url(TRACE_PATH)
    }

    pub fn logs_url(&self) -> Option<String> {
        if self.disabled {
            return None;
        }
        self.logs.url(LOG_PATH)
    }

    pub fn metrics_url(&self) -> Option<String> {
        if self.disabled {
            return None;
        }
        self.metrics.url()
    }
}

pub fn join_endpoint(base: &str, path: &str) -> String {
    if base.ends_with(path) {
        return base.to_owned();
    }
    match base.strip_suffix('/') {
        Some(trimmed) => format!("{trimmed}{path}"),
        None => format!("{base}{path}"),
    }
}

pub fn parse_key_values(raw: &str) -> Vec<(String, String)> {
    raw.split(',')
        .filter_map(|pair| pair.split_once('='))
        .map(|(key, value)| (key.trim().to_owned(), value.trim().to_owned()))
        .filter(|(key, _)| !key.is_empty())
        .collect()
}

fn env_var(name: &str) -> Option<String> {
    env::var(name)
        .ok()
        .map(|value| value.trim().to_owned())
        .filter(|value| !value.is_empty())
}

fn env_bool(name: &str) -> Option<bool> {
    env_var(name).map(|value| {
        matches!(
            value.to_ascii_lowercase().as_str(),
            "1" | "true" | "yes" | "on"
        )
    })
}

fn env_u64(name: &str) -> Option<u64> {
    env_var(name).and_then(|value| value.parse().ok())
}