cargo-gears 0.0.1

use crate::common::{DbConnConfig, PathConfigArgs};
use clap::{Args, Subcommand};

#[derive(Args)]
pub struct ConfigArgs {
    #[command(subcommand)]
    command: ConfigCommand,
}

impl ConfigArgs {
    pub fn run(self) -> anyhow::Result<()> {
        cargo_gears_core::config::ConfigParams::from(self).run()
    }
}

impl From<ConfigArgs> for cargo_gears_core::config::ConfigParams {
    fn from(args: ConfigArgs) -> Self {
        Self {
            command: args.command.into(),
        }
    }
}

#[derive(Subcommand)]
pub enum ConfigCommand {
    Mod(ConfigModulesArgs),
    Db(Box<ConfigDbArgs>),
}

impl From<ConfigCommand> for cargo_gears_core::config::ConfigCommand {
    fn from(command: ConfigCommand) -> Self {
        match command {
            ConfigCommand::Mod(args) => Self::Mod(args.into()),
            ConfigCommand::Db(args) => Self::Db(Box::new((*args).into())),
        }
    }
}

#[derive(Args)]
pub struct ConfigDbArgs {
    #[command(subcommand)]
    command: ConfigDbCommand,
}

impl From<ConfigDbArgs> for cargo_gears_core::config::db::DbParams {
    fn from(args: ConfigDbArgs) -> Self {
        Self {
            command: args.command.into(),
        }
    }
}

#[derive(Subcommand)]
enum ConfigDbCommand {
    /// Add or update (upsert) a global database server config under `database.servers`
    Add(ConfigDbAddArgs),
    /// Edit a global database server config under `database.servers`
    Edit(ConfigDbEditArgs),
    /// Remove a global database server config from `database.servers`
    Rm(ConfigDbRemoveArgs),
}

impl From<ConfigDbCommand> for cargo_gears_core::config::db::DbCommand {
    fn from(command: ConfigDbCommand) -> Self {
        match command {
            ConfigDbCommand::Add(args) => Self::Add(args.into()),
            ConfigDbCommand::Edit(args) => Self::Edit(args.into()),
            ConfigDbCommand::Rm(args) => Self::Rm(args.into()),
        }
    }
}

#[derive(Args)]
struct ConfigDbAddArgs {
    #[command(flatten)]
    path_config: PathConfigArgs,
    /// Server name under `database.servers.<name>`
    name: String,
    #[command(flatten)]
    conn: DbConnConfig,
}

impl From<ConfigDbAddArgs> for cargo_gears_core::config::db::AddArgs {
    fn from(args: ConfigDbAddArgs) -> Self {
        Self {
            path_config: args.path_config.into(),
            name: args.name,
            conn: args.conn.into(),
        }
    }
}

#[derive(Args)]
struct ConfigDbEditArgs {
    #[command(flatten)]
    path_config: PathConfigArgs,
    /// Server name under `database.servers.<name>`
    name: String,
    #[command(flatten)]
    conn: DbConnConfig,
}

impl From<ConfigDbEditArgs> for cargo_gears_core::config::db::EditArgs {
    fn from(args: ConfigDbEditArgs) -> Self {
        Self {
            path_config: args.path_config.into(),
            name: args.name,
            conn: args.conn.into(),
        }
    }
}

#[derive(Args)]
struct ConfigDbRemoveArgs {
    #[command(flatten)]
    path_config: PathConfigArgs,
    /// Server name under `database.servers.<name>`
    name: String,
}

impl From<ConfigDbRemoveArgs> for cargo_gears_core::config::db::RemoveArgs {
    fn from(args: ConfigDbRemoveArgs) -> Self {
        Self {
            path_config: args.path_config.into(),
            name: args.name,
        }
    }
}

#[derive(Args)]
pub struct ConfigModulesArgs {
    #[command(subcommand)]
    command: ConfigModulesCommand,
}

impl From<ConfigModulesArgs> for cargo_gears_core::config::modules::ModulesParams {
    fn from(args: ConfigModulesArgs) -> Self {
        Self {
            command: args.command.into(),
        }
    }
}

#[derive(Subcommand)]
pub enum ConfigModulesCommand {
    /// Add or update a module in the modules section (upsert)
    Add(ConfigModuleAddArgs),
    /// Manage module-level database config
    Db(Box<ConfigModuleDbArgs>),
    /// Remove a module from the modules section
    Rm(ConfigModuleRemoveArgs),
}

impl From<ConfigModulesCommand> for cargo_gears_core::config::modules::ModulesCommand {
    fn from(command: ConfigModulesCommand) -> Self {
        match command {
            ConfigModulesCommand::Add(args) => Self::Add(args.into()),
            ConfigModulesCommand::Db(args) => Self::Db(Box::new((*args).into())),
            ConfigModulesCommand::Rm(args) => Self::Rm(args.into()),
        }
    }
}

#[derive(Args)]
pub struct ConfigModuleAddArgs {
    #[command(flatten)]
    path_config: PathConfigArgs,
    /// Module name
    module: String,
    /// Module package name for metadata
    #[arg(long)]
    package: Option<String>,
    /// Module package version for metadata
    #[arg(long = "module-version")]
    module_version: Option<String>,
    /// Whether Cargo default features should be enabled
    #[arg(long)]
    default_features: Option<bool>,
    /// Feature to include in metadata (repeatable)
    #[arg(short = 'F', long = "feature", value_delimiter = ',')]
    features: Vec<String>,
    /// Dependency name to include in metadata.deps (repeatable)
    #[arg(long = "dep")]
    deps: Vec<String>,
}

impl From<ConfigModuleAddArgs> for cargo_gears_core::config::modules::add::AddParams {
    fn from(args: ConfigModuleAddArgs) -> Self {
        Self {
            path_config: args.path_config.into(),
            module: args.module,
            package: args.package,
            module_version: args.module_version,
            default_features: args.default_features,
            features: args.features,
            deps: args.deps,
        }
    }
}

#[derive(Args)]
pub struct ConfigModuleDbArgs {
    #[command(subcommand)]
    command: ConfigModuleDbCommand,
}

impl From<ConfigModuleDbArgs> for cargo_gears_core::config::modules::db::ModuleDbParams {
    fn from(args: ConfigModuleDbArgs) -> Self {
        Self {
            command: args.command.into(),
        }
    }
}

#[derive(Subcommand)]
enum ConfigModuleDbCommand {
    /// Add or update (upsert) a module-level database configuration
    Add(ConfigModuleDbAddArgs),
    /// Edit a module-level database configuration
    Edit(ConfigModuleDbEditArgs),
    /// Remove a module-level database configuration
    Rm(ConfigModuleDbRemoveArgs),
}

impl From<ConfigModuleDbCommand> for cargo_gears_core::config::modules::db::ModuleDbCommand {
    fn from(command: ConfigModuleDbCommand) -> Self {
        match command {
            ConfigModuleDbCommand::Add(args) => Self::Add(args.into()),
            ConfigModuleDbCommand::Edit(args) => Self::Edit(args.into()),
            ConfigModuleDbCommand::Rm(args) => Self::Rm(args.into()),
        }
    }
}

#[derive(Args)]
struct ConfigModuleDbAddArgs {
    #[command(flatten)]
    path_config: PathConfigArgs,
    /// Module name under `modules.<module>`
    module: String,
    #[command(flatten)]
    conn: DbConnConfig,
}

impl From<ConfigModuleDbAddArgs> for cargo_gears_core::config::modules::db::AddArgs {
    fn from(args: ConfigModuleDbAddArgs) -> Self {
        Self {
            path_config: args.path_config.into(),
            module: args.module,
            conn: args.conn.into(),
        }
    }
}

#[derive(Args)]
struct ConfigModuleDbEditArgs {
    #[command(flatten)]
    path_config: PathConfigArgs,
    /// Module name under `modules.<module>`
    module: String,
    #[command(flatten)]
    conn: DbConnConfig,
}

impl From<ConfigModuleDbEditArgs> for cargo_gears_core::config::modules::db::EditArgs {
    fn from(args: ConfigModuleDbEditArgs) -> Self {
        Self {
            path_config: args.path_config.into(),
            module: args.module,
            conn: args.conn.into(),
        }
    }
}

#[derive(Args)]
struct ConfigModuleDbRemoveArgs {
    #[command(flatten)]
    path_config: PathConfigArgs,
    /// Module name under `modules.<module>`
    module: String,
}

impl From<ConfigModuleDbRemoveArgs> for cargo_gears_core::config::modules::db::RemoveArgs {
    fn from(args: ConfigModuleDbRemoveArgs) -> Self {
        Self {
            path_config: args.path_config.into(),
            module: args.module,
        }
    }
}

#[derive(Args)]
pub struct ConfigModuleRemoveArgs {
    #[command(flatten)]
    path_config: PathConfigArgs,
    /// Module name
    module: String,
}

impl From<ConfigModuleRemoveArgs> for cargo_gears_core::config::modules::remove::RemoveParams {
    fn from(args: ConfigModuleRemoveArgs) -> Self {
        Self {
            path_config: args.path_config.into(),
            module: args.module,
        }
    }
}