use std::io::Write;

use clusterflux_coordinator::{service::bind_listener, CoordinatorService};
use clusterflux_core::{ProjectId, TenantId, UserId};
use serde_json::json;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let raw_args = std::env::args().skip(1).collect::<Vec<_>>();
    match raw_args.as_slice() {
        [flag] if matches!(flag.as_str(), "--version" | "-V") => {
            println!("clusterflux-coordinator {}", env!("CARGO_PKG_VERSION"));
            return Ok(());
        }
        [flag] if matches!(flag.as_str(), "--help" | "-h") => {
            println!(
                "Clusterflux coordinator.\n\n\
                 Usage: clusterflux-coordinator [OPTIONS]\n\n\
                 Options:\n  \
                   --listen <ADDRESS>                 [default: 127.0.0.1:0]\n  \
                   --allow-local-trusted-loopback\n  \
                   -h, --help\n  \
                   -V, --version"
            );
            return Ok(());
        }
        _ => {}
    }

    let mut listen = "127.0.0.1:0".to_owned();
    let mut allow_local_trusted = std::env::var("CLUSTERFLUX_ALLOW_LOCAL_TRUSTED_LOOPBACK")
        .ok()
        .as_deref()
        == Some("1");
    let mut args = raw_args.into_iter();
    while let Some(arg) = args.next() {
        if arg == "--listen" {
            listen = args.next().ok_or("--listen requires an address")?;
        } else if arg == "--allow-local-trusted-loopback" {
            allow_local_trusted = true;
        } else {
            return Err(format!("unknown argument: {arg}").into());
        }
    }

    let (listener, addr) = bind_listener(&listen)?;
    let database_url = std::env::var("DATABASE_URL").ok();
    let mut service = CoordinatorService::new_with_database_url(1, database_url.as_deref())?;
    let self_hosted_session_secret = std::env::var("CLUSTERFLUX_SELF_HOSTED_SESSION_SECRET")
        .ok()
        .filter(|secret| !secret.trim().is_empty());
    if let Some(session_secret) = self_hosted_session_secret.as_deref() {
        service.issue_cli_session(
            TenantId::new(
                std::env::var("CLUSTERFLUX_SELF_HOSTED_TENANT")
                    .unwrap_or_else(|_| "tenant".to_owned()),
            ),
            ProjectId::new(
                std::env::var("CLUSTERFLUX_SELF_HOSTED_PROJECT")
                    .unwrap_or_else(|_| "project".to_owned()),
            ),
            UserId::new(
                std::env::var("CLUSTERFLUX_SELF_HOSTED_USER").unwrap_or_else(|_| "user".to_owned()),
            ),
            session_secret,
            None,
        )?;
    }
    println!(
        "{}",
        json!({
            "listen": addr.to_string(),
            "client_authority": if allow_local_trusted { "local_trusted_loopback" } else { "strict" },
            "self_hosted_session_bootstrapped": self_hosted_session_secret.is_some(),
            "durable_store": service.durable_store_kind(),
        })
    );
    std::io::stdout().flush()?;

    if allow_local_trusted {
        service.serve_tcp_local_trusted(listener)?;
    } else {
        service.serve_tcp(listener)?;
    }
    Ok(())
}