// std uses
use std::collections::BTreeMap;

/// Command represents an command parsed from the command-line
///
/// # Example
/// ```
/// extern crate clipars;
///
/// use clipars::Command;
/// use std::env;
///
/// let env_args = env::args().collect::<Vec<String>>();
/// let command = Command::from_string(
///     &env_args[..],
///     &["option1", "option2"],
/// );
/// ```
#[derive(Clone, Debug)]
pub struct Command<'a> {
    /// Command name
    command: &'a str,

    /// Map of parameters
    parameters: BTreeMap<&'a str, &'a str>,

    /// List of options
    options: Vec<&'a str>,

    /// List of String arguments
    arguments: Vec<&'a str>,
}

// Command implementation
impl<'a> Command<'a> {
    /// Get command name
    pub fn get_command(&self) -> &'a str {
        // return comand name
        self.command
    }

    /// Get all parameters
    pub fn get_parameters(&self) -> &BTreeMap<&'a str, &'a str> {
        // return map of parameters
        &self.parameters
    }

    /// Get specific parameter
    pub fn get_parameter(&self, name: &'a str) -> Option<&&'a str> {
        // return specific parameter
        self.parameters.get(name)
    }

    /// Get all options
    pub fn get_options(&self) -> &Vec<&'a str> {
        // return options list
        &self.options
    }

    /// Check if option provided
    pub fn is_option(&self, name: &'a str) -> bool {
        // return whether the option is provided
        self.options.contains(&name)
    }

    /// Get all arguments
    pub fn get_arguments(&self) -> &Vec<&'a str> {
        // return arguments list
        &self.arguments
    }

    /// Get argument at specific index
    pub fn get_argument(&self, index: usize) -> Option<&&'a str> {
        // return argument at specific index
        self.arguments.get(index)
    }

    /// Create a new Command from raw command line arguments without options
    /// Provide the arguments list as &[String]
    ///
    /// ```
    /// extern crate clipars;
    ///
    /// use clipars::Command;
    /// use std::env;
    ///
    /// let env_args = env::args().collect::<Vec<String>>();
    /// let command = Command::from_string(
    ///     &env_args[..],
    ///     &["option1", "option2"],
    /// );
    /// ```
    pub fn from_string(raw: &'a [String], filter_options: &[&str]) -> Self {
        Self::from(
            &raw.iter().map(|s| &**s).collect::<Vec<&'a str>>()[..],
            filter_options,
        )
    }

    /// Create a new Command from raw command line arguments without options
    /// Provide the arguments list as &[&str]
    ///
    /// ```
    /// extern crate clipars;
    ///
    /// use clipars::Command;
    /// use std::env;
    ///
    /// let command = Command::without_options(&["command", "--param=value"]);
    /// ```
    pub fn without_options(raw: &[&'a str]) -> Self {
        // return Command
        Self::from(raw, &[])
    }

    /// Create a new Command from raw command line arguments without a command name
    /// Provide the arguments list as &[&str]
    ///
    /// The command [./command --param1=value1 more args]
    /// without the command name is [--param1=value1 more args]
    ///
    /// ```
    /// extern crate clipars;
    ///
    /// use clipars::Command;
    /// use std::env;
    ///
    /// let command = Command::without_command(&["--param=value"], &["option"]);
    /// ```
    pub fn without_command(raw: &[&'a str], filter_options: &[&str]) -> Self {
        // add an empty String at the start
        let raw_with_command = [&[""], &raw[..]].concat();

        // return Command
        Self::from(&raw_with_command, filter_options)
    }

    /// Create a new Command from raw command line arguments without a command name and without options
    /// Provide the arguments list as &[&str]
    ///
    /// The command [./command --param1=value1 more args]
    /// without the command name is [--param1=value1 more args]
    ///
    /// ```
    /// extern crate clipars;
    ///
    /// use clipars::Command;
    /// use std::env;
    ///
    /// let command = Command::without_command_and_options(&["--param=value"]);
    /// ```
    pub fn without_command_and_options(raw: &[&'a str]) -> Self {
        // add an empty String at the start
        let raw_with_command = [&[""][..], &raw[..]].concat();

        // return Command
        Self::from(&raw_with_command, &[])
    }

    /// Create a new Command from raw command line arguments
    /// Provide the arguments list as &[&str]
    ///
    /// ```
    /// extern crate clipars;
    ///
    /// use clipars::Command;
    /// use std::env;
    ///
    /// let command = Command::from(&["command", "--param=value"], &["option"]);
    /// ```
    pub fn from(raw: &[&'a str], filter_options: &[&str]) -> Self {
        // define command name
        let command = match raw.get(0) {
            Some(command) => command,
            None => "",
        };

        // define variables
        let mut parameters: BTreeMap<&str, &str> = BTreeMap::new();
        let mut options: Vec<&str> = Vec::new();
        let mut arguments: Vec<&str> = Vec::new();

        // define iteration parameters
        let mut parameter = "";
        let mut is_parameter = false;

        // iterate through raw arguments
        for (index, argument) in raw.iter().enumerate() {
            // check if first argument (command name)
            if index == 0 {
                // skip
                continue;
            }

            // check if previous argument is a parameter
            if is_parameter {
                // insert parameter into map
                parameters.insert(parameter, argument);

                // empty parameter, compile safe
                parameter = "";

                // next on is not a parameter
                is_parameter = false;
            } else {
                // closure to process parameters using equal sign
                let process_split = |parameters: &mut BTreeMap<&'a str, &'a str>,
                                     parameter: &mut &'a str,
                                     is_parameter: &mut bool,
                                     argument: &'a str| {
                    // split argument
                    let splits = argument.splitn(2, '=');

                    // loop through one or two splitted parameters
                    for split in splits {
                        // check if second
                        if *is_parameter {
                            // insert parameter into map
                            parameters.insert(parameter, split);

                            // proceed with next argument
                            *is_parameter = false;
                        } else {
                            // store parameter name
                            *parameter = split;

                            // next on is a parameter
                            *is_parameter = true;
                        }
                    }
                };

                // check if argument is a parameter
                if argument.starts_with("--") {
                    // remove preceding characters
                    let cut = match argument.len() {
                        len if len >= 3 => &argument[2..],
                        _ => argument,
                    };

                    // check if option
                    if filter_options.contains(&cut) {
                        // add to options
                        options.push(cut);

                        // continue with next argument
                        continue;
                    }

                    // process parameter
                    process_split(&mut parameters, &mut parameter, &mut is_parameter, cut);
                // check if argument is a parameter
                } else if argument.starts_with('-') {
                    // remove preceding characters
                    let cut = match argument.len() {
                        len if len >= 2 => &argument[1..],
                        _ => argument,
                    };

                    // check if option
                    if filter_options.contains(&cut) {
                        // add to options
                        options.push(cut);

                        // continue with next argument
                        continue;
                    }

                    // process parameter
                    process_split(&mut parameters, &mut parameter, &mut is_parameter, cut);
                } else {
                    // add to arguments
                    arguments.push(argument);
                }
            }
        }

        // last parameter without value must be option
        if is_parameter {
            // add parameter to options
            options.push(parameter);
        }

        // return Command
        Self {
            command,
            parameters,
            options,
            arguments,
        }
    }
}

// Unit Tests
#[cfg(test)]
mod tests {
    mod mod_command {
        use crate::Command;

        // Test for Command::from_string
        #[test]
        fn from_string() {
            // define possible options
            let options = ["option1", "option2", "option3"];

            // initialize arguments list and add arguments
            let mut arguments = Vec::new();
            arguments.push("command".into());
            arguments.push("--param1=value1".into());
            arguments.push("--param2=value2".into());
            arguments.push("-short-param1=short-value1".into());
            arguments.push("--option1".into());
            arguments.push("-short-param2=short-value2".into());
            arguments.push("--option2".into());
            arguments.push("--param3".into());
            arguments.push("value3".into());
            arguments.push("--param4".into());
            arguments.push("value4".into());
            arguments.push("some".into());
            arguments.push("more".into());
            arguments.push("arguments".into());

            // parse command
            let command = Command::from_string(&arguments, &options);

            // check values
            assert_eq!(command.get_command(), "command");
            assert_eq!(*command.get_parameter("param1").unwrap(), "value1");
            assert_eq!(*command.get_parameter("param2").unwrap(), "value2");
            assert_eq!(*command.get_parameter("param3").unwrap(), "value3");
            assert_eq!(*command.get_parameter("param4").unwrap(), "value4");
            assert_eq!(
                *command.get_parameter("short-param1").unwrap(),
                "short-value1"
            );
            assert_eq!(
                *command.get_parameter("short-param2").unwrap(),
                "short-value2"
            );
            assert_eq!(command.is_option("option1"), true);
            assert_eq!(command.is_option("option2"), true);
            assert_eq!(command.is_option("option3"), false);
            assert_eq!(*command.get_argument(0).unwrap(), "some");
            assert_eq!(*command.get_argument(1).unwrap(), "more");
            assert_eq!(*command.get_argument(2).unwrap(), "arguments");

            // check lengths
            assert_eq!(command.get_parameters().len(), 6);
            assert_eq!(command.get_options().len(), 2);
            assert_eq!(command.get_arguments().len(), 3);
        }

        // Test for Command::from_no_options
        #[test]
        fn without_options() {
            // initialize arguments list and add arguments
            let mut arguments = Vec::new();
            arguments.push("command");
            arguments.push("--param1=value1");
            arguments.push("--param2=value2");
            arguments.push("-short-param1=short-value1");
            arguments.push("-short-param2=short-value2");
            arguments.push("--param3");
            arguments.push("value3");
            arguments.push("--param4");
            arguments.push("value4");
            arguments.push("some");
            arguments.push("more");
            arguments.push("arguments");

            // parse command
            let command = Command::without_options(&arguments);

            // check values
            assert_eq!(command.get_command(), "command");
            assert_eq!(*command.get_parameter("param1").unwrap(), "value1");
            assert_eq!(*command.get_parameter("param2").unwrap(), "value2");
            assert_eq!(*command.get_parameter("param3").unwrap(), "value3");
            assert_eq!(*command.get_parameter("param4").unwrap(), "value4");
            assert_eq!(
                *command.get_parameter("short-param1").unwrap(),
                "short-value1"
            );
            assert_eq!(
                *command.get_parameter("short-param2").unwrap(),
                "short-value2"
            );
            assert_eq!(command.is_option("option1"), false);
            assert_eq!(*command.get_argument(0).unwrap(), "some");
            assert_eq!(*command.get_argument(1).unwrap(), "more");
            assert_eq!(*command.get_argument(2).unwrap(), "arguments");

            // check lengths
            assert_eq!(command.get_parameters().len(), 6);
            assert_eq!(command.get_options().len(), 0);
            assert_eq!(command.get_arguments().len(), 3);
        }

        // Test for Command::from_no_command()
        #[test]
        fn without_command() {
            // define possible options
            let options = ["option1", "option2", "option3"];

            // initialize arguments list and add arguments
            let mut arguments = Vec::new();
            arguments.push("--param1=value1");
            arguments.push("--param2=value2");
            arguments.push("-short-param1=short-value1");
            arguments.push("--option1");
            arguments.push("-short-param2=short-value2");
            arguments.push("--option2");
            arguments.push("--param3");
            arguments.push("value3");
            arguments.push("--param4");
            arguments.push("value4");
            arguments.push("some");
            arguments.push("more");
            arguments.push("arguments");

            // parse command
            let command = Command::without_command(&arguments, &options);

            // check values
            assert_eq!(command.get_command(), "");
            assert_eq!(*command.get_parameter("param1").unwrap(), "value1");
            assert_eq!(*command.get_parameter("param2").unwrap(), "value2");
            assert_eq!(*command.get_parameter("param3").unwrap(), "value3");
            assert_eq!(*command.get_parameter("param4").unwrap(), "value4");
            assert_eq!(
                *command.get_parameter("short-param1").unwrap(),
                "short-value1"
            );
            assert_eq!(
                *command.get_parameter("short-param2").unwrap(),
                "short-value2"
            );
            assert_eq!(command.is_option("option1"), true);
            assert_eq!(command.is_option("option2"), true);
            assert_eq!(command.is_option("option3"), false);
            assert_eq!(*command.get_argument(0).unwrap(), "some");
            assert_eq!(*command.get_argument(1).unwrap(), "more");
            assert_eq!(*command.get_argument(2).unwrap(), "arguments");

            // check lengths
            assert_eq!(command.get_parameters().len(), 6);
            assert_eq!(command.get_options().len(), 2);
            assert_eq!(command.get_arguments().len(), 3);
        }

        // Test for Command::from_no_command_and_no_options
        #[test]
        fn without_command_and_options() {
            // initialize arguments list and add arguments
            let mut arguments = Vec::new();
            arguments.push("--param1=value1");
            arguments.push("--param2=value2");
            arguments.push("-short-param1=short-value1");
            arguments.push("-short-param2=short-value2");
            arguments.push("--param3");
            arguments.push("value3");
            arguments.push("--param4");
            arguments.push("value4");
            arguments.push("some");
            arguments.push("more");
            arguments.push("arguments");

            // parse command
            let command = Command::without_command_and_options(&arguments);

            // check values
            assert_eq!(command.get_command(), "");
            assert_eq!(*command.get_parameter("param1").unwrap(), "value1");
            assert_eq!(*command.get_parameter("param2").unwrap(), "value2");
            assert_eq!(*command.get_parameter("param3").unwrap(), "value3");
            assert_eq!(*command.get_parameter("param4").unwrap(), "value4");
            assert_eq!(
                *command.get_parameter("short-param1").unwrap(),
                "short-value1"
            );
            assert_eq!(
                *command.get_parameter("short-param2").unwrap(),
                "short-value2"
            );
            assert_eq!(command.is_option("option1"), false);
            assert_eq!(*command.get_argument(0).unwrap(), "some");
            assert_eq!(*command.get_argument(1).unwrap(), "more");
            assert_eq!(*command.get_argument(2).unwrap(), "arguments");

            // check lengths
            assert_eq!(command.get_parameters().len(), 6);
            assert_eq!(command.get_options().len(), 0);
            assert_eq!(command.get_arguments().len(), 3);
        }

        // Test for Command::from
        #[test]
        fn from() {
            // define possible options
            let options = ["option1", "option2", "option3"];

            // initialize arguments list and add arguments
            let mut arguments = Vec::new();
            arguments.push("command");
            arguments.push("--param1=value1");
            arguments.push("--param2=value2");
            arguments.push("-short-param1=short-value1");
            arguments.push("--option1");
            arguments.push("-short-param2=short-value2");
            arguments.push("--option2");
            arguments.push("--param3");
            arguments.push("value3");
            arguments.push("--param4");
            arguments.push("value4");
            arguments.push("some");
            arguments.push("more");
            arguments.push("arguments");

            // parse command
            let command = Command::from(&arguments, &options);

            // check values
            assert_eq!(command.get_command(), "command");
            assert_eq!(*command.get_parameter("param1").unwrap(), "value1");
            assert_eq!(*command.get_parameter("param2").unwrap(), "value2");
            assert_eq!(*command.get_parameter("param3").unwrap(), "value3");
            assert_eq!(*command.get_parameter("param4").unwrap(), "value4");
            assert_eq!(
                *command.get_parameter("short-param1").unwrap(),
                "short-value1"
            );
            assert_eq!(
                *command.get_parameter("short-param2").unwrap(),
                "short-value2"
            );
            assert_eq!(command.is_option("option1"), true);
            assert_eq!(command.is_option("option2"), true);
            assert_eq!(command.is_option("option3"), false);
            assert_eq!(*command.get_argument(0).unwrap(), "some");
            assert_eq!(*command.get_argument(1).unwrap(), "more");
            assert_eq!(*command.get_argument(2).unwrap(), "arguments");

            // check lengths
            assert_eq!(command.get_parameters().len(), 6);
            assert_eq!(command.get_options().len(), 2);
            assert_eq!(command.get_arguments().len(), 3);
        }
    }
}