#![allow(dead_code)]

use derive_builder::Builder;
use std::collections::HashMap;
use std::io::{stdout, Write};

pub enum ValueRequirement {
    None,
    Required(&'static str),
    Optional(&'static str),
}

#[derive(Builder)]
#[builder(pattern = "owned")]
pub struct Option {
    #[builder(setter(into), default = "'\\0'")]
    short: char,
    long: &'static str,
    #[builder(setter(into), default = "\"\"")]
    description: &'static str,
    #[builder(setter(name = "value"), default = "ValueRequirement::None")]
    value_req: ValueRequirement,
    #[builder(setter(skip))]
    is_set: bool,
    #[builder(setter(skip))]
    value: std::option::Option<String>,
}

pub struct Options {
    options: Vec<Option>,
    short: HashMap<char, usize>,
    long: HashMap<&'static str, usize>,
}

impl Option {
    pub fn short(&self) -> char {
        self.short
    }

    pub fn long(&self) -> &'static str {
        self.long
    }

    pub fn description(&self) -> &'static str {
        self.description
    }

    pub fn is_set(&self) -> bool {
        self.is_set
    }

    pub fn value(&self) -> &std::option::Option<String> {
        &self.value
    }

    fn set(&mut self, value: std::option::Option<String>) {
        self.is_set = true;
        self.value = value;
    }
}

impl Options {
    pub fn new() -> Self {
        Options {
            options: Vec::new(),
            short: HashMap::new(),
            long: HashMap::new(),
        }
    }

    pub fn push(&mut self, option: Option) -> usize {
        let index = self.options.len();
        if option.short != '\0' {
            self.short.insert(option.short, index);
        }
        if option.long != "" {
            self.long.insert(option.long, index);
        }
        self.options.push(option);
        index
    }
}

impl std::ops::Index<usize> for Options {
    type Output = Option;

    fn index(&self, index: usize) -> &Self::Output {
        self.options.index(index)
    }
}

pub struct Arguments {
    pub program: std::option::Option<String>,
    pub args: Vec<String>,
}

pub trait Parser {
    fn run(
        &self,
        options: &mut Options,
        args: &mut dyn Iterator<Item = String>,
    ) -> Result<Arguments, String>;

    fn print_help(&self, options: &Options) {
        let lock = std::sync::Mutex::new(stdout().lock());
        self.print_help_fn(options, &|a| {
            writeln!(lock.lock().unwrap(), "{}", a).unwrap();
        });
    }

    fn print_help_fn(&self, options: &Options, println: &dyn Fn(String));
}

#[allow(dead_code)]
pub struct LongOnlyParser {}

#[allow(dead_code)]
pub struct ShortAndLongParser {}

fn print_list(list: Vec<(String, &str)>, println: &dyn Fn(String)) {
    let mut left_len: usize = 0;
    for (left, _) in &list {
        left_len = std::cmp::max(left_len, left.len());
    }
    for (left, right) in &list {
        let mut right_lines = right.split('\n');
        println(format!(
            "{left:<left_len$}  {}",
            right_lines.next().unwrap()
        ));
        for right_line in right_lines {
            println(format!("{:<left_len$}  {right_line}", ""));
        }
    }
}

#[allow(dead_code)]
impl LongOnlyParser {
    pub fn new() -> LongOnlyParser {
        LongOnlyParser {}
    }
}

impl Parser for LongOnlyParser {
    fn run(
        &self,
        options: &mut Options,
        args: &mut dyn Iterator<Item = String>,
    ) -> Result<Arguments, String> {
        let mut ret = Vec::new();
        let program = args.next();
        while let Some(arg) = args.next() {
            if arg.len() >= 2 && arg.starts_with("-") {
                if arg == "--" {
                    // All following arguments are just that.
                    while let Some(arg) = args.next() {
                        ret.push(arg)
                    }
                    break;
                }
                let start = 1;
                let name;
                let mut value;
                if let Some(end) = arg.find('=') {
                    name = arg.get(start..end).unwrap();
                    value = Some(arg.get(end + 1..).unwrap().to_string());
                } else {
                    name = arg.get(start..).unwrap();
                    value = None;
                }
                if let Some(index) = options.long.get(name) {
                    let ref mut option = options.options[*index];
                    match option.value_req {
                        ValueRequirement::None => {
                            if value.is_some() {
                                return Err(format!("option '-{name}' doesn't allow an argument"));
                            }
                        }
                        ValueRequirement::Required(_) => {
                            if value.is_none() {
                                value = args.next();
                                if value.is_none() {
                                    return Err(format!("option '{}' requires an argument", arg));
                                }
                            }
                        }
                        ValueRequirement::Optional(_) => {}
                    }
                    option.set(value);
                } else {
                    return Err(format!("unrecognized option '{}'", arg));
                }
            } else {
                ret.push(arg)
            }
        }
        Ok(Arguments { program, args: ret })
    }

    fn print_help_fn(&self, options: &Options, println: &dyn Fn(String)) {
        let mut lines = Vec::new();
        for option in &options.options {
            let left = match option.value_req {
                ValueRequirement::None => format!("-{}", option.long()),
                ValueRequirement::Required(name) => format!("-{}={}", option.long(), name),
                ValueRequirement::Optional(name) => format!("-{}[={}]", option.long(), name),
            };
            lines.push((left, option.description()));
        }
        print_list(lines, println);
    }
}

#[allow(dead_code)]
impl ShortAndLongParser {
    pub fn new() -> ShortAndLongParser {
        ShortAndLongParser {}
    }
}

impl Parser for ShortAndLongParser {
    fn run(
        &self,
        options: &mut Options,
        args: &mut dyn Iterator<Item = String>,
    ) -> Result<Arguments, String> {
        let mut ret = Vec::new();
        let program = args.next();
        while let Some(arg) = args.next() {
            if arg.starts_with("--") {
                if arg.len() == 2 {
                    // All following arguments are just that.
                    while let Some(arg) = args.next() {
                        ret.push(arg)
                    }
                    break;
                }
                let start = 2;
                let name;
                let mut value;
                if let Some(end) = arg.find('=') {
                    name = arg.get(start..end).unwrap();
                    value = Some(arg.get(end + 1..).unwrap().to_string());
                } else {
                    name = arg.get(start..).unwrap();
                    value = None;
                }
                if let Some(index) = options.long.get(name) {
                    let ref mut option = options.options[*index];
                    match option.value_req {
                        ValueRequirement::None => {
                            if value.is_some() {
                                return Err(format!(
                                    "option '--{}' doesn't allow an argument",
                                    name
                                ));
                            }
                        }
                        ValueRequirement::Required(_) => {
                            if value.is_none() {
                                value = args.next();
                                if value.is_none() {
                                    return Err(format!("option '{}' requires an argument", arg));
                                }
                            }
                        }
                        ValueRequirement::Optional(_) => {}
                    }
                    option.set(value);
                } else {
                    return Err(format!("unrecognized option '{}'", arg));
                }
            } else if arg.starts_with("-") && arg.len() > 1 {
                for c in arg.get(1..).unwrap().chars() {
                    if let Some(index) = options.short.get(&c) {
                        let ref mut option = options.options[*index];
                        let mut value = None;
                        match option.value_req {
                            ValueRequirement::None => {}
                            ValueRequirement::Required(_) => {
                                value = args.next();
                                if value.is_none() {
                                    return Err(format!("option requires an argument -- '{}'", c));
                                }
                            }
                            ValueRequirement::Optional(_) => {}
                        }
                        option.set(value);
                    } else {
                        return Err(format!("invalid option -- '{}'", c));
                    }
                }
            } else {
                ret.push(arg)
            }
        }
        Ok(Arguments { program, args: ret })
    }

    fn print_help_fn(&self, options: &Options, println: &dyn Fn(String)) {
        let mut lines = Vec::new();
        for option in &options.options {
            let left: String;
            if option.short() == '\0' {
                left = match option.value_req {
                    ValueRequirement::None => format!("    --{}", option.long()),
                    ValueRequirement::Required(name) => format!("    --{}={}", option.long(), name),
                    ValueRequirement::Optional(name) => {
                        format!("    --{}[={}]", option.long(), name)
                    }
                };
            } else if option.long() == "" {
                left = match option.value_req {
                    ValueRequirement::None => format!("-{}", option.short()),
                    ValueRequirement::Required(name) => format!("-{}={}", option.short(), name),
                    ValueRequirement::Optional(name) => format!("-{}[={}]", option.short(), name),
                };
            } else {
                left = match option.value_req {
                    ValueRequirement::None => format!("-{}, --{}", option.short(), option.long()),
                    ValueRequirement::Required(name) => {
                        format!("-{}, --{}={}", option.short(), option.long(), name)
                    }
                    ValueRequirement::Optional(name) => {
                        format!("-{}, --{}[={}]", option.short(), option.long(), name)
                    }
                };
            }
            lines.push((left, option.description()));
        }
        print_list(lines, println);
    }
}

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

    struct Params {
        options: Options,

        no_value_idx: usize,
        opt_value_idx: usize,
        value_idx: usize,

        long_no_value_idx: usize,
        long_opt_value_idx: usize,
        long_value_idx: usize,
    }

    fn params_new() -> Params {
        let mut options = Options::new();
        let no_value_idx = options.push(
            OptionBuilder::default()
                .short('V')
                .long("version")
                .description("display version and exit")
                .build()
                .unwrap(),
        );
        let opt_value_idx = options.push(
            OptionBuilder::default()
                .short('s')
                .long("sort")
                .description("sort by optional key")
                .value(ValueRequirement::Optional("key"))
                .build()
                .unwrap(),
        );
        let value_idx = options.push(
            OptionBuilder::default()
                .short('I')
                .long("input")
                .description("input FILE")
                .value(ValueRequirement::Required("FILE"))
                .build()
                .unwrap(),
        );
        let long_no_value_idx = options.push(
            OptionBuilder::default()
                .long("full-time")
                .description("like -l -time-style=full-iso")
                .value(ValueRequirement::None)
                .build()
                .unwrap(),
        );
        let long_opt_value_idx = options.push(
            OptionBuilder::default()
                .long("hyperlink")
                .description("hyperlink file names WHEN")
                .value(ValueRequirement::Optional("WHEN"))
                .build()
                .unwrap(),
        );
        let long_value_idx = options.push(
            OptionBuilder::default()
                .long("indicator-style")
                .description(
                    "append indicator with style WORD to entry names:
none (default), slash (-p),
file-type (--file-type), classify (-F)",
                )
                .value(ValueRequirement::Required("WORD"))
                .build()
                .unwrap(),
        );
        return Params {
            options,
            no_value_idx,
            opt_value_idx,
            value_idx,
            long_no_value_idx,
            long_opt_value_idx,
            long_value_idx,
        };
    }

    fn assert_empty(parser: &Box<dyn Parser>) {
        let mut params = params_new();
        let args = parser
            .run(&mut params.options, &mut [].iter().cloned())
            .unwrap();
        assert_eq!(args.program, None);
        assert_eq!(args.args.len(), 0);
    }

    fn assert_program(parser: &Box<dyn Parser>) {
        let mut params = params_new();
        let args = parser
            .run(
                &mut params.options,
                &mut ["test".to_string()].iter().cloned(),
            )
            .unwrap();
        assert_eq!(args.program, Some("test".to_string()));
        assert_eq!(args.args.len(), 0);
    }

    fn assert_program_arg(parser: &Box<dyn Parser>) {
        let mut params = params_new();
        let args = parser
            .run(
                &mut params.options,
                &mut ["test", "file"].map(|s| s.to_string()).iter().cloned(),
            )
            .unwrap();
        assert_eq!(args.program, Some("test".to_string()));
        assert_eq!(args.args, vec!["file".to_string()]);
    }

    fn assert_options1(parser: &Box<dyn Parser>, input: Vec<&str>) {
        let mut params = params_new();
        let args = parser
            .run(
                &mut params.options,
                &mut input.iter().map(|s| s.to_string()),
            )
            .unwrap();
        assert_eq!(args.program, Some("test".to_string()));
        assert_eq!(params.options[params.no_value_idx].is_set(), true);
        assert_eq!(params.options[params.opt_value_idx].is_set(), true);
        assert_eq!(params.options[params.opt_value_idx].value, None);
        assert_eq!(params.options[params.value_idx].is_set(), true);
        assert_eq!(
            params.options[params.value_idx].value,
            Some("foo".to_string())
        );
        assert_eq!(args.args, vec!["arg".to_string()]);
    }

    fn assert_options2(parser: &Box<dyn Parser>, input: Vec<&str>) {
        let mut params = params_new();
        let args = parser
            .run(
                &mut params.options,
                &mut input.iter().map(|s| s.to_string()),
            )
            .unwrap();
        assert_eq!(args.program, Some("test".to_string()));
        assert_eq!(params.options[params.long_no_value_idx].is_set(), true);
        assert_eq!(params.options[params.long_opt_value_idx].is_set(), true);
        assert_eq!(
            params.options[params.long_opt_value_idx].value,
            Some("foo".to_string())
        );
        assert_eq!(params.options[params.long_value_idx].is_set(), true);
        assert_eq!(
            params.options[params.long_value_idx].value,
            Some("bar".to_string())
        );
        assert_eq!(args.args, vec!["arg".to_string()]);
    }

    fn assert_args_with_dash(parser: &Box<dyn Parser>, input: Vec<&str>) {
        let mut params = params_new();
        let args = parser
            .run(
                &mut params.options,
                &mut input.iter().map(|s| s.to_string()),
            )
            .unwrap();
        assert_eq!(args.program, Some("test".to_string()));
        assert_eq!(
            params.options[params.value_idx].value,
            Some("-foo".to_string())
        );
        assert_eq!(
            args.args,
            vec![
                "-".to_string(),
                "-sort".to_string(),
                "-full-time".to_string(),
            ]
        );
    }

    fn assert_error(parser: &Box<dyn Parser>, input: Vec<&str>, error: &str) {
        let mut params = params_new();
        let maybe_args = parser.run(
            &mut params.options,
            &mut input.iter().map(|s| s.to_string()),
        );
        assert_eq!(maybe_args.is_err(), true);
        unsafe {
            assert_eq!(maybe_args.unwrap_err_unchecked(), error);
        }
    }

    fn assert_help(parser: &Box<dyn Parser>, expected: &str) {
        let params = params_new();
        let out = std::sync::Mutex::new(String::new());
        parser.print_help_fn(&params.options, &|line| {
            let mut o = out.lock().unwrap();
            *o += &line;
            *o += "\n";
        });
        assert_eq!(*out.lock().unwrap(), expected);
    }

    #[test]
    fn empty_longonly() {
        let parser: Box<dyn Parser> = Box::new(LongOnlyParser::new());
        assert_empty(&parser);
    }

    #[test]
    fn empty_shortandlong() {
        let parser: Box<dyn Parser> = Box::new(ShortAndLongParser::new());
        assert_empty(&parser);
    }

    #[test]
    fn program_longonly() {
        let parser: Box<dyn Parser> = Box::new(LongOnlyParser::new());
        assert_program(&parser);
    }

    #[test]
    fn program_shortandlong() {
        let parser: Box<dyn Parser> = Box::new(ShortAndLongParser::new());
        assert_program(&parser);
    }

    #[test]
    fn program_arg_longonly() {
        let parser: Box<dyn Parser> = Box::new(LongOnlyParser::new());
        assert_program_arg(&parser);
    }

    #[test]
    fn program_arg_shortandlong() {
        let parser: Box<dyn Parser> = Box::new(ShortAndLongParser::new());
        assert_program_arg(&parser);
    }

    #[test]
    fn options1_longonly() {
        let parser: Box<dyn Parser> = Box::new(LongOnlyParser::new());
        assert_options1(
            &parser,
            vec!["test", "-version", "-sort", "-input=foo", "arg"],
        );
        assert_options1(
            &parser,
            vec!["test", "-version", "-sort", "-input", "foo", "arg"],
        );
    }

    #[test]
    fn options1_shortandlong() {
        let parser: Box<dyn Parser> = Box::new(ShortAndLongParser::new());
        assert_options1(
            &parser,
            vec!["test", "--version", "--sort", "--input=foo", "arg"],
        );
        assert_options1(
            &parser,
            vec!["test", "--version", "--sort", "--input", "foo", "arg"],
        );
        assert_options1(&parser, vec!["test", "-V", "-s", "-I", "foo", "arg"]);
        assert_options1(&parser, vec!["test", "-VsI", "foo", "arg"]);
    }

    #[test]
    fn options2_longonly() {
        let parser: Box<dyn Parser> = Box::new(LongOnlyParser::new());
        assert_options2(
            &parser,
            vec![
                "test",
                "-full-time",
                "-hyperlink=foo",
                "-indicator-style=bar",
                "arg",
            ],
        );
        assert_options2(
            &parser,
            vec![
                "test",
                "-full-time",
                "-hyperlink=foo",
                "-indicator-style",
                "bar",
                "arg",
            ],
        );
    }

    #[test]
    fn options2_shortandlong() {
        let parser: Box<dyn Parser> = Box::new(ShortAndLongParser::new());
        assert_options2(
            &parser,
            vec![
                "test",
                "--full-time",
                "--hyperlink=foo",
                "--indicator-style=bar",
                "arg",
            ],
        );
        assert_options2(
            &parser,
            vec![
                "test",
                "--full-time",
                "--hyperlink=foo",
                "--indicator-style",
                "bar",
                "arg",
            ],
        );
    }

    #[test]
    fn args_with_dash_longonly() {
        let parser: Box<dyn Parser> = Box::new(LongOnlyParser::new());
        assert_args_with_dash(
            &parser,
            vec!["test", "-", "-input", "-foo", "--", "-sort", "-full-time"],
        );
    }

    #[test]
    fn args_with_dash_shortandlong() {
        let parser: Box<dyn Parser> = Box::new(ShortAndLongParser::new());
        assert_args_with_dash(
            &parser,
            vec!["test", "-", "--input", "-foo", "--", "-sort", "-full-time"],
        );
    }

    #[test]
    fn bad_option_longonly() {
        let parser: Box<dyn Parser> = Box::new(LongOnlyParser::new());
        assert_error(
            &parser,
            vec!["test", "-unknown"],
            "unrecognized option '-unknown'",
        );
    }

    #[test]
    fn bad_option_shortandlong() {
        let parser: Box<dyn Parser> = Box::new(ShortAndLongParser::new());
        assert_error(
            &parser,
            vec!["test", "--unknown"],
            "unrecognized option '--unknown'",
        );
        assert_error(&parser, vec!["test", "-U"], "invalid option -- 'U'");
    }

    #[test]
    fn missing_arg_longonly() {
        let parser: Box<dyn Parser> = Box::new(LongOnlyParser::new());
        assert_error(
            &parser,
            vec!["test", "-input"],
            "option '-input' requires an argument",
        );
    }

    #[test]
    fn missing_arg_shortandlong() {
        let parser: Box<dyn Parser> = Box::new(ShortAndLongParser::new());
        assert_error(
            &parser,
            vec!["test", "--input"],
            "option '--input' requires an argument",
        );
        assert_error(
            &parser,
            vec!["test", "-I"],
            "option requires an argument -- 'I'",
        );
    }

    #[test]
    fn unexpected_arg_longonly() {
        let parser: Box<dyn Parser> = Box::new(LongOnlyParser::new());
        assert_error(
            &parser,
            vec!["test", "-version=foo"],
            "option '-version' doesn't allow an argument",
        );
    }

    #[test]
    fn unexpected_arg_shortandlong() {
        let parser: Box<dyn Parser> = Box::new(ShortAndLongParser::new());
        assert_error(
            &parser,
            vec!["test", "--version=foo"],
            "option '--version' doesn't allow an argument",
        );
    }

    #[test]
    fn help_longonly() {
        let parser: Box<dyn Parser> = Box::new(LongOnlyParser::new());
        assert_help(
            &parser,
            "-version               display version and exit
-sort[=key]            sort by optional key
-input=FILE            input FILE
-full-time             like -l -time-style=full-iso
-hyperlink[=WHEN]      hyperlink file names WHEN
-indicator-style=WORD  append indicator with style WORD to entry names:
                       none (default), slash (-p),
                       file-type (--file-type), classify (-F)
",
        );
    }

    #[test]
    fn help_shortandlong() {
        let parser: Box<dyn Parser> = Box::new(ShortAndLongParser::new());
        assert_help(
            &parser,
            "-V, --version               display version and exit
-s, --sort[=key]            sort by optional key
-I, --input=FILE            input FILE
    --full-time             like -l -time-style=full-iso
    --hyperlink[=WHEN]      hyperlink file names WHEN
    --indicator-style=WORD  append indicator with style WORD to entry names:
                            none (default), slash (-p),
                            file-type (--file-type), classify (-F)
",
        );
    }
}