use super::error::ProgramError;
use super::Token;

pub type LexerResult = Result<Token, ProgramError>;

/// A lexer (tokenizer) for a mathematical expression.
///
/// The Lexer programatically tokenizes one or more bytes of a program, with safety checks to
/// enable notification that the program has concluded (EOF). Each Token is individually useless
/// unless further processed; for instance, by the Parser.
///
/// As an example, an abstract representation of a program's tokenization is shown:
///
/// ```ignore
/// in:
///     123 + 281 ./ 3
///     ^~~ ^ ^~~ ^~ ^
/// out (over 5 iterations):
///     1. INTEGER(123)
///     2. PLUS
///     3. INTEGER(281)
///     4. DIVIDEINT
///     5. INTEGER(3)
/// ```
///
/// We expect the Parser to be agnostic to the significance and relationship of each byte in the
/// program, instead concerned only with the creation and typing of bytes. As such, the Lexer is
/// built to refrain from analyzing anything but the values of bytes in a program.
pub struct Lexer<'a> {
    text: &'a str,
    size: usize,
    ptr: usize,
    chr: Option<char>,
}

impl<'a> Lexer<'a> {
    /// Creates a Lexer from a text program.
    pub fn from(text: &str) -> Lexer {
        Lexer {
            text: &text,
            size: text.len(),
            ptr: 0,
            chr: Some(text.as_bytes()[0] as char),
        }
    }

    /// Pushes the Lexer's character pointer by one increment and sets the Lexer's next character
    /// to the one pointed at in the program. If the pointer extends past the end of the program,
    /// the character is set to `None`.
    fn push_ptr(&mut self) {
        self.ptr += 1;
        if self.ptr < self.size {
            self.chr = Some(self.text.as_bytes()[self.ptr] as char);
        } else {
            self.chr = None;
        }
    }

    /// Gives the next `amt` characters in the program as a String. If there are less characters
    /// remaining in the program than `amt`, then only the remaining characters are given.
    fn peek_ahead(&self, amt: &usize) -> String {
        let mut result = String::new();
        let next_ptr = self.ptr;
        for pos in (next_ptr)..(next_ptr + amt) {
            if pos < self.size {
                result.push(self.text.as_bytes()[pos] as char);
            } else {
                break;
            }
        }
        result
    }

    /// Pushes the Lexer's pointer past any whitespace in the program, or until the end of the
    /// program.
    fn skip_whitespace(&mut self) {
        while let Some(chr) = self.chr {
            if chr.is_whitespace() {
                self.push_ptr();
            } else {
                break;
            }
        }
    }

    /// Build an integer in the program until a non-digit is found or the end of program is
    /// reached.
    fn build_integer(&mut self) -> usize {
        let mut result = String::new();
        while let Some(chr) = self.chr {
            if chr.is_digit(10) {
                result.push(self.chr.unwrap());
                self.push_ptr();
            } else {
                break;
            }
        }
        result.parse::<usize>().unwrap()
    }

    /// Skips `amt` Tokens and returns the current Lexer. Primarily intended for use in method
    /// chaining:
    ///
    /// ```
    /// # mod rcalc;
    /// # use rcalc::{Lexer, Token};
    /// let mut lexer = Lexer::from("2 + 3");
    /// let result = lexer.skip(1).next_token().unwrap(); // => Token::PLUS
    /// # assert_eq!(result, Token::PLUS);
    /// ```
    pub fn skip(&mut self, amt: usize) -> &mut Lexer<'a> {
        for _ in 0..amt {
            match self.next_token() {
                _ => (),
            };
        }
        self
    }

    /// Tokenizes the next one or more characters in the program. If no valid Token can be made,
    /// the Lexer panics.
    ///
    /// ```
    /// # mod rcalc;
    /// # use rcalc::{Lexer, Token};
    /// let mut lexer = Lexer::from("2 + 3");
    /// let result = lexer.next_token().unwrap(); // => Token::NUMBER(2)
    /// # assert_eq!(result, Token::NUMBER(2));
    /// ```
    pub fn next_token(&mut self) -> LexerResult {
        while let Some(chr) = self.chr {
            if chr.is_whitespace() {
                self.skip_whitespace();
                continue;
            } else if chr.is_digit(10) {
                return Ok(Token::NUMBER(self.build_integer()));
            } else {
                self.push_ptr();
                match chr {
                    // Operands
                    '+' => return Ok(Token::PLUS),
                    '-' => return Ok(Token::MINUS),
                    '*' => return Ok(Token::MULTIPLY),
                    '/' => return Ok(Token::DIVIDE),
                    '%' => return Ok(Token::MODULO),
                    '^' => return Ok(Token::EXPONENT),
                    '!' => return Ok(Token::FACTORIAL),
                    '.' => {
                        match self.peek_ahead(&1).as_ref() {
                            "/" => {
                                self.push_ptr();
                                return Ok(Token::DIVIDEINT);
                            }
                            _ => {
                                return Err(ProgramError::of(
                                    "InvalidOperand",
                                    "Invalid multi-character operand.",
                                ))
                            }
                        }
                    }

                    // Controls
                    '(' => return Ok(Token::LPAREN),
                    ')' => return Ok(Token::RPAREN),

                    // Error
                    _ => {
                        return Err(ProgramError::of(
                            "InvalidCharacter",
                            "Expected Token, found unknown character.",
                        ))
                    }
                }
            }
        }

        Ok(Token::EOF)
    }
}