malice

use std::path::PathBuf;

use malice::{

    routes::router,

    state::{AppState, ensure_dirs, load_or_create_master_key},

};

use malice_static::{bind_listener, serve};

fn env_flag(name: &str, default: bool) -> bool {

    match std::env::var(name) {

        Ok(value) => {

            let value = value.trim().to_ascii_lowercase();

            match value.as_str() {

                "1" | "true" | "yes" | "on" => true,

                "0" | "false" | "no" | "off" => false,

                _ => default,

            }

        }

        Err(_) => default,

    }

}

fn data_dir() -> PathBuf {

    std::env::var("MALICE_DATA_DIR")

        .map(PathBuf::from)

        .unwrap_or_else(|_| PathBuf::from("local-data"))

}

fn web_dir() -> Option<String> {

    if let Ok(dir) = std::env::var("MALICE_WEB_DIR") {

        assert!(

            std::path::Path::new(&dir).join("index.html").is_file(),

            "MALICE_WEB_DIR must point to built frontend assets containing index.html"

        );

        return Some(dir);

    }

    let local = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("web/dist");

    local

        .join("index.html")

        .is_file()

        .then(|| local.to_string_lossy().into_owned())

}

#[tokio::main]

async fn main() {

    tracing_subscriber::fmt()

        .with_env_filter(

            tracing_subscriber::EnvFilter::try_from_default_env()

                .unwrap_or_else(|_| "malice=info,tower_http=info".into()),

        )

        .with_target(false)

        .compact()

        .init();

    let data_dir = data_dir();

    ensure_dirs(&data_dir);

    let master_key =

        load_or_create_master_key(&data_dir).expect("loading the master key must succeed");

    let cookie_secure = env_flag("MALICE_SESSION_COOKIE_SECURE", true);

    let allow_http_homeserver = env_flag("MALICE_ALLOW_HTTP_HOMESERVER", false);

    let state = AppState::new(data_dir, master_key, cookie_secure, allow_http_homeserver);

    let app = router(state.clone(), web_dir());

    let listener = bind_listener().await;

    serve(

        listener,

        app,

        async move { state.shutdown_gracefully().await },

    )

    .await;

}