mod activate;
mod cache;
mod cas;
mod cli;
mod config;
mod gc;
mod generate;
mod git_export;
mod git_ssh;
mod identity;
mod init;
mod manifest;
mod mirror;
mod nginx;
mod oauth;
mod output;
mod pds;
mod project;
mod provision;
mod registry;
mod request_key;
mod snapshot;

use std::sync::Arc;

use clap::Parser as _;

fn init_tracing() {
    let filter = tracing_subscriber::EnvFilter::try_from_default_env()
        .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("info"));
    tracing_subscriber::fmt()
        .with_env_filter(filter)
        .with_writer(std::io::stderr)
        .init();
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    init_tracing();
    let cli = cli::Cli::parse();
    let config = Arc::new(config::ValidatedConfig::load(&cli.config)?);

    use cli::{Command, PlcCommand, RepoCommand};
    match cli.command {
        Command::Init => init::run(config).await,
        Command::Repo { command } => match command {
            RepoCommand::Import(args) => provision::import(config, args).await,
            RepoCommand::Create(args) => provision::create(config, args).await,
            RepoCommand::List => registry::list(config).await,
            RepoCommand::Record(args) => pds::record(config, &args.repo_did, args.publish).await,
        },
        Command::Plc { command } => match command {
            PlcCommand::Sync => registry::plc_sync(config).await,
        },
        Command::Generate { repo } => generate::run(config, repo.as_deref()).await.map(|_| ()),
        Command::Activate { generation } => activate::run(config, &generation).await,
        Command::OAuth { command } => match command {
            cli::OAuthCommand::Login { owner } => {
                let owner_did = match owner {
                    Some(raw) => knot_types::AccountDid::new(raw)?,
                    None => config.owner.clone(),
                };
                oauth::run_interactive_auth(&config, &owner_did).await.map(|_| ())
            }
            cli::OAuthCommand::Status => oauth::print_status(&config).await,
        },
        Command::GitSsh => git_ssh::run(config).await,
        Command::PostActivate { repos } => {
            activate::post_activate(config, &repos).await;
            Ok(())
        }
    }
}