1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use std::{error::Error};
use clap::{Parser, Arg, Command};
use inquire::{Text, Confirm, Select};

pub trait InteractiveParse
where Self: Sized
{
    fn interactive_parse() -> Result<Self, Box<dyn Error>>;
}

fn parse_required_arg(arg: &Arg) -> Result<Vec<String>, Box<dyn Error>> {
    let mut output_args = vec![];
    let id = arg.get_id();
    match arg.is_positional() {
        // Arg is positional
        true => { },
        // Arg uses flag
        false => { output_args.push(format!("--{}", id)); },
    }
    let string = Text::new(arg.get_id().as_str()).prompt()?;
    output_args.push(string);
    Ok(output_args)
}

fn parse_optional_arg(arg: &Arg) -> Result<Vec<String>, Box<dyn Error>> {
    match Confirm::new("Add optional value?")
    .with_help_message(arg.get_id().as_str())
    .prompt()? 
    {
        true => { parse_required_arg(arg) },
        false => Ok(vec![]),
    }
}

fn parse_vec_arg(arg: &Arg) -> Result<Vec<String>, Box<dyn Error>> {
    let mut new_args = parse_optional_arg(arg)?;
    let mut total_args = vec![];
    while new_args.len() != 0 {
        total_args.extend(new_args);
        new_args = parse_optional_arg(arg)?;
    }
    if let Some(value_delimiter) = arg.get_value_delimiter() {
        total_args.join(value_delimiter.to_string().as_str());
    }
    Ok(total_args)
}

fn parse_arg(arg: &Arg) -> Result<Vec<String>, Box<dyn Error>> {
    match arg.get_num_args() {
        // arg is a vec
        Some(_) => {
            parse_vec_arg(arg)
        },
        None => {
            match arg.is_required_set() {
                true => parse_required_arg(arg),
                false => parse_optional_arg(arg),
            }
        },
    }

}

fn get_args<'a>(command: impl Iterator<Item = &'a Arg>) -> Result<Vec<String>, Box<dyn Error>> {
    let mut arg_list = vec![];
    for arg in command {
        arg_list.extend(parse_arg(arg)?);
    }
    Ok(arg_list)
}

impl<T> InteractiveParse for T
where T: Parser {
    fn interactive_parse() -> Result<Self, Box<dyn Error>> {
        let base_command = T::command();
        let mut args = vec![base_command.get_name().to_string()];
        let mut command = &base_command;
        loop {
            args.extend(get_args(command.get_arguments())?);
            let subcommands: Vec<&Command> = command.get_subcommands().collect();
            if subcommands.len() == 0 { break; }
            command = Select::new(command.get_name(), subcommands).prompt()?;
            args.push(command.get_name().to_string());
        }
        Ok(T::parse_from(args))
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[derive(Parser, Debug)]
    #[command(author, version, about, long_about = None)]
    struct Git {
        #[command(subcommand)]
        subcommand: SubCommand,

        #[arg(required=false)]
        my_arg: Option<String>
    }

    #[derive(Parser, Debug)]
    #[clap(rename_all = "snake_case", infer_subcommands=true)]
    enum SubCommand {
        Commit {
            #[arg(required=false)]
            message: Option<String>
        },
        Clone {
            address: Vec<String>
        },
        Merge {
            #[arg(value_delimiter=',')]
            address: Vec<String>
        }
    }

    #[ignore]
    #[test]
    fn test() {
        let git = Git::interactive_parse().unwrap();
        println!("{:?}", git);   
    }
}