use config::obs::ObsSettings;
use opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge;
use tracing_subscriber::filter::EnvFilter;
use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::util::SubscriberInitExt;

use crate::error::ObsError;
use crate::guard::ObservabilityGuard;
use crate::{logs, metrics, otlp, traces};

pub fn init(settings: &ObsSettings) -> Result<ObservabilityGuard, ObsError> {
    let mut guard = ObservabilityGuard::default();

    let trace_layer = if settings.enabled && settings.enable_traces {
        let provider = traces::build(otlp::resource(settings), settings)?;
        guard.set_tracer(provider);
        Some(tracing_opentelemetry::layer().with_tracer(opentelemetry::global::tracer("obs")))
    } else {
        None
    };

    let log_layer = if settings.enabled && settings.enable_logs {
        let provider = logs::build(otlp::resource(settings), settings)?;
        guard.set_logger(provider.clone());
        Some(OpenTelemetryTracingBridge::new(&provider))
    } else {
        None
    };

    if settings.enabled && settings.enable_metrics {
        let provider = metrics::install(otlp::resource(settings), settings)?;
        guard.set_meter(provider);
    }

    let filter = match (std::env::var("RUST_LOG").ok(), settings.log_level.as_str()) {
        (Some(env), _) => EnvFilter::try_new(env).map_err(|e| ObsError::Filter(e.to_string()))?,
        (None, "") => EnvFilter::new("info"),
        (None, level) => EnvFilter::try_new(level).map_err(|e| ObsError::Filter(e.to_string()))?,
    };

    let console_layer = settings.console_log.then(|| {
        tracing_subscriber::fmt::layer()
            .with_target(true)
            .with_writer(std::io::stdout)
    });

    tracing_subscriber::registry()
        .with(filter)
        .with(console_layer)
        .with(trace_layer)
        .with(log_layer)
        .init();

    Ok(guard)
}