fn main() {
    let cmd = clap::Command::new("cargo")
        .bin_name("cargo")
        .subcommand_required(true)
        .subcommand(
            clap::command!("example").arg(
                clap::arg!(--"manifest-path" <PATH>)
                    .value_parser(clap::value_parser!(std::path::PathBuf)),),
        );

    // 从 os:env::args() 获得输入
    let matches = cmd.get_matches();

    // 匹配子命令
    let matches = match matches.subcommand() {
        Some(("example", matches)) => matches,
        _ => unreachable!("clap should ensure we don't get here"),
    };

    // 获得子命令的选项参数
    let manifest_path = matches.get_one::<std::path::PathBuf>("manifest-path");
    println!("{manifest_path:?}");
}

use clap::Parser;

#[derive(Parser)]
#[command(name = "cargo", bin_name = "cargo", subcommand_required = true)]
enum CargoCli {
    ExampleDerive(ExampleDeriveArgs),
}

#[derive(clap::Args)]
#[command(version, about, long_about = None)]
struct ExampleDeriveArgs {
    #[arg(long)]
    manifest_path: Option<std::path::PathBuf>,
}

fn main() {
    let CargoCli::ExampleDerive(args) = CargoCli::parse();
    println!("{:?}", args.manifest_path);
}

impl Arg
    pub fn value_parser(self, parser: impl IntoResettable<ValueParser>) -> Arg

// Register a type with value_parser!
pub trait ValueParserFactory {
    // 关联类型， 一般是实现 TypedValueParser 的类型。
    type Parser;

    // Required method
    fn value_parser() -> Self::Parser;
}

// clap 注册的 Rust 类型, 这些类型可以直接在 derive 宏修饰的 struct/enum 中使用.
impl ValueParserFactory for bool
impl ValueParserFactory for i8
impl ValueParserFactory for i16
impl ValueParserFactory for i32
impl ValueParserFactory for i64
impl ValueParserFactory for u8
impl ValueParserFactory for u16
impl ValueParserFactory for u32
impl ValueParserFactory for u64
impl ValueParserFactory for Box<str>
impl ValueParserFactory for Box<OsStr>
impl ValueParserFactory for Box<Path>
impl ValueParserFactory for String
impl ValueParserFactory for OsString
impl ValueParserFactory for PathBuf

// Parser 需要实现 TypedValueParser trait
impl<T> ValueParserFactory for Box<T>
    where T: ValueParserFactory + Send + Sync + Clone, <T as ValueParserFactory>::Parser: TypedValueParser<Value = T>
impl<T> ValueParserFactory for Arc<T>
    where T: ValueParserFactory + Send + Sync + Clone, <T as ValueParserFactory>::Parser: TypedValueParser<Value = T>
impl<T> ValueParserFactory for Wrapping<T>
    where T: ValueParserFactory + Send + Sync + Clone, <T as ValueParserFactory>::Parser: TypedValueParser<Value = T>,

/// Simple program to greet a person
#[derive(Parser, Debug)]
#[command(version, about, long_about = None)]
struct Args {
    /// Name of the person to greet
    #[arg(short, long)]
    name: String, // String 和 u8 实现了 ValueParserFactory trait，故可以直接使用。

    /// Number of times to greet
    #[arg(short, long, default_value_t = 1)]
    count: u8,
    
    #[arg(long)]
    manifest_path: Option<std::path::PathBuf>, // Option<T>/Vec<T> 也 OK
    
    // 调用 value_parser() 方法，传入实现 TypedValuePrarser trait 的类型，
    // 这里使用闭包实现 TypedValuePrarser triat。
    #[arg(value_parser = validate_package_name)] 
    package_name: String,
    
    /// Network port to use
    // clap::value_parser!(u16) 返回 clap::builder::RangedI64ValueParser 类型，它有 range 方法
    #[arg(value_parser = clap::value_parser!(u16).range(1..))]
    port: u16,
}

// Built-in types
let parser = clap::value_parser!(String);
assert_eq!(format!("{parser:?}"), "ValueParser::string");

let parser = clap::value_parser!(std::ffi::OsString);
assert_eq!(format!("{parser:?}"), "ValueParser::os_string");

let parser = clap::value_parser!(std::path::PathBuf);
assert_eq!(format!("{parser:?}"), "ValueParser::path_buf");
        
// clap::value_parser!(u16) 返回 clap::builder::RangedI64ValueParser 类型，它有 range 方法        
clap::value_parser!(u16).range(3000..);
clap::value_parser!(u64).range(3000..);

let parser = clap::value_parser!(usize);
assert_eq!(format!("{parser:?}"), "_AnonymousValueParser(ValueParser::other(usize))");

// ValueEnum 类型
#[derive(Debug, Clone, Copy, ValueEnum, PartialEq, Eq)]
pub enum ColorChoice {
    Auto,
    Always,
    Never,
}
clap::value_parser!(ColorChoice);

pub trait TypedValueParser: Clone + Send + Sync + 'static {
    type Value: Send + Sync + Clone;

    // 从传入的 arg/value 来解析出 self::Value 类型值;
    fn parse_ref( &self, cmd: &Command, arg: Option<&Arg>, value: &OsStr ) -> Result<Self::Value, Error>;
    //...
}

// clap::builder module 提供了如下实现 TypedValueParser 的类型：
impl TypedValueParser for BoolValueParser // 返回 bool
impl TypedValueParser for BoolishValueParser // 将类似于 bool 值解析为 bool
impl TypedValueParser for FalseyValueParser
impl TypedValueParser for NonEmptyStringValueParser // 返回非空 String
impl TypedValueParser for OsStringValueParser // 返回 OsString
impl TypedValueParser for PathBufValueParser // 返回 PathBuf
impl TypedValueParser for PossibleValuesParser // 可选值列表
impl TypedValueParser for StringValueParser // 返回 String
impl TypedValueParser for UnknownArgumentValueParser
impl<E> TypedValueParser for EnumValueParser<E> where E: ValueEnum + Clone + Send + Sync + 'static // 枚举值

// 可以通过闭包来实现 TypedValueParser， 闭包的参数是 &str： Fn(&str) -> Result<T, E>， T 为解析后的值类型；
impl<F, T, E> TypedValueParser for F
where
    F: Fn(&str) -> Result<T, E> + Clone + Send + Sync + 'static,
    E: Into<Box<dyn Error + Sync + Send>>,
    T: Send + Sync + Clone

impl<P, F, T> TypedValueParser for MapValueParser<P, F>
where
    P: TypedValueParser,
    <P as TypedValueParser>::Value: Send + Sync + Clone,
    F: Fn(<P as TypedValueParser>::Value) -> T + Clone + Send + Sync + 'static,
    T: Send + Sync + Clone

impl<P, F, T, E> TypedValueParser for TryMapValueParser<P, F>
where
    P: TypedValueParser,
    <P as TypedValueParser>::Value: Send + Sync + Clone,
    F: Fn(<P as TypedValueParser>::Value) -> Result<T, E> + Clone + Send + Sync + 'static,
    T: Send + Sync + Clone,
    E: Into<Box<dyn Error + Sync + Send>>

// RangedI64ValueParser 和 RangedU64ValueParser 用于定义一个 range 范围。
impl<T> TypedValueParser for RangedI64ValueParser<T>
where
    T: TryFrom<i64> + Clone + Send + Sync + 'static,
    <T as TryFrom<i64>>::Error: Send + Sync + 'static + Error + ToString

impl<T> TypedValueParser for RangedU64ValueParser<T>
where
    T: TryFrom<u64> + Clone + Send + Sync + 'static,
    <T as TryFrom<u64>>::Error: Send + Sync + 'static + Error + ToString,

let mut cmd = clap::Command::new("raw")
    .arg(
        clap::Arg::new("append")
            .value_parser(clap::builder::BoolishValueParser::new())
            .required(true)
    );

let m = cmd.try_get_matches_from_mut(["cmd", "true"]).unwrap();
let port: bool = *m.get_one("append")
    .expect("required");
assert_eq!(port, true);

let value_parser = clap::builder::BoolishValueParser::new();
assert!(value_parser.parse_ref(&cmd, arg, OsStr::new("random")).is_err());
assert!(value_parser.parse_ref(&cmd, arg, OsStr::new("")).is_err());
assert!(value_parser.parse_ref(&cmd, arg, OsStr::new("100")).is_err());
assert_eq!(value_parser.parse_ref(&cmd, arg, OsStr::new("true")).unwrap(), true);
assert_eq!(value_parser.parse_ref(&cmd, arg, OsStr::new("Yes")).unwrap(), true);
assert_eq!(value_parser.parse_ref(&cmd, arg, OsStr::new("oN")).unwrap(), true);
assert_eq!(value_parser.parse_ref(&cmd, arg, OsStr::new("1")).unwrap(), true);
assert_eq!(value_parser.parse_ref(&cmd, arg, OsStr::new("false")).unwrap(), false);
assert_eq!(value_parser.parse_ref(&cmd, arg, OsStr::new("No")).unwrap(), false);
assert_eq!(value_parser.parse_ref(&cmd, arg, OsStr::new("oFF")).unwrap(), false);
assert_eq!(value_parser.parse_ref(&cmd, arg, OsStr::new("0")).unwrap(), false);

// 使用宏来创建 TypedValueParser
let mut cmd = clap::Command::new("raw")
    .arg(
        clap::Arg::new("port")
            .long("port")            
            .value_parser(clap::value_parser!(u16).range(3000..))
            .action(clap::ArgAction::Set)
            .required(true)
    );
let m = cmd.try_get_matches_from_mut(["cmd", "--port", "3001"]).unwrap();
let port: u16 = *m.get_one("port").expect("required");
assert_eq!(port, 3001);

// 使用 clap::builder module 提供的实现 TypedValueParser trait 的类型值
let mut cmd = clap::Command::new("raw")
    .arg(
        clap::Arg::new("append")
            // 使用实现 TypedValueParser trait 的类型值作为参数
            .value_parser(clap::builder::NonEmptyStringValueParser::new())
            .required(true)
    );
let m = cmd.try_get_matches_from_mut(["cmd", "true"]).unwrap();
let port: &String = m.get_one("append").expect("required");
assert_eq!(port, "true");


// 使用 Fn 闭包实现 TypedValueParser，闭包的参数是 &str，
// 返回的 Ok 值类型需要和 arg 字段类型值 T/Option<T>/Vec<T>/Option<Vec<T>> 中的 T 一致。
fn bytes_from_str(src: &str) -> Result<Bytes, Infallible> {
    Ok(Bytes::from(src.to_string()))
}

#[derive(Subcommand, Debug)]
enum Command {
    Ping {
        // value_parser 的值为实现 TypedValueParser 的类型。
        #[arg(value_parser = bytes_from_str)]
        msg: Option<Bytes>,
    }
}

#[derive(Copy, Clone, Debug)]
pub struct Custom(u32);

// Custom 实现 ValueParserFactory 后才能作为 value_parser!() 宏的参数
impl clap::builder::ValueParserFactory for Custom {
    type Parser = CustomValueParser; // Parser 需要实现 TypedValueParser

    fn value_parser() -> Self::Parser {
        CustomValueParser
    }
}

#[derive(Clone, Debug)]
pub struct CustomValueParser;

impl clap::builder::TypedValueParser for CustomValueParser {
    type Value = Custom;

    fn parse_ref(&self, cmd: &clap::Command, arg: Option<&clap::Arg>, value: &std::ffi::OsStr, ) -> Result<Self::Value, clap::Error> {
        // 使用 clap::value_parser!() 宏创建的 CustomValueParser 来解析参数。
        let inner = clap::value_parser!(u32);
        let val = inner.parse_ref(cmd, arg, value)?;
        Ok(Custom(val))
    }
}

// 使用自定义 Custom 类型
let parser: CustomValueParser = clap::value_parser!(Custom);

pub fn value_parser(self, parser: impl IntoResettable<ValueParser>) -> Arg

// 任何能 `Into<ValueParser>` 的类型值都可以作为 `Arg::value_parser()` 的参数：
impl<I> IntoResettable<ValueParser> for I where I: Into<ValueParser>

impl IntoResettable<ValueParser> for Option<ValueParser>

impl<I> IntoResettable<ValueRange> for I where I: Into<ValueRange>

pub struct ValueParser(/* private fields */);

// 从 TypedValueParser 创建 ValueParser
pub fn new<P>(other: P) -> ValueParser where  P: TypedValueParser,

// 从 [P; C] 和 Vec<P> 转换为 ValueParser, 其中 P 需要实现 Into<PossibleValue>，一般为 String/&str 等；
impl<P, const C: usize> From<[P; C]> for ValueParser where P: Into<PossibleValue>
impl<P> From<Vec<P>> for ValueParser where P: Into<PossibleValue>

// 从 TypedValueParser 转换为 ValueParser, 如预定义的 `BoolValueParser、BoolishValueParser、FalseyValueParser`` 等，
// 以及闭包 `Fn(&str) -> Result<T, E>`
impl<P> From<P> for ValueParser where P: TypedValueParser + Send + Sync + 'static

// 从 RangeXX 转换为 ValueParser
impl From<Range<i64>> for ValueParser
impl From<RangeFrom<i64>> for ValueParser
impl From<RangeFull> for ValueParser
impl From<RangeInclusive<i64>> for ValueParser
impl From<RangeTo<i64>> for ValueParser
impl From<RangeToInclusive<i64>> for ValueParser

// 从预定义的关联函数创建 ValueParser
pub const fn bool() -> ValueParser
pub const fn string() -> ValueParser
pub const fn os_string() -> ValueParser
pub const fn path_buf() -> ValueParser

pub struct PossibleValue { /* private fields */ }

impl PossibleValue
    pub fn new(name: impl Into<Str>) -> PossibleValue
    
// 为可生成 str 的任意对象转换为 PossibleValue
impl<S> From<S> for PossibleValue where S: Into<Str>

impl PossibleValuesParser
    pub fn new(values: impl Into<PossibleValuesParser>) -> PossibleValuesParser

// 为可迭代对象，如 &[&str], Vec<&str>, [&str; N] 等转换为 PossibleValuesParser
impl<I, T> From<I> for PossibleValuesParser where I: IntoIterator<Item = T>, T: Into<PossibleValue>

impl TypedValueParser for PossibleValuesParser

// 示例
let mut cmd = clap::Command::new("raw")
    .arg(
        clap::Arg::new("color")
            // 必须都是字符串列表
            // 1. Vec<&str>
            .value_parser(vec!["always", "auto", "never"]))
            // 2. [&str; 3]
            .value_parser(["always", "auto", "never"])
            .value_parser(clap::builder::PossibleValuesParser::new(["always", "auto", "never"]))
            .required(true)
        );

let m = cmd.try_get_matches_from_mut(["cmd", "always"]).unwrap();
let port: &String = m.get_one("color").expect("required");
assert_eq!(port, "always");

use std::path::PathBuf;
use clap::{arg, command, value_parser, ArgAction, Command};

// 设置 Command 参数
let m = Command::new("My Program")
    .author("Me, [email protected]")
    .version("1.0.2")
    .about("Explains in brief what the program does")
    .arg(Arg::new("in_file"))
    .after_help("Longer explanation to appear after the options when displaying the help information from --help or -h")
    .get_matches();

// 使用 crate_xx!() 宏来设置 Command 信息
let m = Command::new(crate_name!())
    .author(crate_authors!("\n"))
    .version(crate_version!())
    .about(crate_description!())
    .get_matches();

// command!() 从 Cargo.toml 中读取和设置 Command 的 name/version/authors/description 信息。
let matches = command!()
    // 使用 arg!() 宏来快捷创建 Arg，指定的 name 和 config 为 arg id，后续用来匹配查找参数值。
    .arg(arg!([name] "Optional name to operate on"))
    .arg(
        arg!(-c --config <FILE> "Sets a custom config file" )
            .required(false) // 可选参数（默认是必选的）
            .value_parser(value_parser!(PathBuf)) // 设置参数解析类型（默认为 String）
    ) 
    .arg(arg!( -d --debug ... "Turn debugging information on" ))
    .subcommand(
        // new 的参数为 command id，后续用来匹配命令
        Command::new("test")
            .about("does testing things")
            .arg(arg!(-l --list "lists test values").action(ArgAction::SetTrue))
    )
    .get_matches();

// name 为前面通过 Arg::new("name") 或 arg!([name]) 设置的 arg id
if let Some(name) = matches.get_one::<String>("name") {
    println!("Value for name: {name}");
}

if let Some(config_path) = matches.get_one::<PathBuf>("config") {
    println!("Value for config: {}", config_path.display());
}

if let Some(matches) = matches.subcommand_matches("test") {
    // "$ myapp test" was run
    if matches.get_flag("list") {
        // "$ myapp test -l" was run
        println!("Printing testing lists...");
    } else {
        println!("Not printing testing lists...");
    }
}

fn main() {
    let cli = Command::new("Built CLI");
    // Augment with derived subcommands
    let cli = Subcommands::augment_subcommands(cli);

    let matches = cli.get_matches();
    let derived_subcommands = Subcommands::from_arg_matches(&matches)
        .map_err(|err| err.exit())
        .unwrap();
    println!("Derived subcommands: {derived_subcommands:#?}");
}

let m = cmd.clone().get_matches_from(vec!["prog", "-F", "in-file", "out-file"]);

let matches = Command::new("MyApp")
    .arg(Arg::new("out")
        .long("output")
        .required(true)
        .action(ArgAction::Set)
        .default_value("-"))
    .arg(Arg::new("cfg")
        .short('c')
        .action(ArgAction::Set))
    .get_matches(); // builds the instance of ArgMatches

if let Some(c) = matches.get_one::<String>("cfg") {
    println!("Value for -c: {c}");
}
println!("Value for --output: {}", matches.get_one::<String>("out").unwrap());

// You can check the presence of an argument's values
if matches.contains_id("out") {
    // However, if you want to know where the value came from
    if matches.value_source("out").expect("checked contains_id") == ValueSource::CommandLine {
        println!("`out` set by user");
    } else {
        println!("`out` is defaulted");
    }
}


 let app_m = Command::new("git")
     .subcommand(Command::new("clone"))
     .subcommand(Command::new("push"))
     .subcommand(Command::new("commit"))
     .get_matches();
 
match app_m.subcommand() {
    Some(("clone",  sub_m)) => {}, // clone was used
    Some(("push",   sub_m)) => {}, // push was used
    Some(("commit", sub_m)) => {}, // commit was used
    _                       => {}, // Either no subcommand or one not tested for...
}

// 使用 arg!() 来创建 Arg：

// [name]: 位置参数 name，name 作为 arg id，外围的 [] 表示是可选的。
let input = arg!([name] "Optional name to operate on").required(false)
    
// -i：short flag
// --input： long flag，同时 input 作为 arg id
// <FILE>: value_name，在显示参数的 help 信息时使用
// "Provides an input file to the program": 帮助信息
let input = arg!(-i --input <FILE> "Provides an input file to the program");

let matches = command!()
    // 位置参数，id 为 name
    .arg(arg!([name] "Optional name to operate on").required(false))
    // flag 参数，id 为 list
    .arg(arg!(-l --list "lists test values").action(ArgAction::SetTrue))

// 对 args!() 创建的 Arg 对象，进一步调用 value_parser!() 等方法
let matches = command!()
    .arg(
        arg!([PORT])
            .value_parser(value_parser!(u16)) // Rust 内置类型
            .default_value("2020"),
    )
    .get_matches();


// 使用 Arg::new("arg_id") 函数来创建 Arg
let cmd = Command::new().arg(
    Arg::new("in_file") // 未调用 short 或 long 方法，所以为位置参数
)

let cfg = Arg::new("config") // 未调用 short 或 long 方法，所以为位置参数
    .action(ArgAction::Set)
    .value_name("FILE")
    .value_parser(2..5); // RangeFull 实现了 ValueParser

let cfg = Arg::new("config")
    .short('c') // flag 类型参数
    .long("config")
    .action(ArgAction::Set) // 设置参数值的动作, 默认为 ArgAction::Set
    .value_name("FILE") // 在显示参数的帮助信息时使用
    .help("Provides a config file to myprog");

// 更复杂的例子
use clap::{arg, command, ArgAction};

fn main() {
    let matches = command!().next_line_help(true)
        // 未指定 ValueParser 时默认为 StringValueParser
        .arg(arg!(--two <VALUE>).required(true).action(ArgAction::Set))
        .arg(arg!(--one <VALUE>).required(true).action(ArgAction::Set))
        .get_matches();

    println!( "two: {:?}", matches.get_one::<String>("two").expect("required") );
    println!( "one: {:?}", matches.get_one::<String>("one").expect("required") );
}

let mut cmd = clap::Command::new("raw")
    .arg(
        clap::Arg::new("output")
            .value_parser(clap::value_parser!(PathBuf))
            .required(true)
    );

let cfg = Arg::new("config") 
        .action(ArgAction::Set)
        .value_name("FILE")
        // RangeFull 实现了 ValueParser
        .value_parser(2..5); 

let mut cmd = clap::Command::new("raw")
    .arg(
        clap::Arg::new("color")
            .long("color")
            // [&str; 3] 实现了 ValueParser
            .value_parser(["always", "auto", "never"])
            .default_value("auto")
    );

let cfg = Arg::new("config")
    .action(ArgAction::Set)
    .value_name("FILE")
    // [PossibleValue; 3] 实现了 ValueParser
    .value_parser([
        PossibleValue::new("fast"),
        PossibleValue::new("slow").help("slower than fast"),
        PossibleValue::new("secret speed").hide(true)
    ]);

/// Doc comment
#[derive(Parser)]
#[command(CMD ATTRIBUTE)]
#[group(GROUP ATTRIBUTE)]
struct Cli {
    /// Doc comment
    #[arg(ARG ATTRIBUTE)]
    field: UserType,

    #[arg(value_enum, ARG ATTRIBUTE...)]
    field: EnumValues,
}

/// Doc comment
#[derive(ValueEnum)]
#[value(VALUE ENUM ATTRIBUTE)]
enum EnumValues {
    /// Doc comment
    #[value(POSSIBLE VALUE ATTRIBUTE)]
    Variant1,
}

// builder 风格
let cmd = Command::new("mycmd")
    .arg(
        Arg::new("flag")
            .long("flag") // 调用 short/long 方法后则设置为 flag 参数
            .action(clap::ArgAction::Append) // 默认 action 为 ArgAction::Set，Vec 需要设置为 ArgAction::Append
    );

let matches = cmd.try_get_matches_from(["mycmd", "--flag", "value", "--flag" "value2"]).unwrap();
assert!(matches.contains_id("flag"));
assert_eq!(
    // 需要使用 get_many() 方法来获得 Vec
    matches.get_many::<String>("flag").unwrap_or_default().map(|v| v.as_str()).collect::<Vec<_>>(),  vec!["value", "value2"]
);

// num_args 指定参数值的个数，这里表示 -F 有两个参数值，如 -F in-file out-file
let cmd = Command::new("prog")
    .arg(Arg::new("file")
        .action(ArgAction::Set) // 默认为 Set 类型
        .num_args(2) // 2 个参数值，也可以指定 Range，如 2.. 表示至少 2 个位置参数
        .short('F'));

let m = cmd.clone().get_matches_from(vec!["prog", "-F", "in-file", "out-file"]);
assert_eq!(
    // 需要使用 get_many() 方法来获得 Vec
    m.get_many::<String>("file").unwrap_or_default().map(|v| v.as_str()).collect::<Vec<_>>(),  vec!["in-file", "out-file"]
);
// 只指定一个参数值时报错
let res = cmd.clone().try_get_matches_from(vec!["prog", "-F", "file1"]);
assert_eq!(res.unwrap_err().kind(), ErrorKind::WrongNumberOfValues);

// derive 风格：
#[derive(Parser, Debug)]
struct RemoveArgs {
    // flag 参数
    #[arg(short, long)]
    force: bool,

    // 未加 #[arg]，所以为位置参数。
    // name 是可选的位置参数，未指定时为空 Vec，多个值会收集到 Vec 中。
    name: Vec<String>,
    
    #[clap(value_parser = bytes_from_str)]
    name2: String 
}

let mut cmd = clap::Command::new("raw")
    .arg(
        clap::Arg::new("append")
            .value_parser(clap::builder::FalseyValueParser::new())
            .required(false)
    );

// 使用 Fn 闭包来实现 TypedValueParser:
// Result 的 Ok 值类型需要和 arg 字段类型值 T/Option<T>/Vec<T>/Option<Vec<T>> 中的 T 一致。
fn bytes_from_str(src: &str) -> Result<Bytes, Infallible> {
    Ok(Bytes::from(src.to_string()))
}

#[derive(Subcommand, Debug)]
enum Command {
    Ping {
        // 手动指定实现 TypedValueParser 的类型。
        #[clap(value_parser = bytes_from_str)]
        msg: Option<Bytes>,
    }
}

let m = Command::new("prog")
    .arg(Arg::new("verb")
        .long("verbose")
        .short('v')
        .action(ArgAction::SetTrue)
        .global(true))
    .subcommand(Command::new("test"))
    .subcommand(Command::new("do-stuff"))
    .get_matches_from(vec![
        "prog", "do-stuff", "--verbose"
    ]);

assert_eq!(m.subcommand_name(), Some("do-stuff"));
let sub_m = m.subcommand_matches("do-stuff").unwrap();
assert_eq!(sub_m.get_flag("verb"), true);

use std::collections::BTreeMap;

use clap::{command, value_parser, Arg, ArgAction, ArgGroup, ArgMatches, Command};

fn main() {
    let matches = cli().get_matches();
    let values = Value::from_matches(&matches);
    println!("{values:#?}");
}

fn cli() -> Command {
    command!()
        .group(ArgGroup::new("tests").multiple(true))
        .next_help_heading("TESTS")
        .args([
            position_sensitive_flag(Arg::new("empty"))
                .long("empty")
                .action(ArgAction::Append)
                .help("File is empty and is either a regular file or a directory")
                .group("tests"),
            
            Arg::new("name")
                .long("name")
                .action(ArgAction::Append)
                .help("Base of file name (the path with the leading directories removed) matches shell pattern pattern")
                .group("tests")
        ])
        
        .group(ArgGroup::new("operators").multiple(true))
        .next_help_heading("OPERATORS")
        .args([
            position_sensitive_flag(Arg::new("or"))
                .short('o')
                .long("or")
                .action(ArgAction::Append)
                .help("expr2 is not evaluate if exp1 is true")
                .group("operators"),
            
            position_sensitive_flag(Arg::new("and"))
                .short('a')
                .long("and")
                .action(ArgAction::Append)
                .help("Same as `expr1 expr1`")
                .group("operators"),
        ])
}

fn position_sensitive_flag(arg: Arg) -> Arg {
    // Flags don't track the position of each occurrence, so we need to emulate flags with value-less options to get the same result
    arg.num_args(0)
        .value_parser(value_parser!(bool))
        .default_missing_value("true")
        .default_value("false")
}

#[derive(Clone, PartialEq, Eq, Hash, Debug)]
pub enum Value {
    Bool(bool),
    String(String),
}

impl Value {
    pub fn from_matches(matches: &ArgMatches) -> Vec<(clap::Id, Self)> {
        
        let mut values = BTreeMap::new();
        
        for id in matches.ids() {
            if matches.try_get_many::<clap::Id>(id.as_str()).is_ok() {
                // ignore groups
                continue;
            }
            let value_source = matches .value_source(id.as_str()) .expect("id came from matches");
            if value_source != clap::parser::ValueSource::CommandLine {
                // Any other source just gets tacked on at the end (like default values)
                continue;
            }
            if Self::extract::<String>(matches, id, &mut values) {
                continue;
            }
            if Self::extract::<bool>(matches, id, &mut values) {
                continue;
            }
            unimplemented!("unknown type for {id}: {matches:?}");
        }
        
        values.into_values().collect::<Vec<_>>()
    }

    fn extract<T: Clone + Into<Value> + Send + Sync + 'static>(
        matches: &ArgMatches,
        id: &clap::Id,
        output: &mut BTreeMap<usize, (clap::Id, Self)>,
    ) -> bool {
        
        match matches.try_get_many::<T>(id.as_str()) {
            Ok(Some(values)) => {
                for (value, index) in values.zip(matches.indices_of(id.as_str()).expect("id came from matches"),) {
                    output.insert(index, (id.clone(), value.clone().into()));
                }
                true
            }
            Ok(None) => {unreachable!("`ids` only reports what is present")}
            Err(clap::parser::MatchesError::UnknownArgument { .. }) => {unreachable!("id came from matches")}
            Err(clap::parser::MatchesError::Downcast { .. }) => false,
            Err(_) => {unreachable!("id came from matches")}
        }
    }
}

impl From<String> for Value {
    fn from(other: String) -> Self {
        Self::String(other)
    }
}

impl From<bool> for Value {
    fn from(other: bool) -> Self {
        Self::Bool(other)
    }
}

// $ find --help
// A simple to use, efficient, and full-featured Command Line Argument Parser

// Usage: find[EXE] [OPTIONS]

// Options:
//   -h, --help     Print help
//   -V, --version  Print version

// TESTS:
//       --empty        File is empty and is either a regular file or a directory
//       --name <name>  Base of file name (the path with the leading directories removed) matches shell
//                      pattern pattern

// OPERATORS:
//   -o, --or   expr2 is not evaluate if exp1 is true
//   -a, --and  Same as `expr1 expr1`