use crate::token::{Token, Tokenizer};
use anyhow::anyhow;

/// A plugin-based Lexer.
/// It perform lexical analysis on strings
pub struct Lexer<'a> {
    /// The [Tokenizer]s who describe the lexicon
    tokenizers: Vec<Tokenizer<'a>>,
}

impl<'a> Lexer<'a> {
    /// Create a builder
    ///
    /// # Example
    /// ```rust
    /// use lexer::Lexer;
    /// use lexer::token::{TokenKind, Tokenizer};
    ///
    /// let int = Tokenizer::new(TokenKind::LITERAL("INT"), |s: &str| { s.chars().all(|c| c.is_digit(10)) });
    /// let lex = Lexer::builder().add(int).build();
    /// ```
    pub fn builder() -> LexerBuilder<'a> {
        LexerBuilder::new()
    }

    /// Return a vector of [Token] from the given string
    ///
    /// # Errors
    /// Return an Error if a part of the string doesn't match any token
    ///
    /// # Example
    /// ```rust
    /// use regex::Regex;
    /// use lexer::Lexer;
    /// use lexer::token::{TokenKind, Tokenizer};
    ///
    /// // Simple math lexer example
    /// let plus = Tokenizer::new(TokenKind::OPERATOR("PLUS"), '+');
    /// let minus = Tokenizer::new(TokenKind::OPERATOR("MINUS"), '-');
    /// let star = Tokenizer::new(TokenKind::OPERATOR("STAR"), '*');
    /// let slash = Tokenizer::new(TokenKind::OPERATOR("SLASH"), '/');
    /// let equal = Tokenizer::new(TokenKind::OPERATOR("EQUAL"), '=');
    /// let number = Tokenizer::new(TokenKind::LITERAL("NUMBER"), |s: &str| {
    ///   let mut dot_seen = false;
    ///
    ///   for ch in s.chars() {
    ///     if !ch.is_digit(10) && (ch != '.' || dot_seen) {
    ///       return false;
    ///     } else if ch == '.' {
    ///       dot_seen = true;
    ///     }
    ///   }
    ///   
    ///   true
    /// });
    /// let id_regex = Regex::new(r"[a-zA-Z_$][a-zA-Z_$0-9]*").unwrap();
    /// let id = Tokenizer::new(TokenKind::IDENTIFIER, id_regex);
    /// let whitespace = Tokenizer::new(TokenKind::WHITESPACE("SPACE"), ' ');
    /// let lexer = Lexer::builder()
    ///   .extend(vec![plus, minus, star, slash, equal, number, id, whitespace])
    ///   .build();
    ///
    /// assert!(lexer.tokenize("x_4 = 1 + 3 = 8 * 0.25").is_ok());
    /// // Our lexer doesn't handle parenthesis...
    /// assert!(lexer.tokenize("x_4 = (1 + 3)").is_err());
    /// ```
    pub fn tokenize(&self, value: &'a str) -> anyhow::Result<Vec<Token<'a>>> {
        let mut start = 0;
        let mut result = Vec::new();
        // Try to find tokens until EOF or Error
        while start < value.len() {
            let token = self.tokenize_once(value, start)?;
            start += token.value.len();
            result.push(token);
        }

        Ok(result)
    }

    /// Return a [Token] for the given string
    ///
    /// # Error
    /// Return an Error if a part of the string doesn't match any token
    fn tokenize_once(&self, value: &'a str, start: usize) -> anyhow::Result<Token<'a>> {
        let mut best_token = None;
        let mut best_size = 0;
        // Try for each tokenizer in order
        for tokenizer in &self.tokenizers {
            if let Some(token) = tokenizer.tokenize(&value[start..]) {
                if token.value.len() > best_size {
                    best_size = token.value.len();
                    best_token = Some(token);
                }
            }
        }

        best_token.ok_or(anyhow!("No match for '{}'", value))
    }
}

/// Builder for [Lexer]
pub struct LexerBuilder<'a> {
    /// Temporary tokenizers for the Lexer
    tokenizers: Vec<Tokenizer<'a>>,
}

impl<'a> LexerBuilder<'a> {
    /// Create a LexerBuilder
    ///
    /// # Example
    /// ```rust
    /// use lexer::LexerBuilder;
    ///
    /// let mut builder = LexerBuilder::new();
    /// ```
    pub fn new() -> Self {
        Self {
            tokenizers: Vec::new(),
        }
    }

    /// Add a [Tokenizer] to the builder and return it
    ///
    /// # Example
    /// ```rust
    /// use lexer::LexerBuilder;
    /// use lexer::token::{TokenKind, Tokenizer};
    ///
    /// let builder = LexerBuilder::new()
    ///   .add(Tokenizer::new(TokenKind::DELIMITER("OPAREN"), '('))
    ///   .add(Tokenizer::new(TokenKind::DELIMITER("CPAREN"), ')'));
    /// ```
    pub fn add(mut self, tokenizer: Tokenizer<'a>) -> Self {
        self.tokenizers.push(tokenizer);
        self
    }

    /// Add a vector of [Tokenizer] to the builder and return it
    ///
    /// # Example
    /// ```rust
    /// use lexer::LexerBuilder;
    /// use lexer::token::{TokenKind, Tokenizer};
    ///
    /// let tok = vec![
    ///     Tokenizer::new(TokenKind::COMMENT("OPEN"), "/*"),
    ///     Tokenizer::new(TokenKind::DELIMITER("CLOSE"), "*/"),
    /// ];
    /// let builder = LexerBuilder::new().extend(tok);
    /// ```
    pub fn extend(mut self, tokenizers: Vec<Tokenizer<'a>>) -> Self {
        self.tokenizers.extend(tokenizers);
        self
    }

    /// Build a [Lexer]
    ///
    /// # Example
    /// ```rust
    /// use lexer::LexerBuilder;
    /// use lexer::token::{TokenKind, Tokenizer};
    ///
    /// let lexer = LexerBuilder::new()
    ///   .add(Tokenizer::new(TokenKind::WHITESPACE("ALL"), [' ', '\n', '\t', '\r']))
    ///   .build();
    /// ```
    pub fn build(mut self) -> Lexer<'a> {
        // Sort tokenizers by priority
        self.tokenizers.sort_by(|a, b| a.partial_cmp(b).unwrap());
        Lexer {
            tokenizers: self.tokenizers,
        }
    }
}