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

pub mod prelude;

mod error;
mod opt;
mod state;
#[cfg(test)]
mod tests;

pub use crate::{
    error::{Error, ErrorKind},
    opt::Opt,
    state::State,
};
use std::result;

/// A specialized `Result` type for use with [`getopt`](fn.getopt.html)
pub type Result<T> = result::Result<T, Error>;

/// 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)`](struct.Opt.html).
///
/// # Examples
///
/// ## "-"
/// ```
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// use getopt::prelude::*;
///
/// // 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)?);
/// assert_eq!("-", args[state.index]);
/// # Ok(())
/// # }
/// ```
///
/// ## "--"
/// ```
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// use getopt::prelude::*;
///
/// // 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)?);
/// assert_eq!("-a", args[state.index]);
/// # Ok(())
/// # }
/// ```
///
/// ## Unexpected option:
/// ```
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// use getopt::prelude::*;
///
/// // 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!(
///     "unknown option -- b".to_string(),
///     getopt(&args, optstring, &mut state)
///         .unwrap_err()
///         .to_string()
/// );
/// # Ok(())
/// # }
/// ```
///
/// ## Missing argument:
/// ```
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// use getopt::prelude::*;
///
/// // 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!(
///     "option requires an argument -- a".to_string(),
///     getopt(&args, optstring, &mut state)
///         .unwrap_err()
///         .to_string()
/// );
/// # Ok(())
/// # }
/// ```
///
/// ## A simple example:
/// ```
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// use getopt::prelude::*;
///
/// // 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)?);
/// assert_eq!(State { index: 1, point: 2 }, state);
/// assert_eq!(
///     Opt(Some('b'), Some("c".to_string())),
///     getopt(&args, optstring, &mut state)?
/// );
/// assert_eq!(State { index: 2, point: 0 }, state);
/// assert_eq!(Opt(None, None), getopt(&args, optstring, &mut state)?);
/// assert_eq!(State { index: 2, point: 0 }, state);
/// assert_eq!("foo", args[state.index]);
/// # Ok(())
/// # }
/// ```
///
/// ## A more realistic example:
/// ```
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// use getopt::prelude::*;
///
/// // 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)? {
///         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,
///         _ => unreachable!(),
///     }
/// }
///
/// 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());
/// # Ok(())
/// # }
/// ```
pub fn getopt(args: &[String], optstring: &str, state: &mut State) -> Result<Opt> {
    let args: Vec<Vec<char>> = explode(args);
    let nothing: Result<Opt> = 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].is_empty()
            || 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(Error::new(ErrorKind::UnknownOption, 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(Error::new(ErrorKind::MissingArgument, 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
}