use argh::FromArgs;

#[derive(FromArgs)]
#[argh(name = "cargo smart-release")]
/// Release workspace crates fearlessly.
///
/// Use --execute to actually perform the operation.
pub struct Args {
    #[argh(subcommand)]
    pub subcommands: SubCommands,
}

#[derive(FromArgs)]
#[argh(subcommand)]
pub enum SubCommands {
    SmartRelease(SmartRelease),
}

#[derive(FromArgs)]
#[argh(subcommand, name = "smart-release")]
/// Release workspace crates fearlessly.
///
/// Use --execute to actually perform the operation.
pub struct SmartRelease {
    /// actually perform a release. Dry-run mode is the default
    #[argh(switch, short = 'n')]
    pub execute: bool,

    /// provide more detailed messages on the INFO log level in dry-run mode.
    ///
    /// Note --verbose is implied with --execute.
    #[argh(switch, short = 'v')]
    pub verbose: bool,

    /// always bump versions as specified by --bump or --bump-dependencies even if this is not required.
    ///
    /// If it's required or not is determined by looking at the published versions in the crates index.
    #[argh(switch, short = 'd')]
    pub no_bump_on_demand: bool,

    /// additionally run 'cargo publish --dry-run' when --execute is not set. This can be useful to see which local
    /// crates do not build with the released versions of their workspace dependencies anymore.
    #[argh(switch)]
    pub dry_run_cargo_publish: bool,

    /// allow publishes to take place on a dirty working tree. Really not recommended alongside --execute.
    #[argh(switch)]
    pub allow_dirty: bool,

    /// always update the crates-index beforehand. It is used to determine if the computed version to be published was
    /// already published.
    #[argh(switch, short = 'u')]
    pub update_crates_index: bool,

    /// allow discovery of changed crates to also publish stable crates, bumping their version according to --bump <spec>.
    #[argh(switch)]
    pub allow_auto_publish_of_stable_crates: bool,

    /// don't actually publish, but perform all other operations like manifest adjustments and tag creation.
    #[argh(switch)]
    pub skip_publish: bool,

    /// don't create tags indicating the version numbers of all crates that are to be published after changing
    /// their manifests.
    #[argh(switch)]
    pub skip_tag: bool,

    /// don't push tags and the HEAD branch after any successful run of `cargo publish`.
    #[argh(switch)]
    pub skip_push: bool,

    /// do not take into consideration any dependencies of the crates to publish.
    ///
    /// This flag is useful when various `--skip-X` are specified in order to bump versions only, without publishing.
    #[argh(switch)]
    pub skip_dependencies: bool,

    /// pass --no-verify to 'cargo publish' which should only be a last resort when fixing up packages that
    /// otherwise wouldn't publish, but need to be publish to resolve the situation.
    #[argh(switch)]
    pub dangerously_pass_no_verify: bool,

    /// if set it will be allowed to publish crates with cycles to other workspace crates which are not published.
    ///
    /// Doing so causes repeated publishes to never stabilize, as one set of dependencies destabilizes another set.
    /// A possible fix is to bump version numbers of all crates in the set at once and publishing those who would
    /// depend on an unpublished version with "--no-validate".
    #[argh(switch)]
    pub ignore_instability: bool,

    /// specify the kind of version bump you seek for the crate and potentially it's dependencies.
    ///
    /// Can be 'major', 'minor' or 'patch', or 'keep' which doesn't alter the version.
    /// If unspecified, the current version will be kept, useful if versions are specified manually.
    #[argh(option, short = 'b')]
    pub bump: Option<String>,

    /// specify the kind of version bump to apply to dependencies only.
    ///
    /// Can be 'major', 'minor' or 'patch', or 'keep' which doesn't alter the version.
    /// If unspecified, "keep" will be used.
    #[argh(option, short = 'b')]
    pub bump_dependencies: Option<String>,

    /// the name of the crates to be released, along with all of their dependencies if needed, using `cargo release`
    #[argh(positional)]
    pub crates: Vec<String>,
}