//! `oxygenhub`: `init`, `serve`, `admin`, `check` (hub spec §17.3).

use clap::{Parser, Subcommand};
use hub_api::Visibility;
use oxygenhub::config::Config;
use oxygenhub::repos::RepoName;
use oxygenhub::{db, keys};
use std::path::PathBuf;

#[derive(Parser)]
#[command(name = "oxygenhub", version, about = "A forge for Oxygen repositories")]
struct Cli {
    /// The data directory (hub spec §3.2)
    #[arg(long, global = true, env = "OXYHUB_DATA", default_value = "data")]
    data: PathBuf,
    #[command(subcommand)]
    cmd: Cmd,
}

#[derive(Subcommand)]
enum Cmd {
    /// Create the data directory, keys, database and a default hub.toml
    Init {
        /// What links and clone URLs start with
        #[arg(long)]
        base_url: Option<String>,
        /// Generate a self-signed TLS certificate (developer edition)
        #[arg(long)]
        self_signed: bool,
    },
    /// Run the hub
    Serve,
    /// Offline administration
    Admin {
        #[command(subcommand)]
        cmd: AdminCmd,
    },
    /// Verify every repository's objects and signatures
    Check,
}

#[derive(Subcommand)]
enum AdminCmd {
    /// Repositories
    Repo {
        #[command(subcommand)]
        cmd: RepoCmd,
    },
}

#[derive(Subcommand)]
enum RepoCmd {
    /// Create an empty repository OWNER/NAME
    Create {
        slug: String,
        #[arg(long, default_value = "")]
        description: String,
        #[arg(long, default_value = "public")]
        visibility: String,
        /// Bind to this repository id now (32 hex characters, from `.oxy/id`);
        /// otherwise the first push binds it
        #[arg(long)]
        id: Option<String>,
    },
    /// List repositories
    List,
    /// Move a repository to the trash
    Delete { slug: String },
    /// Change the description, default bookmark or visibility
    Set {
        slug: String,
        #[arg(long)]
        description: Option<String>,
        #[arg(long)]
        default_bookmark: Option<String>,
        #[arg(long)]
        visibility: Option<String>,
    },
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(tracing_subscriber::EnvFilter::from_default_env().add_directive("oxygenhub=info".parse()?))
        .init();
    let cli = Cli::parse();
    match cli.cmd {
        Cmd::Init { base_url, self_signed } => init(&cli.data, base_url, self_signed).await,
        Cmd::Serve => {
            let config = Config::load(&cli.data)?;
            let app = oxygenhub::build(config).await?;
            oxygenhub::serve(app).await
        }
        Cmd::Admin { cmd: AdminCmd::Repo { cmd } } => {
            let config = Config::load(&cli.data)?;
            let app = oxygenhub::build(config).await?;
            repo_admin(&app, cmd).await
        }
        Cmd::Check => {
            let config = Config::load(&cli.data)?;
            let app = oxygenhub::build(config).await?;
            check(&app).await
        }
    }
}

async fn init(data: &PathBuf, base_url: Option<String>, self_signed: bool) -> anyhow::Result<()> {
    std::fs::create_dir_all(data)?;
    let toml_path = data.join("hub.toml");
    if !toml_path.exists() {
        let base = base_url.clone().unwrap_or_else(|| "http://127.0.0.1:7300".into());
        let mut text = String::from("# Oxygenhub configuration (docs/spec.md section 17.1)\n\n[site]\nname = \"Oxygenhub\"\n\n[server]\nbind = \"127.0.0.1:7300\"\n");
        if self_signed {
            text.push_str("tls_bind = \"0.0.0.0:7343\"\n");
        }
        text.push_str(&format!("base_url = \"{base}\"\n\n[tls]\nself_signed = {self_signed}\n\n[auth]\n# Bearer tokens allowed to push until accounts exist.\npush_tokens = []\n"));
        std::fs::write(&toml_path, text)?;
        println!("wrote {}", toml_path.display());
    }
    let mut config = Config::load(data)?;
    if let Some(b) = base_url {
        config.server.base_url = b;
    }
    let app = oxygenhub::build(config).await?;
    println!("hub key {}", app.hub_key.key.to_hex());
    if (self_signed || app.config.tls.self_signed)
        && keys::ensure_self_signed(&app.config.tls_cert(), &app.config.tls_key(), app.config.base_url())?
    {
        println!("wrote self-signed certificate {}", app.config.tls_cert().display());
    }
    println!("data directory {} is ready", data.display());
    Ok(())
}

async fn repo_admin(app: &oxygenhub::Shared, cmd: RepoCmd) -> anyhow::Result<()> {
    match cmd {
        RepoCmd::Create { slug, description, visibility, id } => {
            let name = RepoName::parse(&slug).ok_or_else(|| anyhow::anyhow!("{slug:?} is not a valid owner/name"))?;
            let visibility = Visibility::parse(&visibility).ok_or_else(|| anyhow::anyhow!("visibility is public, internal or private"))?;
            let id = match id {
                Some(h) => {
                    let bytes = hex::decode(h.trim()).ok().and_then(|v| <[u8; 16]>::try_from(v).ok());
                    Some(bytes.ok_or_else(|| anyhow::anyhow!("--id takes 32 hex characters"))?)
                }
                None => None,
            };
            if db::repos::get(&app.db, &name.owner, &name.name).await?.is_some() {
                anyhow::bail!("{name} already exists");
            }
            app.repos.create(&name, id)?;
            db::repos::create(&app.db, &name.owner, &name.name, &description, visibility).await?;
            println!("created {name}: oxy clone {}/{name}", app.config.base_url());
        }
        RepoCmd::List => {
            for r in db::repos::list(&app.db).await? {
                println!("{:<40} {:<8} {}", r.slug(), r.visibility, r.description);
            }
        }
        RepoCmd::Delete { slug } => {
            let name = RepoName::parse(&slug).ok_or_else(|| anyhow::anyhow!("{slug:?} is not a valid owner/name"))?;
            let row = db::repos::get(&app.db, &name.owner, &name.name).await?.ok_or_else(|| anyhow::anyhow!("{name} does not exist"))?;
            let dest = app.repos.trash(&name)?;
            db::repos::delete(&app.db, row.id).await?;
            println!("moved {name} to {}", dest.display());
        }
        RepoCmd::Set { slug, description, default_bookmark, visibility } => {
            let name = RepoName::parse(&slug).ok_or_else(|| anyhow::anyhow!("{slug:?} is not a valid owner/name"))?;
            let row = db::repos::get(&app.db, &name.owner, &name.name).await?.ok_or_else(|| anyhow::anyhow!("{name} does not exist"))?;
            if let Some(d) = description {
                db::repos::set_description(&app.db, row.id, &d).await?;
            }
            if let Some(b) = default_bookmark {
                db::repos::set_default_bookmark(&app.db, row.id, &b).await?;
            }
            if let Some(v) = visibility {
                let v = Visibility::parse(&v).ok_or_else(|| anyhow::anyhow!("visibility is public, internal or private"))?;
                db::repos::set_visibility(&app.db, row.id, v).await?;
            }
            println!("updated {name}");
        }
    }
    Ok(())
}

async fn check(app: &oxygenhub::Shared) -> anyhow::Result<()> {
    let mut problems = 0;
    for r in db::repos::list(&app.db).await? {
        let name = RepoName::new(&r.owner, &r.name).unwrap();
        let report = app.repos.read(&name, oxygenhub::repos::view::verification).await;
        match report {
            Ok(v) => {
                println!(
                    "{:<40} {} changes, {} signed, {} sealed, {} unsigned, {} invalid",
                    name,
                    v.total,
                    v.signed,
                    v.sealed,
                    v.unsigned,
                    v.invalid.len()
                );
                problems += v.invalid.len();
            }
            Err(e) => {
                println!("{name:<40} ERROR {e}");
                problems += 1;
            }
        }
    }
    if problems > 0 {
        anyhow::bail!("{problems} problem(s)");
    }
    Ok(())
}