use std::env;

/**
Enum allowing to choose the type of argument.
*/
#[derive(Debug)]
pub enum ArgType
{
    Flag,
    Value,
    ValueList,
}

/**
ArgResult enum is similar to ArgType enum but contains data generated through parsing
*/
#[derive(Debug, PartialEq)]
pub enum ArgResult
{
    Flag,
    Value(String),
    ValueList(Vec<String>),
}

///

/// Argument struct allows to specify type of expected argument, its names and after parsing contains results.

///

/// # Examples

/// ```

/// use trivial_argument_parser::*;

/// let mut example_argument = Argument::new(Some('l'), Some("an-list"), ArgType::ValueList).unwrap();

/// ```


#[derive(Debug)]
pub struct Argument
{
    short: Option<char>,
    long: Option<String>,
    arg_type: ArgType,
    pub arg_result: Option<ArgResult>,
}

impl Argument
{
    /**
    Create new Argument. You need to specify at least one name (short or long) or you can specify both. Parameter arg_type changes how the parsing will treat the argument.
    */
    pub fn new(short: Option<char>, long: Option<& str>, arg_type: ArgType) -> Result<Argument, String>
    {
        // Check if at least 1 name is specified

        match & short
        {
            None =>
            {
                match & long
                {
                    None =>
                    {
                        return Err(String::from("At least one name of argument must be specified (short or long or both)"))
                    }
                    _ => ()
                }
            }
            _ => (),
        };

        // Check if long name is defined, if so use it

        let long_owned: Option<String> = match long
        {
            Some(text) => Some(String::from(text)),
            None => None,
        };

        Ok(Argument{short, long: long_owned, arg_type, arg_result: None})
    }

    pub fn add_value(& mut self, input_iter: & mut std::slice::Iter<'_, String>) -> Result<(), String>
    {
        match self.arg_type
        {
            ArgType::Flag =>
            {
                match self.arg_result
                {
                    Some(_) => return Err(String::from("Flag already set")),
                    _ => (),
                }
                self.arg_result = Some(ArgResult::Flag);
            }
            ArgType::Value =>
            {
                match self.arg_result
                {
                    Some(_) => return Err(String::from("Value already assigned")),
                    _ => (),
                }
                match input_iter.next()
                {
                    Some(word) => self.arg_result = Some(ArgResult::Value(String::from(word))),
                    None => return Err(String::from("Expected value")),
                }

            }
            ArgType::ValueList =>
            {
                let mut new_result = false;
                match self.arg_result
                {
                    Some(_) => (),
                    None => new_result = true,
                }

                if new_result
                {
                    self.arg_result = Some(ArgResult::ValueList(Vec::new()));
                }

                match input_iter.next()
                {
                    Some(word) =>
                    {
                        match self.arg_result.as_mut().expect("as mut")
                        {
                            ArgResult::ValueList(ref mut values) => values.push(String::from(word)),
                            _ => return Err(String::from("WTF")),
                        }
                    }
                    None => return Err(String::from("Expected value")),
                }
            }
        }

        Ok(())
    }
}

///

/// Acumulates arguments into list which then can be fed to parse.

///

/// # Examples

/// ```

/// use trivial_argument_parser::*;

/// let mut args_list = ArgumentList::new();

/// args_list.append_arg(Argument::new(Some('d'), None, ArgType::Flag).unwrap());

/// args_list.append_arg(Argument::new(Some('p'), None, ArgType::Value).unwrap());

/// args_list.append_arg(Argument::new(Some('l'), Some("an-list"), ArgType::ValueList).unwrap());

/// ```

#[derive(Debug)]
pub struct ArgumentList
{
    pub dangling_values: Vec<String>,
    pub arguments: Vec<Argument>,
}

impl ArgumentList
{
    /**
    Create ArgumentList with empty vector of arguments.
    */
    pub fn new() -> ArgumentList
    {
        ArgumentList{dangling_values: Vec::new(), arguments: Vec::new()}
    }

    /**
    Append argument to the end of the list.
    */
    pub fn append_arg(& mut self, argument: Argument)
    {
        self.arguments.push(argument);
    }

    /**
    Append dangling values (dangling values)
    */
    pub fn append_dangling_value(& mut self, value: & str)
    {
        self.dangling_values.push(String::from(value));
    }

    /**
    Search arguments by short name
    */
    pub fn search_by_short_name(& mut self, name: char) -> Result<& mut Argument, String>
    {
        for x in & mut self.arguments
        {
            match x.short
            {
                Some(symbol) =>
                {
                    if symbol == name
                    {
                        return Ok(x)
                    }
                }
                None => (),
            };
        }
        Err(String::from("Argument not found"))
    }

    /**
    Search arguments by long name
    */
    pub fn search_by_long_name(& mut self, name: & str) -> Result<& mut Argument, String>
    {
        for x in & mut self.arguments
        {
            match x.long
            {
                Some(ref long_name) =>
                {
                    if long_name == name
                    {
                        return Ok(x)
                    }
                }
                None => (),
            }
        }
        Err(String::from("Argument not found"))
    }

    /// Function that does all the parsing. You need to feed user input.

    ///

    /// # Examples

    /// ```

    /// use trivial_argument_parser::*;

    ///

    /// let mut args_list = ArgumentList::new();

    /// args_list.append_arg(Argument::new(Some('d'), None, ArgType::Flag).unwrap());

    /// args_list.append_arg(Argument::new(Some('p'), None, ArgType::Value).unwrap());

    /// args_list.append_arg(Argument::new(Some('l'), Some("an-list"), ArgType::ValueList).unwrap());

    /// args_list.parse_args(args_to_string_vector(std::env::args())).unwrap();

    /// ```

    pub fn parse_args(& mut self, input: Vec<String>) -> Result<(), String>
    {
        let mut input_iter = input.iter();
        while let Some(word) = input_iter.next()
        {
            // Check if word is a short argument, long argument or dangling value

            let word_length = word.chars().count();
            let mut chars = word.chars();
            if word_length == 2
            {
                if word.chars().nth(0).expect("first letter") == '-' &&  word.chars().nth(1).expect(& format!("{}", word_length)).is_alphabetic()
                {
                    // Add value to argument identified by short name

                    match self.search_by_short_name(word.chars().nth(1).unwrap())
                    {
                        Ok(ref mut argument) =>
                        {
                            argument.add_value(& mut input_iter);
                        }
                        Err(msg) =>
                        {
                            return Err(format!("Error while parsing arguments: {}", msg))
                        }
                    };
                }
                else
                {
                    // Add as dangling value

                    self.append_dangling_value(word);
                }
            }
            else if word_length > 2
            {
                if word.chars().nth(0).unwrap() == '-' && word.chars().nth(1).unwrap() == '-' && word.chars().nth(2).unwrap().is_alphabetic()
                {
                    // Add value to argument identified by long name

                    match self.search_by_long_name(& word[2..word.len()])
                    {
                        Ok(ref mut argument) =>
                        {
                            argument.add_value(& mut input_iter);
                        }
                        Err(msg) =>
                        {
                            return Err(format!("Error while parsing arguments: {}", msg))
                        }
                    };
                }
                else
                {
                    // Add as dangling value

                    self.append_dangling_value(word);
                }
            }
            else
            {
                // Add as dangling value

                self.append_dangling_value(word);
            }
        }

        // return arguments list with filled parsed values

        Ok(())
    }
}

/**
Helper function to transform arguments given by user from Args to vector of String.
*/
pub fn args_to_string_vector(args: env::Args) -> Vec<String>
{
    let mut arguments = Vec::new();

    for x in args
    {
        arguments.push(String::from(x));
    }
    arguments
}

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

    #[test]
    fn parse_works()
    {
        let args = vec![String::from("-d"), String::from("-p"), String::from("/file"), String::from("--an-list"), String::from("Marcin"), String::from("-l"), String::from("Mazgaj")];
        let mut args_list = ArgumentList::new();
        args_list.append_arg(Argument::new(Some('d'), None, ArgType::Flag).expect("append 1"));
        args_list.append_arg(Argument::new(Some('p'), None, ArgType::Value).expect("append 2"));
        args_list.append_arg(Argument::new(Some('l'), Some("an-list"), ArgType::ValueList).expect("append 3"));
        args_list.parse_args(args).unwrap();
        assert_eq!(args_list.arguments[0].arg_result, Some(ArgResult::Flag));
        assert_eq!(args_list.arguments[1].arg_result, Some(ArgResult::Value(String::from("/file"))));
        assert_eq!(args_list.arguments[2].arg_result, Some(ArgResult::ValueList(vec![String::from("Marcin"), String::from("Mazgaj")])));
    }
}