bpt 0.1.6

use crate::command::*;
use crate::error::CommandResult;
use crate::location::*;
use crate::metadata::*;
use camino::Utf8PathBuf;
use clap::Parser;
use clap::builder::{Styles, styling::AnsiColor};
use std::sync::LazyLock;

// Styling for `--help` output
const BEDROCK_CLAP_STYLE: Styles = Styles::styled()
    // Section headers, e.g. "Commands:"
    // .header(AnsiColor::Yellow.on_default().bold())
    // Error message
    .error(AnsiColor::Red.on_default().bold())
    // Literally the word "Usage:"
    // .usage(AnsiColor::Yellow.on_default().bold())
    // Literal things users should type verbatim like subcommand and flags
    .literal(AnsiColor::Green.on_default())
    // Items the user should substitute, e.g. [FLAG]
    .placeholder(AnsiColor::Yellow.on_default())
    // Suggestions for valid user input
    .valid(AnsiColor::Green.on_default())
    // Invalid user input in error messages
    .invalid(AnsiColor::Red.on_default());

#[derive(clap::Parser)]
#[clap(styles = BEDROCK_CLAP_STYLE)]
// CLAP's special-case handling of help and version flags clashes with our UX
// Disable it and implement handling like any other flag
/// Bedrock Package Tool
#[clap(
    version,
    propagate_version = true,
    disable_help_flag = true,
    disable_help_subcommand = true,
    disable_version_flag = true
)]
// Top-level `--help` output has two sections:
// 1. (sub)commands
// 2. common options
pub struct Cli {
    #[command(subcommand)]
    command: Command,
    #[clap(flatten)]
    common_flags: CommonFlags,
}

// (Sub)commands
#[derive(clap::Subcommand)]
enum Command {
    //////////////////////////////////
    // Modify installed package set //
    //////////////////////////////////
    /// Install packages
    Install {
        /// May be any combination of the following:
        /// - Package identifier (e.g. package name) of a repository package
        /// - File path to a binary package (*.bpt)
        /// - File path to a build definition (*.bbuild)
        /// - http(s) URL to a binary package (*.bpt)
        /// - http(s) URL to a build definition (*.bbuild)
        #[clap(verbatim_doc_comment, required = true)]
        pkgs: Vec<PkgPathUrlRepo>,
        /// Reinstall already installed package(s)
        #[clap(short, long, help_heading = "Install options")]
        reinstall: bool,
    },
    /// Remove installed packages
    Remove {
        /// Installed packages to remove
        #[clap(verbatim_doc_comment, required = true)]
        pkgs: Vec<PartId>,
        /// Also remove modified configuration files
        #[clap(short, long, help_heading = "Remove options")]
        purge: bool,
        /// Forget package metadata without removing files from disk
        #[clap(short, long, help_heading = "Remove options")]
        forget: bool,
    },
    /// Upgrade installed packages
    Upgrade {
        /// May be any combination of the following:
        /// - Empty list, indicating all installed packages
        /// - Package identifier (e.g. package name) of a repository package
        /// - File path to a binary package (*.bpt)
        /// - File path to a build definition (*.bbuild)
        /// - http(s) URL to a binary package (*.bpt)
        /// - http(s) URL to a build definition (*.bbuild)
        #[clap(verbatim_doc_comment)]
        pkgs: Vec<PkgPathUrlRepo>,
    },
    /// Downgrade installed packages
    Downgrade {
        /// May be any combination of the following:
        /// - Package identifier (e.g. package name) of a repository package
        /// - File path to a binary package (*.bpt)
        /// - File path to a build definition (*.bbuild)
        /// - http(s) URL to a binary package (*.bpt)
        /// - http(s) URL to a build definition (*.bbuild)
        #[clap(verbatim_doc_comment, required = true)]
        pkgs: Vec<PkgPathUrlRepo>,
    },
    /// Apply current world file to the installed package set
    Apply,

    ////////////////////
    // Query database //
    ////////////////////
    /// Check installed package install integrity (e.g. file checksums)
    Check {
        /// May be any combination of the following:
        /// - Empty list, indicating all installed packages
        /// - Package identifier (e.g. package name) of an installed package
        #[clap(verbatim_doc_comment)]
        pkgs: Vec<PartId>,
        /// Treat backup file content differences as errors
        #[clap(
            short,
            long,
            help_heading = "Check options",
            conflicts_with = "ignore_backup"
        )]
        strict: bool,
        /// Ignore backup file content differences
        #[clap(short, long, help_heading = "Check options", conflicts_with = "strict")]
        ignore_backup: bool,
    },
    /// Describe packages
    Info {
        /// May be any combination of the following:
        /// - Package identifier (e.g. package name) of an installed package
        /// - Package identifier (e.g. package name) of a repository package
        /// - File path to a binary package (*.bpt)
        /// - File path to a build definition (*.bbuild)
        /// - http(s) URL to a binary package (*.bpt)
        /// - http(s) URL to a build definition (*.bbuild)
        #[clap(verbatim_doc_comment, required = true)]
        pkgs: Vec<PkgPathUrlRepo>,
        /// Search installed packages
        #[clap(short, long, help_heading = "Info options")]
        installed: bool,
        /// Search repository packages
        #[clap(short, long, help_heading = "Info options")]
        repository: bool,
    },
    /// List files provided by packages
    Files {
        /// May be any combination of the following:
        /// - Package identifier (e.g. package name) of an installed package
        /// - Package identifier (e.g. package name) of a repository binary package
        /// - File path to a binary package (*.bpt)
        /// - http(s) URL to a binary package (*.bpt)
        #[clap(verbatim_doc_comment, required = true)]
        pkgs: Vec<BptPathUrlRepo>,
        /// Search installed packages
        #[clap(short, long, help_heading = "Files options")]
        installed: bool,
        /// Search repository packages
        #[clap(short, long, help_heading = "Files options")]
        repository: bool,
    },
    /// Search packages
    // If no flags constrain search, searches everything.
    Search {
        /// Regular expression to match against package names or descriptions
        /// (Case insensitive unless uppercase ASCII character(s) present)
        #[clap(verbatim_doc_comment, required = true)]
        regex: String,
        /// Search package names
        #[clap(short, long, help_heading = "Search options")]
        name: bool,
        /// Search package descriptions
        #[clap(short, long, help_heading = "Search options")]
        description: bool,
        /// Search installed packages
        #[clap(short, long, help_heading = "Search options")]
        installed: bool,
        /// Search repository packages
        #[clap(short, long, help_heading = "Search options")]
        repository: bool,
    },
    /// List packages
    // If no flags constrain list, lists everything.
    List {
        /// List installed packages
        #[clap(short, long, help_heading = "List options")]
        installed: bool,
        /// List repository packages
        #[clap(short, long, help_heading = "List options")]
        repository: bool,
        /// List explicitly installed packages
        #[clap(short = 'x', long, help_heading = "List options")]
        explicit: bool,
        /// List packages installed as dependencies
        #[clap(short = 'd', long, help_heading = "List options")]
        dependency: bool,
    },
    /// List packages that provide files
    // If no flags constrain list, lists everything.
    Provides {
        /// Regex to match against package file paths
        /// Case insensitive unless uppercase ASCII character(s) present
        #[clap(required = true)]
        regex: String,
        /// Search installed packages
        #[clap(short, long, help_heading = "Provides options")]
        installed: bool,
        /// Search repository packages
        #[clap(short, long, help_heading = "Provides options")]
        repository: bool,
    },

    /////////////////////////
    // Repository requests //
    /////////////////////////
    /// Sync repository information
    Sync {
        /// May be any combination of the following:
        /// - Empty list, indicating all configured indexes
        /// - http(s) URL to a package index (*.pkgidx)
        /// - http(s) URL to a file index (*.fileidx)
        /// - File path to a package index (*.pkgidx)
        /// - File path to a file index (*.fileidx)
        #[clap(verbatim_doc_comment)]
        indexes: Vec<IdxPathUrl>,
        /// Refresh indexes even if they were checked recently
        #[clap(short, long, help_heading = "Sync options")]
        force: bool,
    },
    /// Fetch packages from repositories
    Fetch {
        /// Package identifier (e.g. package name) of a repository package
        #[clap(required = true)]
        pkgs: Vec<PartId>,
    },
    /// Remove cached packages and/or source files
    Clean {
        /// Remove cached packages
        #[clap(short, long, help_heading = "Clean options")]
        packages: bool,
        /// Remove cached source files
        #[clap(short = 's', long, help_heading = "Clean options")]
        source: bool,
    },

    //////////////////////
    // Package building //
    //////////////////////
    /// Build binary packages (*.bpt) from build definitions (*.bbuild)
    Build {
        /// May be any combination of the following:
        /// - Package identifier (e.g. package name) buildable from repository build definitions
        /// - http(s) URL to a build definition (*.bbuild)
        /// - File path to a build definition (*.bbuild)
        #[clap(verbatim_doc_comment, required = true)]
        bbuilds: Vec<BbuildPathUrlRepo>,
        /// Target architecture
        #[clap(short, long, value_enum, default_value = Arch::host().as_str(), help_heading = "Build options")]
        arch: Arch,
    },
    /// Generate local repository *.bpt, *.pkgidx, and *.fileidx files
    MakeRepo,

    ////////////////
    // Signatures //
    ////////////////
    /// Verify signatures
    Verify {
        /// File paths to signed files to verify
        #[clap(required = true)]
        paths: Vec<Utf8PathBuf>,
    },
    /// Sign files, stripping preexisting signatures if necessary.
    Sign {
        /// Only (re)sign files which do not currently pass `bpt verify`
        #[clap(short, long)]
        needed: bool,
        /// File paths to files to (re)sign
        #[clap(required = true)]
        paths: Vec<Utf8PathBuf>,
    },
}

const COMMON: &str = "Common options";

// False positive warning on Clap's manual help
#[allow(clippy::manual_non_exhaustive)]
#[derive(Parser)]
pub struct CommonFlags {
    /// Display this help information
    #[clap(short = 'h', long, global = true, help_heading = COMMON, action = clap::ArgAction::HelpLong)]
    help: (),

    /// Display version information
    #[clap(short = 'v', long, global = true, help_heading = COMMON, action = clap::ArgAction::Version)]
    version: (),
    /// Assume "yes" as answer to all prompts and run non-interactively.
    #[clap(short = 'y', long, global = true, help_heading = COMMON)]
    pub yes: bool,

    /// Show steps that would be taken without taking them.
    #[clap(short = 'D', long, global = true, help_heading = COMMON)]
    pub dry_run: bool,

    /// Print network utility stderr
    #[clap(short = 'N', long, global = true, help_heading = COMMON)]
    pub netutil_stderr: bool,

    /// Skip verifying signatures
    #[clap(short = 'V', long, global = true, help_heading = COMMON)]
    pub skip_verify: bool,

    /// Skip signing results
    #[clap(short = 'S', long, global = true, help_heading = COMMON)]
    pub skip_sign: bool,

    /// Minisign private key (aka secret key)
    #[clap(short = 'P', long, global = true, default_value = default_priv_key_path(), help_heading = COMMON)]
    pub priv_key: Utf8PathBuf,

    /// File containing minisign private key passphrase for non-interactive use
    #[clap(long, global = true, help_heading = COMMON)]
    pub priv_key_passphrase_file: Option<Utf8PathBuf>,

    /// Output directory for fetched or built files
    #[clap(short = 'O', long, global = true, default_value = default_out_dir_path(), help_heading = COMMON)]
    pub out_dir: Utf8PathBuf,

    /// Manage file system at root
    #[clap(short = 'R', long, global = true, default_value = "/", help_heading = COMMON)]
    pub root_dir: RootDir,
}

fn default_priv_key_path() -> &'static str {
    // Clap 4.0 only accepts defaults as reference types (&str or &OsStr).  In order to support this,
    // (ab)use a dynamically populated static value.
    static DEFAULT_PRIV_KEY: LazyLock<Utf8PathBuf> = LazyLock::new(|| {
        dirs::home_dir()
            .and_then(|mut p| {
                p.push(".minisign/minisign.key");
                Utf8PathBuf::try_from(p).ok()
            })
            .expect("Unable to get home directory")
    });

    DEFAULT_PRIV_KEY.as_str()
}

fn default_out_dir_path() -> &'static str {
    // Clap 4.0 only accepts defaults as reference types (&str or &OsStr).  In order to support this,
    // (ab)use a dynamically populated static value.
    static DEFAULT_OUT_DIR: LazyLock<Utf8PathBuf> = LazyLock::new(|| {
        std::env::current_dir()
            .and_then(|cwd| Utf8PathBuf::try_from(cwd).map_err(|e| e.into_io_error()))
            .expect("Unable to get current working directory")
    });

    DEFAULT_OUT_DIR.as_str()
}

impl Cli {
    pub fn run(self) -> CommandResult {
        let Self {
            command,
            common_flags,
        } = self;

        match command {
            Command::Install { pkgs, reinstall } => install(common_flags, pkgs, reinstall),
            Command::Remove {
                pkgs,
                purge,
                forget,
            } => remove(common_flags, pkgs, purge, forget),
            Command::Upgrade { pkgs } => upgrade(common_flags, pkgs),
            Command::Downgrade { pkgs } => downgrade(common_flags, pkgs),
            Command::Apply => apply(common_flags),
            Command::Check {
                pkgs,
                strict,
                ignore_backup,
            } => check(common_flags, pkgs, strict, ignore_backup),
            Command::Info {
                pkgs,
                installed,
                repository,
            } => info(common_flags, pkgs, installed, repository),
            Command::Files {
                pkgs,
                installed,
                repository,
            } => files(common_flags, pkgs, installed, repository),
            Command::Search {
                regex,
                name,
                description,
                installed,
                repository,
            } => search(
                common_flags,
                regex,
                name,
                description,
                installed,
                repository,
            ),
            Command::List {
                installed,
                repository,
                explicit,
                dependency,
            } => list(common_flags, installed, repository, explicit, dependency),
            Command::Provides {
                regex,
                installed,
                repository,
            } => provides(common_flags, regex, installed, repository),
            Command::Sync { indexes, force } => sync(common_flags, indexes, force),
            Command::Fetch { pkgs } => fetch(common_flags, pkgs),
            Command::Clean { packages, source } => clean(common_flags, packages, source),
            Command::Build { bbuilds, arch } => build(common_flags, bbuilds, arch),
            Command::MakeRepo => make_repo(common_flags),
            Command::Verify { paths } => verify(common_flags, paths),
            Command::Sign { needed, paths } => sign(common_flags, needed, paths),
        }
    }
}