//! Oxygenhub: a forge for Oxygen repositories (`docs/spec.md`).

//!

//! One process: an axum router serving pages, the JSON API and the wire

//! protocol; SQLite for hub state; repositories as bare Oxygen stores.

pub mod api;

pub mod auth;

pub mod config;

pub mod db;

pub mod events;

pub mod flow;

pub mod hooks;

pub mod keys;

pub mod mirror;

pub mod notify;

pub mod protocol;

pub mod render;

pub mod repos;

pub mod web;

use crate::config::Config;

use crate::repos::Repos;

use std::sync::Arc;

/// Everything a request handler can reach.

pub struct App {

    pub config: Config,

    pub db: db::Pool,

    pub repos: Arc<Repos>,

    pub server: Arc<oxy_server::Server>,

    pub hub_key: keys::HubKey,

    pub cookie_key: auth::CookieKey,

    pub events: events::Events,

    pub started: std::time::Instant,

}

pub type Shared = Arc<App>;

/// Open the data directory and build the application state. `init` must

/// have run once; `serve` and the tests call this.

pub async fn build(config: Config) -> anyhow::Result<Shared> {

    std::fs::create_dir_all(config.repos_dir())?;

    let db = db::open(&config.db_path()).await?;

    let repos = Arc::new(Repos::new(config.repos_dir()));

    let hub_key = keys::ensure_identity(&config.keys_dir(), &config.site.name, config.base_url())?;

    let cookie_key = auth::CookieKey::load_or_create(&config.keys_dir())?;

    let backend = protocol::HubBackend::new(repos.clone(), db.clone(), config.auth.push_tokens.clone(), tokio::runtime::Handle::current());

    let slot = backend.app_slot();

    let server = oxy_server::Server::new(backend);

    let app = Arc::new(App {

        config,

        db,

        repos,

        server,

        hub_key,

        cookie_key,

        events: events::Events::default(),

        started: std::time::Instant::now(),

    });

    *slot.lock().unwrap() = Some(Arc::downgrade(&app));

    tokio::spawn(hooks::worker(app.clone()));

    Ok(app)

}

/// The full router: pages, API, protocol and static assets.

pub fn router(app: Shared) -> axum::Router {

    web::router(app)

}

/// Serve on the configured addresses until the process is told to stop.

pub async fn serve(app: Shared) -> anyhow::Result<()> {

    let router = router(app.clone());

    let http = app.config.bind_addr()?;

    let https = app.config.tls_bind_addr()?;

    if http.is_none() && https.is_none() {

        anyhow::bail!("nothing to bind: set server.bind or server.tls_bind");

    }

    let mut tasks = tokio::task::JoinSet::new();

    if let Some(addr) = http {

        let listener = tokio::net::TcpListener::bind(addr).await?;

        tracing::info!("http on {addr}");

        let r = router.clone();

        tasks.spawn(async move { axum::serve(listener, r).await.map_err(anyhow::Error::from) });

    }

    if let Some(addr) = https {

        let _ = rustls::crypto::ring::default_provider().install_default();

        let tls = axum_server::tls_rustls::RustlsConfig::from_pem_file(app.config.tls_cert(), app.config.tls_key())

            .await

            .map_err(|e| anyhow::anyhow!("loading TLS files: {e}"))?;

        tracing::info!("https on {addr}");

        let r = router.clone();

        tasks.spawn(async move { axum_server::bind_rustls(addr, tls).serve(r.into_make_service()).await.map_err(anyhow::Error::from) });

    }

    tokio::select! {

        r = tasks.join_next() => { r.transpose()?.transpose()?; Ok(()) }

        _ = tokio::signal::ctrl_c() => { tracing::info!("stopping"); Ok(()) }

    }

}