//! # getopt
//!
//! `getopt` provides a minimalistic, (essentially) POSIX-compliant option parser.

/// A single option.
///
/// For `Opt(x, y)`:
///   - `x` is `Some` character, or `None` if no option was found.
///   - `y` is `Some` string, or `None` if no argument was expected.
///
/// # Example
///
/// ```
/// use getopt::*;
///
/// // args = ["program", "-abc", "foo"];
/// # let args: Vec<String> = vec!["program", "-abc", "foo"]
/// #     .into_iter()
/// #     .map(String::from)
/// #     .collect();
/// let optstring = "ab:c";
/// let mut state = State::new();
///
/// assert_eq!(
///     Opt(Some('a'), None),
///     getopt(&args, optstring, &mut state).unwrap()
/// );
/// assert_eq!(
///     Opt(Some('b'), Some(String::from("c"))),
///     getopt(&args, optstring, &mut state).unwrap()
/// );
/// assert_eq!(
///     Opt(None, None),
///     getopt(&args, optstring, &mut state).unwrap()
/// );
/// ```
#[derive(Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct Opt(pub Option<char>, pub Option<String>);

/// The current state of the parser.
///
/// `args[index]` is the current element being parsed.
/// `args[index][point]` is the current character being parsed.
///
/// After parsing is complete (that is, [`Opt(None, None)`][`Opt`] is returned), any remaining arguments can
/// be found in `args` beginning at `index`.
///
/// # Example
///
/// ```
/// use getopt::*;
///
/// // args = ["program", "-abc", "foo"];
/// # let args: Vec<String> = vec!["program", "-abc", "foo"]
/// #     .into_iter()
/// #     .map(String::from)
/// #     .collect();
/// let optstring = "ab:c";
/// let mut state = State::new();
///
/// getopt(&args, optstring, &mut state).unwrap();
/// assert_eq!(State { index: 1, point: 2 }, state);
/// getopt(&args, optstring, &mut state).unwrap();
/// assert_eq!(State { index: 2, point: 0 }, state);
/// getopt(&args, optstring, &mut state).unwrap();
/// assert_eq!(State { index: 2, point: 0 }, state);
/// assert_eq!("foo", args[state.index]);
/// ```
///
/// [`Opt`]: struct.Opt.html
#[derive(Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct State {
    pub index: usize,
    pub point: usize,
}

impl State {
    /// Constructs a new `State`, with `index` and `point` initialized to 1 and 0, respectively.
    pub fn new() -> State {
        State::default()
    }
}

impl Default for State {
    fn default() -> State {
        State { index: 1, point: 0 }
    }
}

/// Returns the next option character, if any.
///
/// Returns an error if an unexpected option is encountered or if an expected argument is not
/// found.
///
/// Parsing stops at the first non-hyphenated argument; or at the first argument matching "-"; or
/// after the first argument matching "--".
///
/// When no more options are available, `getopt` returns [`Opt(None, None)`][`Opt`].
///
/// # Examples
///
/// ## "-"
/// ```
/// use getopt::*;
///
/// // args = ["program", "-", "-a"];
/// # let args: Vec<String> = vec!["program", "-", "-a"]
/// #     .into_iter()
/// #     .map(String::from)
/// #     .collect();
/// let optstring = "a";
/// let mut state = State::new();
///
/// assert_eq!(
///     Opt(None, None),
///     getopt(&args, optstring, &mut state).unwrap()
/// );
/// assert_eq!("-", args[state.index]);
/// ```
///
/// ## "--"
/// ```
/// use getopt::*;
///
/// // args = ["program", "--", "-a"];
/// # let args: Vec<String> = vec!["program", "--", "-a"]
/// #     .into_iter()
/// #     .map(String::from)
/// #     .collect();
/// let optstring = "a";
/// let mut state = State::new();
///
/// assert_eq!(
///     Opt(None, None),
///     getopt(&args, optstring, &mut state).unwrap()
/// );
/// assert_eq!("-a", args[state.index]);
/// ```
///
/// ## Unexpected option:
/// ```
/// use getopt::*;
///
/// // args = ["program", "-b"];
/// # let args: Vec<String> = vec!["program", "-b"]
/// #     .into_iter()
/// #     .map(String::from)
/// #     .collect();
/// let optstring = "a";
/// let mut state = State::new();
///
/// assert_eq!(
///     Err(String::from("unknown option -- b")),
///     getopt(&args, optstring, &mut state)
/// );
/// ```
///
/// ## Missing argument:
/// ```
/// use getopt::*;
///
/// // args = ["program", "-a"];
/// # let args: Vec<String> = vec!["program", "-a"]
/// #     .into_iter()
/// #     .map(String::from)
/// #     .collect();
/// let optstring = "a:";
/// let mut state = State::new();
///
/// assert_eq!(
///     Err(String::from("option requires an argument -- a")),
///     getopt(&args, optstring, &mut state)
/// );
/// ```
///
/// ## A simple example:
/// ```
/// use getopt::*;
///
/// // args = ["program", "-abc", "foo"];
/// # let args: Vec<String> = vec!["program", "-abc", "foo"]
/// #     .into_iter()
/// #     .map(String::from)
/// #     .collect();
/// let optstring = "ab:c";
/// let mut state = State::new();
///
/// assert_eq!(
///     Opt(Some('a'), None),
///     getopt(&args, optstring, &mut state).unwrap()
/// );
/// assert_eq!(State { index: 1, point: 2 }, state);
/// assert_eq!(
///     Opt(Some('b'), Some(String::from("c"))),
///     getopt(&args, optstring, &mut state).unwrap()
/// );
/// assert_eq!(State { index: 2, point: 0 }, state);
/// assert_eq!(
///     Opt(None, None),
///     getopt(&args, optstring, &mut state).unwrap()
/// );
/// assert_eq!(State { index: 2, point: 0 }, state);
/// assert_eq!("foo", args[state.index]);
/// ```
///
/// ## A more realistic example:
/// ```
/// use getopt::*;
///
/// // args = ["program", "-abc", "-d", "foo", "-e", "bar"];
/// # let mut args: Vec<String> = vec!["program", "-abc", "-d", "foo", "-e", "bar"]
/// #     .into_iter()
/// #     .map(String::from)
/// #     .collect();
/// let optstring = "ab:cd:e";
/// let mut state = State::new();
///
/// let mut a_flag = false;
/// let mut b_flag = String::new();
/// let mut c_flag = false;
/// let mut d_flag = String::new();
/// let mut e_flag = false;
///
/// loop {
///     match getopt(&args, optstring, &mut state) {
///         Err(error) => panic!("{}", error),
///         Ok(opt) => match opt {
///             Opt(None, _) => break,
///             Opt(Some('a'), None) => a_flag = true,
///             Opt(Some('b'), Some(arg)) => b_flag = arg.clone(),
///             Opt(Some('c'), None) => c_flag = true,
///             Opt(Some('d'), Some(arg)) => d_flag = arg.clone(),
///             Opt(Some('e'), None) => e_flag = true,
///             _ => panic!("unknown option: {:?}", opt),
///         },
///     }
/// }
///
/// let args = args.split_off(state.index);
///
/// assert_eq!(true, a_flag);
/// assert_eq!("c", b_flag);
/// assert_eq!(false, c_flag);
/// assert_eq!("foo", d_flag);
/// assert_eq!(true, e_flag);
///
/// assert_eq!(1, args.len());
/// assert_eq!("bar", args.first().unwrap());
/// ```
///
/// [`Opt`]: struct.Opt.html
pub fn getopt(args: &[String], optstring: &str, state: &mut State) -> Result<Opt, String> {
    let args: Vec<Vec<char>> = explode(args);
    let nothing: Result<Opt, String> = Ok(Opt(None, None));

    if state.point == 0 {
        /*
         * If, when getopt() is called:
         *      argv[optind] is a null pointer
         *      *argv[optind] is not the character '-'
         *      argv[optind] points to the string "-"
         * getopt() shall return -1 without changing optind.
         */
        if state.index >= args.len() || args[state.index][0] != '-' || args[state.index].len() == 1
        {
            return nothing;
        }

        /*
         * If:
         *      argv[optind] points to the string "--"
         * getopt() shall return -1 after incrementing optind.
         */
        if args[state.index][1] == '-' && args[state.index].len() == 2 {
            state.index += 1;
            return nothing;
        }

        state.point += 1;
    }

    let opt: char = args[state.index][state.point];
    state.point += 1;

    match get_spec(optstring, opt) {
        None => Err(format!("unknown option -- {}", opt)),
        Some(Spec(c, false)) => {
            if state.point >= args[state.index].len() {
                state.index += 1;
                state.point = 0;
            }
            Ok(Opt(Some(c), None))
        }
        Some(Spec(c, true)) => {
            let arg: String = if state.point >= args[state.index].len() {
                state.index += 1;
                if state.index >= args.len() {
                    return Err(format!("option requires an argument -- {}", opt));
                }
                args[state.index].iter().collect()
            } else {
                args[state.index]
                    .clone()
                    .split_off(state.point)
                    .iter()
                    .collect()
            };
            state.index += 1;
            state.point = 0;

            Ok(Opt(Some(c), Some(arg)))
        }
    }
}

fn explode(array: &[String]) -> Vec<Vec<char>> {
    array.into_iter().map(|e| e.chars().collect()).collect()
}

struct Spec(char, bool);

fn get_spec(optstring: &str, c: char) -> Option<Spec> {
    let optstring: Vec<char> = optstring.chars().collect();

    for i in 0..optstring.len() {
        if optstring[i] == c {
            return Some(Spec(c, i + 1 < optstring.len() && optstring[i + 1] == ':'));
        }
    }
    None
}

#[cfg(test)]
mod tests;