robinpath 0.2.0

use super::token::{is_keyword, Token, TokenKind, TokenValue};
use crate::error::RobinPathError;

pub struct Lexer {
    source: Vec<char>,
    pos: usize,
    line: usize,
    column: usize,
    tokens: Vec<Token>,
    is_continuation: bool,
}

impl Lexer {
    pub fn new(source: &str) -> Self {
        Self {
            source: source.chars().collect(),
            pos: 0,
            line: 1,
            column: 0,
            tokens: Vec::new(),
            is_continuation: false,
        }
    }

    pub fn tokenize(mut self) -> Result<Vec<Token>, RobinPathError> {
        while !self.is_at_end() {
            self.skip_whitespace_not_newline();
            if self.is_at_end() {
                break;
            }

            let ch = self.peek();

            match ch {
                '\n' => {
                    self.emit(TokenKind::Newline, "\n");
                    self.advance();
                    self.line += 1;
                    self.column = 0;
                    self.is_continuation = false;
                }
                '\r' => {
                    self.advance();
                    if self.peek() == '\n' {
                        self.advance();
                    }
                    self.emit(TokenKind::Newline, "\n");
                    self.line += 1;
                    self.column = 0;
                    self.is_continuation = false;
                }
                '\\' => {
                    // Line continuation
                    self.advance();
                    // Skip until newline
                    while !self.is_at_end() && self.peek() != '\n' && self.peek() != '\r' {
                        self.advance();
                    }
                    if !self.is_at_end() {
                        if self.peek() == '\r' {
                            self.advance();
                        }
                        if !self.is_at_end() && self.peek() == '\n' {
                            self.advance();
                        }
                        self.line += 1;
                        self.column = 0;
                    }
                    self.is_continuation = true;
                }
                '#' => self.scan_comment()?,
                '"' | '\'' => self.scan_string(ch)?,
                '`' => self.scan_template_string()?,
                '$' => self.scan_variable()?,
                '@' => self.scan_decorator()?,
                '-' => {
                    // Check for chunk/cell markers: --- chunk:name ---
                    if self.check_fence_marker() {
                        self.scan_fence_marker()?;
                    } else if self.peek_at(1).is_some_and(|c| c == '-' && self.peek_at(2) == Some('-')) {
                        self.scan_fence_marker()?;
                    } else {
                        // Could be negative number or minus operator
                        // If previous token is not a value-producing token, treat as negative number
                        let is_unary = self.is_unary_context();
                        if is_unary && self.peek_at(1).is_some_and(|c| c.is_ascii_digit()) {
                            self.scan_number()?;
                        } else {
                            self.emit(TokenKind::Minus, "-");
                            self.advance();
                        }
                    }
                }
                '+' => {
                    self.emit(TokenKind::Plus, "+");
                    self.advance();
                }
                '*' => {
                    self.emit(TokenKind::Multiply, "*");
                    self.advance();
                }
                '/' => {
                    self.emit(TokenKind::Divide, "/");
                    self.advance();
                }
                '%' => {
                    self.emit(TokenKind::Modulo, "%");
                    self.advance();
                }
                '=' => {
                    self.advance();
                    if !self.is_at_end() && self.peek() == '=' {
                        self.advance();
                        self.emit(TokenKind::Eq, "==");
                    } else {
                        self.emit(TokenKind::Assign, "=");
                    }
                }
                '!' => {
                    self.advance();
                    if !self.is_at_end() && self.peek() == '=' {
                        self.advance();
                        self.emit(TokenKind::Ne, "!=");
                    } else {
                        self.emit(TokenKind::Not, "!");
                    }
                }
                '>' => {
                    self.advance();
                    if !self.is_at_end() && self.peek() == '=' {
                        self.advance();
                        self.emit(TokenKind::Gte, ">=");
                    } else {
                        self.emit(TokenKind::Gt, ">");
                    }
                }
                '<' => {
                    self.advance();
                    if !self.is_at_end() && self.peek() == '=' {
                        self.advance();
                        self.emit(TokenKind::Lte, "<=");
                    } else {
                        self.emit(TokenKind::Lt, "<");
                    }
                }
                '&' => {
                    self.advance();
                    if !self.is_at_end() && self.peek() == '&' {
                        self.advance();
                        self.emit(TokenKind::And, "&&");
                    } else {
                        return Err(RobinPathError::lexer(
                            "Expected '&&' for logical AND",
                            self.line,
                            self.column,
                        ));
                    }
                }
                '|' => {
                    self.advance();
                    if !self.is_at_end() && self.peek() == '|' {
                        self.advance();
                        self.emit(TokenKind::Or, "||");
                    } else {
                        return Err(RobinPathError::lexer(
                            "Expected '||' for logical OR",
                            self.line,
                            self.column,
                        ));
                    }
                }
                '(' => {
                    self.emit(TokenKind::LParen, "(");
                    self.advance();
                }
                ')' => {
                    self.emit(TokenKind::RParen, ")");
                    self.advance();
                }
                '[' => {
                    self.emit(TokenKind::LBracket, "[");
                    self.advance();
                }
                ']' => {
                    self.emit(TokenKind::RBracket, "]");
                    self.advance();
                }
                '{' => {
                    self.emit(TokenKind::LBrace, "{");
                    self.advance();
                }
                '}' => {
                    self.emit(TokenKind::RBrace, "}");
                    self.advance();
                }
                ',' => {
                    self.emit(TokenKind::Comma, ",");
                    self.advance();
                }
                ':' => {
                    self.emit(TokenKind::Colon, ":");
                    self.advance();
                }
                '.' => {
                    // Could be start of number (.5)
                    if self.peek_at(1).is_some_and(|c| c.is_ascii_digit()) {
                        self.scan_number()?;
                    } else {
                        self.emit(TokenKind::Dot, ".");
                        self.advance();
                    }
                }
                _ if ch.is_ascii_digit() => self.scan_number()?,
                _ if ch.is_alphabetic() || ch == '_' => self.scan_identifier()?,
                _ => {
                    // Skip unknown characters
                    self.advance();
                }
            }
        }

        self.emit(TokenKind::Eof, "");
        Ok(self.tokens)
    }

    fn peek(&self) -> char {
        self.source.get(self.pos).copied().unwrap_or('\0')
    }

    fn peek_at(&self, offset: usize) -> Option<char> {
        self.source.get(self.pos + offset).copied()
    }

    fn advance(&mut self) -> char {
        let ch = self.peek();
        self.pos += 1;
        self.column += 1;
        ch
    }

    fn is_at_end(&self) -> bool {
        self.pos >= self.source.len()
    }

    fn emit(&mut self, kind: TokenKind, text: &str) {
        let mut tok = Token::new(kind, text, self.line, self.column);
        tok.is_continuation = self.is_continuation;
        if self.is_continuation && kind != TokenKind::Newline {
            self.is_continuation = false;
        }
        self.tokens.push(tok);
    }

    fn emit_with_value(&mut self, kind: TokenKind, text: &str, value: TokenValue) {
        let mut tok = Token::new(kind, text, self.line, self.column).with_value(value);
        tok.is_continuation = self.is_continuation;
        if self.is_continuation && kind != TokenKind::Newline {
            self.is_continuation = false;
        }
        self.tokens.push(tok);
    }

    fn skip_whitespace_not_newline(&mut self) {
        while !self.is_at_end() {
            let ch = self.peek();
            if ch == ' ' || ch == '\t' {
                self.advance();
            } else {
                break;
            }
        }
    }

    fn is_unary_context(&self) -> bool {
        if self.tokens.is_empty() {
            return true;
        }
        let last = &self.tokens[self.tokens.len() - 1];
        matches!(
            last.kind,
            TokenKind::Newline
                | TokenKind::LParen
                | TokenKind::LBracket
                | TokenKind::Comma
                | TokenKind::Assign
                | TokenKind::Plus
                | TokenKind::Minus
                | TokenKind::Multiply
                | TokenKind::Divide
                | TokenKind::Modulo
                | TokenKind::Eq
                | TokenKind::Ne
                | TokenKind::Gt
                | TokenKind::Lt
                | TokenKind::Gte
                | TokenKind::Lte
                | TokenKind::And
                | TokenKind::Or
                | TokenKind::Not
                | TokenKind::Colon
        )
    }

    fn scan_comment(&mut self) -> Result<(), RobinPathError> {
        let start_col = self.column;
        self.advance(); // skip #
        let mut text = String::from("#");
        while !self.is_at_end() && self.peek() != '\n' && self.peek() != '\r' {
            text.push(self.advance());
        }
        let mut tok = Token::new(TokenKind::Comment, &text, self.line, start_col);
        tok.value = Some(TokenValue::String(text[1..].trim().to_string()));
        tok.is_continuation = self.is_continuation;
        self.tokens.push(tok);
        Ok(())
    }

    fn scan_string(&mut self, quote: char) -> Result<(), RobinPathError> {
        let start_col = self.column;
        let start_line = self.line;
        self.advance(); // skip opening quote
        let mut value = String::new();
        let mut raw = String::new();
        raw.push(quote);

        while !self.is_at_end() {
            let ch = self.peek();
            if ch == '\\' {
                self.advance();
                raw.push('\\');
                if self.is_at_end() {
                    break;
                }
                let escaped = self.advance();
                raw.push(escaped);
                match escaped {
                    'n' => value.push('\n'),
                    't' => value.push('\t'),
                    'r' => value.push('\r'),
                    '\\' => value.push('\\'),
                    '\'' => value.push('\''),
                    '"' => value.push('"'),
                    '$' => value.push('$'),
                    _ => {
                        value.push('\\');
                        value.push(escaped);
                    }
                }
            } else if ch == quote {
                raw.push(quote);
                self.advance();
                self.emit_with_value(
                    TokenKind::String,
                    &raw,
                    TokenValue::String(value),
                );
                // Fix: set line/col correctly for start
                if let Some(tok) = self.tokens.last_mut() {
                    tok.line = start_line;
                    tok.column = start_col;
                }
                return Ok(());
            } else {
                if ch == '\n' {
                    self.line += 1;
                    self.column = 0;
                }
                value.push(ch);
                raw.push(ch);
                self.advance();
            }
        }

        Err(RobinPathError::lexer(
            format!("Unterminated string starting with {}", quote),
            start_line,
            start_col,
        ))
    }

    fn scan_template_string(&mut self) -> Result<(), RobinPathError> {
        let start_col = self.column;
        let start_line = self.line;
        self.advance(); // skip `
        let mut text = String::from("`");

        while !self.is_at_end() {
            let ch = self.peek();
            if ch == '\\' {
                self.advance(); // consume the backslash
                if !self.is_at_end() {
                    let escaped = self.peek();
                    if escaped == '\\' {
                        // \\ → collapse to single \ in raw text
                        text.push(self.advance());
                    } else {
                        // All other escapes: preserve backslash + char for evaluator
                        text.push('\\');
                        text.push(self.advance());
                    }
                }
            } else if ch == '`' {
                text.push(self.advance());
                let mut tok =
                    Token::new(TokenKind::TemplateLiteral, &text, start_line, start_col);
                tok.value = Some(TokenValue::String(
                    text[1..text.len() - 1].to_string(),
                ));
                tok.is_continuation = self.is_continuation;
                self.tokens.push(tok);
                return Ok(());
            } else {
                if ch == '\n' {
                    self.line += 1;
                    self.column = 0;
                }
                text.push(self.advance());
            }
        }

        Err(RobinPathError::lexer(
            "Unterminated template string",
            start_line,
            start_col,
        ))
    }

    fn scan_variable(&mut self) -> Result<(), RobinPathError> {
        let start_col = self.column;

        // Check for $( subexpression
        if self.peek_at(1) == Some('(') {
            self.advance(); // $
            self.advance(); // (
            self.emit_with_value(
                TokenKind::SubexpressionOpen,
                "$(",
                TokenValue::String("$(".to_string()),
            );
            if let Some(tok) = self.tokens.last_mut() {
                tok.column = start_col;
            }
            return Ok(());
        }

        // Check for bare $ (last value)
        if self.peek_at(1).is_none()
            || self
                .peek_at(1)
                .is_some_and(|c| !c.is_alphanumeric() && c != '_')
        {
            self.advance();
            self.emit_with_value(
                TokenKind::Variable,
                "$",
                TokenValue::String(String::new()),
            );
            if let Some(tok) = self.tokens.last_mut() {
                tok.column = start_col;
            }
            return Ok(());
        }

        // Scan full variable: $name.path[0][$key]
        let mut text = String::new();
        text.push(self.advance()); // $

        // Scan variable name
        while !self.is_at_end() {
            let ch = self.peek();
            if ch.is_alphanumeric() || ch == '_' {
                text.push(self.advance());
            } else {
                break;
            }
        }

        // Scan path segments: .prop, [index], [$key]
        while !self.is_at_end() {
            let ch = self.peek();
            if ch == '.' {
                text.push(self.advance()); // .
                while !self.is_at_end() {
                    let c = self.peek();
                    if c.is_alphanumeric() || c == '_' {
                        text.push(self.advance());
                    } else {
                        break;
                    }
                }
            } else if ch == '[' {
                text.push(self.advance()); // [
                while !self.is_at_end() && self.peek() != ']' {
                    text.push(self.advance());
                }
                if !self.is_at_end() {
                    text.push(self.advance()); // ]
                }
            } else {
                break;
            }
        }

        let var_name = if text.len() > 1 {
            text[1..].to_string()
        } else {
            String::new()
        };

        self.emit_with_value(
            TokenKind::Variable,
            &text,
            TokenValue::String(var_name),
        );
        if let Some(tok) = self.tokens.last_mut() {
            tok.column = start_col;
        }

        Ok(())
    }

    fn scan_number(&mut self) -> Result<(), RobinPathError> {
        let start_col = self.column;
        let mut text = String::new();
        let mut has_dot = false;

        // Handle negative sign
        if self.peek() == '-' {
            text.push(self.advance());
        }

        // Handle 0x hex prefix
        if self.peek() == '0' && self.peek_at(1) == Some('x') {
            text.push(self.advance()); // 0
            text.push(self.advance()); // x
            while !self.is_at_end() {
                let ch = self.peek();
                if ch.is_ascii_hexdigit() || ch == '_' {
                    if ch != '_' {
                        text.push(ch);
                    }
                    self.advance();
                } else {
                    break;
                }
            }
            let num: f64 = i64::from_str_radix(&text[2..], 16)
                .map(|n| n as f64)
                .unwrap_or(f64::NAN);
            self.emit_with_value(TokenKind::Number, &text, TokenValue::Number(num));
            if let Some(tok) = self.tokens.last_mut() {
                tok.column = start_col;
            }
            return Ok(());
        }

        // Handle leading dot (.5)
        if self.peek() == '.' {
            text.push('0');
            text.push(self.advance());
            has_dot = true;
        }

        // Integer part
        while !self.is_at_end() {
            let ch = self.peek();
            if ch.is_ascii_digit() {
                text.push(self.advance());
            } else if ch == '_' {
                self.advance(); // skip underscores
            } else {
                break;
            }
        }

        // Decimal part
        if !has_dot && !self.is_at_end() && self.peek() == '.' {
            // Check that next char is a digit (not a property access like 5.toString)
            if self.peek_at(1).is_some_and(|c| c.is_ascii_digit()) {
                text.push(self.advance()); // .
                while !self.is_at_end() {
                    let ch = self.peek();
                    if ch.is_ascii_digit() {
                        text.push(self.advance());
                    } else if ch == '_' {
                        self.advance();
                    } else {
                        break;
                    }
                }
            }
        }

        // Scientific notation
        if !self.is_at_end() && (self.peek() == 'e' || self.peek() == 'E') {
            text.push(self.advance());
            if !self.is_at_end() && (self.peek() == '+' || self.peek() == '-') {
                text.push(self.advance());
            }
            while !self.is_at_end() && self.peek().is_ascii_digit() {
                text.push(self.advance());
            }
        }

        let num: f64 = text.parse().unwrap_or(f64::NAN);
        self.emit_with_value(TokenKind::Number, &text, TokenValue::Number(num));
        if let Some(tok) = self.tokens.last_mut() {
            tok.column = start_col;
        }

        Ok(())
    }

    fn scan_identifier(&mut self) -> Result<(), RobinPathError> {
        let start_col = self.column;
        let mut text = String::new();

        while !self.is_at_end() {
            let ch = self.peek();
            if ch.is_alphanumeric() || ch == '_' {
                text.push(self.advance());
            } else if ch == '.' {
                // Module-qualified: math.add
                // Only treat as dot-identifier if next char is alphabetic
                if self.peek_at(1).is_some_and(|c| c.is_alphabetic() || c == '_') {
                    text.push(self.advance()); // .
                    while !self.is_at_end() {
                        let c = self.peek();
                        if c.is_alphanumeric() || c == '_' {
                            text.push(self.advance());
                        } else {
                            break;
                        }
                    }
                } else {
                    break;
                }
            } else {
                break;
            }
        }

        // Check for keywords
        match text.as_str() {
            "true" => {
                self.emit_with_value(TokenKind::Boolean, "true", TokenValue::Bool(true));
            }
            "false" => {
                self.emit_with_value(TokenKind::Boolean, "false", TokenValue::Bool(false));
            }
            "null" => {
                self.emit(TokenKind::Null, "null");
            }
            "and" => {
                self.emit(TokenKind::And, "and");
            }
            "or" => {
                self.emit(TokenKind::Or, "or");
            }
            "not" => {
                self.emit(TokenKind::Not, "not");
            }
            _ if is_keyword(&text) => {
                self.emit(TokenKind::Keyword, &text);
            }
            _ => {
                self.emit(TokenKind::Identifier, &text);
            }
        }

        if let Some(tok) = self.tokens.last_mut() {
            tok.column = start_col;
        }

        Ok(())
    }

    fn scan_decorator(&mut self) -> Result<(), RobinPathError> {
        let start_col = self.column;
        self.advance(); // @
        let mut name = String::new();
        while !self.is_at_end() {
            let ch = self.peek();
            if ch.is_alphanumeric() || ch == '_' || ch == '.' {
                name.push(self.advance());
            } else {
                break;
            }
        }
        let text = format!("@{}", name);
        self.emit_with_value(
            TokenKind::Decorator,
            &text,
            TokenValue::String(name),
        );
        if let Some(tok) = self.tokens.last_mut() {
            tok.column = start_col;
        }
        Ok(())
    }

    fn check_fence_marker(&self) -> bool {
        // Check for --- at start of line (with possible leading whitespace)
        self.pos < self.source.len()
            && self.source[self.pos] == '-'
            && self.pos + 2 < self.source.len()
            && self.source[self.pos + 1] == '-'
            && self.source[self.pos + 2] == '-'
    }

    fn scan_fence_marker(&mut self) -> Result<(), RobinPathError> {
        let start_col = self.column;
        let mut text = String::new();

        // Consume ---
        for _ in 0..3 {
            text.push(self.advance());
        }

        // Skip whitespace
        while !self.is_at_end() && self.peek() == ' ' {
            text.push(self.advance());
        }

        // Read the rest of the line
        let mut content = String::new();
        while !self.is_at_end() && self.peek() != '\n' && self.peek() != '\r' {
            content.push(self.advance());
        }
        text.push_str(&content);

        let content = content.trim().trim_end_matches('-').trim();

        // Determine type
        if content.starts_with("chunk:") {
            let id = content["chunk:".len()..].trim().to_string();
            self.emit_with_value(
                TokenKind::ChunkMarker,
                &text,
                TokenValue::String(id),
            );
        } else if content.starts_with("cell ") || content.starts_with("cell:") {
            // Cell block: ---cell type id:xxx---
            let cell_info = if content.starts_with("cell:") {
                content["cell:".len()..].trim().to_string()
            } else {
                content["cell ".len()..].trim().to_string()
            };

            // Determine if this is a code cell or raw text cell
            let is_code_cell = cell_info.starts_with("code");

            self.emit_with_value(
                TokenKind::CellOpen,
                &text,
                TokenValue::String(cell_info.clone()),
            );
            if let Some(tok) = self.tokens.last_mut() {
                tok.column = start_col;
            }

            if !is_code_cell {
                // Raw text cell (prompt, schema, etc) — scan until ---end---
                self.scan_raw_text_until_end()?;
            }
            return Ok(());
        } else if content == "end" {
            self.emit(TokenKind::CellClose, &text);
        } else if content == "endcell" {
            self.emit(TokenKind::CellClose, &text);
        } else if content == "prompt" {
            self.emit(TokenKind::PromptOpen, &text);
        } else if content == "endprompt" {
            self.emit(TokenKind::PromptClose, &text);
        } else if content.is_empty() {
            // Bare --- ... --- prompt block
            self.emit(TokenKind::PromptOpen, &text);
            if let Some(tok) = self.tokens.last_mut() {
                tok.column = start_col;
            }
            // Scan raw text until the next bare ---
            self.scan_raw_text_until_bare_fence()?;
            return Ok(());
        } else {
            // Generic fence marker — treat as chunk marker
            self.emit_with_value(
                TokenKind::ChunkMarker,
                &text,
                TokenValue::String(content.to_string()),
            );
        }

        if let Some(tok) = self.tokens.last_mut() {
            tok.column = start_col;
        }

        Ok(())
    }

    fn scan_raw_text_until_end(&mut self) -> Result<(), RobinPathError> {
        // Consume trailing newline after open marker
        if !self.is_at_end() && (self.peek() == '\n' || self.peek() == '\r') {
            if self.peek() == '\r' { self.advance(); }
            if !self.is_at_end() && self.peek() == '\n' { self.advance(); }
        }

        let mut raw_text = String::new();
        let _start_line = self.line;

        while !self.is_at_end() {
            // Check if current line starts with ---end---
            if self.peek() == '-' && self.check_fence_at_pos("---end---") {
                break;
            }
            // Also check trimmed line
            if self.at_line_start_with("---end---") {
                break;
            }
            raw_text.push(self.advance());
        }

        // Trim trailing newline from raw text
        let trimmed = raw_text.trim_end_matches('\n').trim_end_matches('\r');
        if !trimmed.is_empty() {
            self.emit_with_value(
                TokenKind::RawText,
                trimmed,
                TokenValue::String(trimmed.to_string()),
            );
        }

        // Now consume the ---end--- line
        if !self.is_at_end() {
            let mut end_text = String::new();
            while !self.is_at_end() && self.peek() != '\n' && self.peek() != '\r' {
                end_text.push(self.advance());
            }
            self.emit(TokenKind::CellClose, &end_text);
        }

        Ok(())
    }

    fn scan_raw_text_until_bare_fence(&mut self) -> Result<(), RobinPathError> {
        // Consume trailing newline after open marker
        if !self.is_at_end() && (self.peek() == '\n' || self.peek() == '\r') {
            if self.peek() == '\r' { self.advance(); }
            if !self.is_at_end() && self.peek() == '\n' { self.advance(); }
            self.line += 1;
            self.column = 0;
        }

        let mut raw_text = String::new();
        let mut at_line_start = true;

        while !self.is_at_end() {
            // Check if current position is --- at start of a line (possibly indented)
            if at_line_start {
                // Skip whitespace to check for ---
                let mut look = self.pos;
                while look < self.source.len() && self.source[look] == ' ' {
                    look += 1;
                }
                if look + 2 < self.source.len()
                    && self.source[look] == '-'
                    && self.source[look + 1] == '-'
                    && self.source[look + 2] == '-'
                {
                    // Check rest of line is only whitespace or dashes (bare fence)
                    let mut bare = true;
                    let mut j = look + 3;
                    while j < self.source.len()
                        && self.source[j] != '\n'
                        && self.source[j] != '\r'
                    {
                        if self.source[j] != ' ' && self.source[j] != '-' {
                            bare = false;
                            break;
                        }
                        j += 1;
                    }
                    if bare {
                        // Skip the leading whitespace so scan_fence_marker continues from ---
                        while self.pos < look {
                            self.advance();
                        }
                        break;
                    }
                }
            }
            let ch = self.advance();
            raw_text.push(ch);
            if ch == '\n' {
                self.line += 1;
                self.column = 0;
                at_line_start = true;
            } else if ch == '\r' {
                at_line_start = false;
            } else {
                at_line_start = false;
            }
        }

        let trimmed = raw_text.trim_end_matches('\n').trim_end_matches('\r');
        if !trimmed.is_empty() {
            self.emit_with_value(
                TokenKind::RawText,
                trimmed,
                TokenValue::String(trimmed.to_string()),
            );
        }

        // Consume the closing ---
        if !self.is_at_end() {
            let mut end_text = String::new();
            while !self.is_at_end() && self.peek() != '\n' && self.peek() != '\r' {
                end_text.push(self.advance());
            }
            self.emit(TokenKind::PromptClose, &end_text);
        }

        Ok(())
    }

    fn check_fence_at_pos(&self, pattern: &str) -> bool {
        let bytes: Vec<char> = pattern.chars().collect();
        for (i, ch) in bytes.iter().enumerate() {
            if self.pos + i >= self.source.len() || self.source[self.pos + i] != *ch {
                return false;
            }
        }
        true
    }

    fn at_line_start_with(&self, pattern: &str) -> bool {
        // Skip leading whitespace from current position
        let mut p = self.pos;
        while p < self.source.len() && self.source[p] == ' ' {
            p += 1;
        }
        let bytes: Vec<char> = pattern.chars().collect();
        for (i, ch) in bytes.iter().enumerate() {
            if p + i >= self.source.len() || self.source[p + i] != *ch {
                return false;
            }
        }
        true
    }
}