let matches = App::new("My Super Program")
        .version("1.0")
        .author("Kevin K. <[email protected]>")
        .about("Does awesome things")
        .arg(Arg::new("config")
            .short('c')
            .long("config")
            .value_name("FILE")
            .about("Sets a custom config file")
            .takes_value(true))
        .arg(Arg::new("INPUT")
            .about("Sets the input file to use")
            .required(true)
            .index(1))
        .arg(Arg::new("v")
            .short('v')
            .multiple_occurrences(true)
            .takes_value(true)
            .about("Sets the level of verbosity"))
        .subcommand(App::new("test")
            .about("controls testing features")
            .version("1.3")
            .author("Someone E. <[email protected]>")
            .arg(Arg::new("debug")
                .short('d')
                .about("print debug information verbosely")))
        .get_matches();
    // You can check the value provided by positional arguments, or option arguments
    if let Some(i) = matches.value_of("INPUT") {
        println!("Value for input: {}", i);
    }
    if let Some(c) = matches.value_of("config") {
        println!("Value for config: {}", c);
    }
    // You can see how many times a particular flag or argument occurred
    // Note, only flags can have multiple occurrences
    match matches.occurrences_of("v") {
        0 => println!("Verbose mode is off"),
        1 => println!("Verbose mode is kind of on"),
        2 => println!("Verbose mode is on"),
        _ => println!("Don't be crazy"),
    }
    // You can check for the existence of subcommands, and if found use their
    // matches just as you would the top level app
    if let Some(ref matches) = matches.subcommand_matches("test") {
        // "$ myapp test" was run
        if matches.is_present("debug") {
            // "$ myapp test -d" was run
            println!("Printing debug info...");
        } else {
            println!("Printing normally...");
        }
    }

// 顶层命令
// 包含了 root 属性和不同的 subcommand
#[derive(Clap, Debug)]
pub struct RepoSubcommand {
    #[clap(long, env = "ANNI_REPO")]
    root: PathBuf,
    #[clap(subcommand)]
    action: RepoAction,
}
// 第二层的 Subcommand
// 包含各个子命令的声明方式
#[derive(Clap, Debug)]
pub enum RepoAction {
    Add(RepoAddAction),
    Edit(RepoEditAction),
    Apply(RepoApplyAction),
    Validate(RepoValidateAction),
    Print(RepoPrintAction),
}
// 第三层的命令
// 实际执行的操作
#[derive(Clap, Debug)]
pub struct RepoAddAction {
    #[clap(short = 'e', long)]
    open_editor: bool,
    #[clap(required = true)]
    directories: Vec<PathBuf>,
}

#[derive(Clap)]
struct SimpleCommand {
    #[clap(subcommand)]
    subcommand: SimpleSubcommand;
}
#[clap(Clap)]
enum SimpleSubcommand {
    A(SubcommandA),
    B(SubcommandB),
}
#[clap(Clap)]
struct SubcommandA {
    #[clap(short, long)]
    arg1: String,
}
#[clap(Clap)]
struct SubcommandB {
    #[clap(short, long)]
    arg2: String,
}

pub trait Handle {
    fn handle(&self) -> anyhow::Result<()>;
}
#[proc_macro_derive(ClapHandler)]
pub fn derive_clap_handler(item: TokenStream) -> TokenStream {
    let input = parse_macro_input!(item as DeriveInput);
    let name = &input.ident;
    let expanded = match input.data {
        Data::Struct(DataStruct { ref fields, .. }) => {
            match fields {
                Fields::Named(ref fields_name) => {
                    // find struct field which has #[clap(subcommand)]
                    let subcommand_field: Option<syn::Ident> = fields_name
                        .named
                        .iter()
                        .find_map(|field| {
                            for attr in field.attrs.iter() {
                                if attr.path.is_ident("clap") {
                                    let ident: syn::Ident = attr.parse_args().ok()?;
                                    if ident == "subcommand" {
                                        return Some(field.ident.clone().unwrap());
                                    }
                                }
                            }
                            None
                        })
                        .expect("Failed to find #[clap(subcommand)] in struct!");
                    quote! {
                        impl Handle for #name {
                            fn handle(&self) -> anyhow::Result<()> {
                                self.#subcommand_field.handle()
                            }
                        }
                    }
                }
                _ => panic!("ClapHandler is not implemented for unnamed or None struct"),
            }
        }
        Data::Enum(DataEnum { variants, .. }) => {
            // list enum variants
            let subcommands: Vec<_> = variants
                .iter()
                .map(|v| {
                    let ident = &v.ident;
                    quote! { #name::#ident }
                })
                .collect();
            quote! {
                impl Handler for #name {
                    #[inline(always)]
                    fn handle(&self) -> anyhow::Result<()> {
                        match self {
                            #(#subcommands(s) => s.handle(),)*
                        }
                    }
                }
            }
        }
        _ => panic!("ClapHandler is not implemented for union type"),
    };
    expanded.into()
}