use crate::tokens::Token;
use std::sync::Arc;

pub struct Lexer {
    /// GLSL source
    pub input: Vec<char>,
    /// Position in source
    pub position: usize,
    /// [`char`] under position
    pub current_char: Option<char>,
}

impl Lexer {
    pub fn new(input: &str) -> Self {
        let mut lexer = Lexer {
            input: input.chars().collect(),
            position: 0,
            current_char: None,
        };
        lexer.current_char = if lexer.position < lexer.input.len() {
            Some(lexer.input[lexer.position])
        } else {
            None
        };
        lexer
    }
    fn advance(&mut self) {
        self.position += 1;
        self.current_char = if self.position < self.input.len() {
            Some(self.input[self.position])
        } else {
            None
        };
    }

    fn peek(&self) -> Option<char> {
        if self.position + 1 < self.input.len() {
            Some(self.input[self.position + 1])
        } else {
            None
        }
    }

    /// Parses the source given the [`Lexer`] upon initialization and returns a vector of [`Token`].
    /// # Example:
    /// ```
    /// use glsl_lexer::*;
    /// let source = r#"
    ///     #version 440
    ///     uniform float time;
    ///     void main() {
    ///         gl_FragColor = vec4(1.0, 0.5, 0.2, 1.0);
    ///     }
    /// "#;
    /// let mut lexer = glsl_lexer::Lexer::new(&source);
    /// let tokens = lexer.get_tokens();
    /// dbg!("{}", tokens);
    ///```
    // We are using Arc<[Token]> as return type for cheaper cloning of the returned value
    fn get_tokens(&mut self) -> Arc<[Token]> {
        let mut tokens: Vec<Token> = Vec::new();

        tokens.into()
    }

    fn match_token(&self, ) -> Token {}
}