vineyard

use std::io::{Write as _, stdout};

use std::path::PathBuf;

use anyhow::Context as _;

use clap::{Parser, Subcommand};

use tokio::signal::ctrl_c;

#[cfg(unix)]

use tokio::signal::unix::{SignalKind, signal};

use vineyard::config::Config;

use vineyard::server::spawn;

#[derive(Parser)]

#[command(version, about = "a persistent nostr relay for git forges")]

struct Cli {

    #[command(subcommand)]

    command: Command,

}

#[derive(Subcommand)]

enum Command {

    Serve {

        #[arg(long, default_value = "vineyard.toml")]

        config: PathBuf,

    },

    CheckConfig {

        #[arg(long, default_value = "vineyard.toml")]

        config: PathBuf,

    },

}

#[tokio::main(worker_threads = 2)]

async fn main() -> anyhow::Result<()> {

    tracing_subscriber::fmt()

        .with_env_filter(

            tracing_subscriber::EnvFilter::try_from_default_env()

                .unwrap_or_else(|_| "vineyard=info".into()),

        )

        .init();

    match Cli::parse().command {

        Command::CheckConfig { config } => {

            Config::load(&config)?;

            writeln!(stdout().lock(), "configuration is valid")?;

        }

        Command::Serve { config } => {

            let relay = spawn(Config::load(&config)?).await?;

            #[cfg(unix)]

            {

                let mut terminate =

                    signal(SignalKind::terminate()).context("installing termination handler")?;

                tokio::select! {

                    result = ctrl_c() => result?,

                    _ = terminate.recv() => {},

                }

            }

            #[cfg(not(unix))]

            ctrl_c().await?;

            relay.shutdown().await?;

        }

    }

    Ok(())

}