mod http;

use std::future::Future;
use std::path::Path;

use clap::Parser;
use figment::providers::Format;
use figment::{providers::Toml, Figment};
use opentelemetry::KeyValue;
use opentelemetry_otlp::WithExportConfig;
use opentelemetry_sdk::trace::{BatchConfig, RandomIdGenerator, Sampler, TracerProvider};
use opentelemetry_sdk::{runtime, Resource};
use opentelemetry_semantic_conventions::resource::SERVICE_NAME;
use opentelemetry_semantic_conventions::SCHEMA_URL;
use prometheus::Registry as MetricsRegistry;
use serde::Deserialize;
use tracing_opentelemetry::OpenTelemetryLayer;
use tracing_subscriber::prelude::*;

use lavina_core::prelude::*;
use lavina_core::repo::Storage;
use lavina_core::LavinaCore;

#[derive(Deserialize, Debug)]
struct ServerConfig {
    telemetry: http::ServerConfig,
    irc: projection_irc::ServerConfig,
    xmpp: projection_xmpp::ServerConfig,
    storage: lavina_core::repo::StorageConfig,
}

#[derive(Parser)]
struct CliArgs {
    #[arg(long)]
    config: Box<Path>,
}

fn load_config() -> Result<ServerConfig> {
    let args = CliArgs::parse();
    let raw_config = Figment::from(Toml::file(args.config));
    let config: ServerConfig = raw_config.extract()?;
    Ok(config)
}

#[tokio::main]
async fn main() -> Result<()> {
    set_up_logging()?;
    let sleep = ctrl_c()?;
    let config = load_config()?;

    tracing::info!("Booting up");
    tracing::info!("Loaded config: {config:?}");
    let ServerConfig {
        telemetry: telemetry_config,
        irc: irc_config,
        xmpp: xmpp_config,
        storage: storage_config,
    } = config;
    let metrics = MetricsRegistry::new();
    let storage = Storage::open(storage_config).await?;
    let core = LavinaCore::new(metrics.clone(), storage.clone()).await?;
    let telemetry_terminator = http::launch(telemetry_config, metrics.clone(), core.clone(), storage.clone()).await?;
    let irc = projection_irc::launch(irc_config, core.clone(), metrics.clone(), storage.clone()).await?;
    let xmpp = projection_xmpp::launch(xmpp_config, core.clone(), metrics.clone(), storage.clone()).await?;
    tracing::info!("Started");

    sleep.await;

    tracing::info!("Begin shutdown");
    xmpp.terminate().await?;
    irc.terminate().await?;
    telemetry_terminator.terminate().await?;
    core.shutdown().await?;
    tracing::info!("Shutdown complete");
    Ok(())
}

#[cfg(windows)]
fn ctrl_c() -> Result<impl Future<Output = ()>> {
    use tokio::signal::windows::*;
    let chan = ctrl_c()?;
    async fn recv(mut chan: CtrlC) {
        let _ = chan.recv().await;
    }
    Ok(recv(chan))
}

#[cfg(unix)]
fn ctrl_c() -> Result<impl Future<Output = ()>> {
    use tokio::signal::unix::*;
    let chan = signal(SignalKind::interrupt())?;
    async fn recv(mut chan: Signal) {
        let _ = chan.recv().await;
    }
    Ok(recv(chan))
}

fn set_up_logging() -> Result<()> {
    let trace_config = opentelemetry_sdk::trace::Config::default()
        .with_sampler(Sampler::ParentBased(Box::new(Sampler::TraceIdRatioBased(1.0))))
        .with_id_generator(RandomIdGenerator::default())
        .with_resource(Resource::from_schema_url(
            [KeyValue::new(SERVICE_NAME, "lavina")],
            SCHEMA_URL,
        ));
    let trace_exporter = opentelemetry_otlp::new_exporter().tonic().with_endpoint("http://localhost:4317");
    let tracer = opentelemetry_otlp::new_pipeline()
        .tracing()
        .with_trace_config(trace_config)
        .with_batch_config(BatchConfig::default())
        .with_exporter(trace_exporter)
        .install_batch(runtime::Tokio)
        .unwrap();

    tracing_subscriber::registry().with(tracing_subscriber::fmt::layer()).with(OpenTelemetryLayer::new(tracer)).init();
    Ok(())
}