use self::ErrorKind::*;
use std::{error, fmt};

/// What kinds of errors [`getopt`](fn.getopt.html) can return.
#[derive(Debug)]
pub enum ErrorKind {
    /// An argument was not found for an option that was expecting one.
    MissingArgument,
    /// An unknown option character was encountered.
    UnknownOption,
}

/// A basic error type for [`getopt`](fn.getopt.html)
#[derive(Debug)]
pub struct Error {
    culprit: char,
    kind: ErrorKind,
}

impl Error {
    /// Creates a new error using a known kind and the character that caused the issue.
    pub fn new(kind: ErrorKind, culprit: char) -> Error {
        Error { culprit, kind }
    }

    /// Returns the [`ErrorKind`](enum.ErrorKind.html) for this error.
    pub fn kind(self) -> ErrorKind {
        self.kind
    }
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self.kind {
            MissingArgument => write!(f, "option requires an argument -- {}", self.culprit),
            UnknownOption => write!(f, "unknown option -- {}", self.culprit),
        }
    }
}

impl error::Error for Error {
    fn cause(&self) -> Option<&error::Error> {
        None
    }
}