mod http;

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

use clap::Parser;
use figment::providers::Format;
use figment::{providers::Toml, Figment};
use prometheus::Registry as MetricsRegistry;
use serde::Deserialize;

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<()> {
    tracing_subscriber::fmt::init();
    Ok(())
}