toon-format-rs 0.1.0

use crate::error::{Error, Result};
use crate::lexer::{Lexer, Token};
use crate::value::Value;
use indexmap::IndexMap;

/// Parser for TOON format
pub struct Parser<'a> {
    tokens: Vec<Token>,
    pos: usize,
    #[allow(dead_code)]
    input: &'a str,
}

impl<'a> Parser<'a> {
    /// Creates a new parser from input string
    pub fn new(input: &'a str) -> Result<Self> {
        let mut lexer = Lexer::new(input);
        let tokens = lexer.lex()?;
        Ok(Parser {
            tokens,
            pos: 0,
            input,
        })
    }

    /// Parses the input and returns a Value
    pub fn parse(&mut self) -> Result<Value> {
        self.skip_empty_lines();

        if self.is_eof() {
            return Ok(Value::Object(IndexMap::new()));
        }

        // Check if document starts with an expanded array
        if let Some(Token::Hyphen) = self.peek() {
            return self.parse_expanded_array();
        }

        // Root is always an object
        self.parse_object_at_depth(0)
    }

    /// Returns the current token without consuming it
    fn peek(&self) -> Option<&Token> {
        self.tokens.get(self.pos)
    }

    /// Consumes and returns the next token
    fn next_token(&mut self) -> Option<&Token> {
        let token = self.tokens.get(self.pos);
        if token.is_some() {
            self.pos += 1;
        }
        token
    }

    /// Checks if we're at EOF
    fn is_eof(&self) -> bool {
        matches!(self.peek(), Some(Token::Eof) | None)
    }

    /// Expects a specific token and consumes it
    fn expect(&mut self, expected: &Token) -> Result<()> {
        match self.next_token() {
            Some(token) if token == expected => Ok(()),
            Some(token) => Err(Error::Message(format!(
                "expected {:?}, found {:?}",
                expected, token
            ))),
            None => Err(Error::UnexpectedEof),
        }
    }

    /// Skips newlines and indents (treats them as whitespace)
    fn skip_whitespace(&mut self) {
        while matches!(self.peek(), Some(Token::Newline) | Some(Token::Indent(_))) {
            self.pos += 1;
        }
    }

    /// Skips empty lines (newlines without content)
    fn skip_empty_lines(&mut self) {
        while matches!(self.peek(), Some(Token::Newline)) {
            self.pos += 1;
        }
    }

    /// Gets the indent level at current position (0 if not at indent)
    #[allow(dead_code)]
    fn get_indent(&self) -> usize {
        match self.peek() {
            Some(Token::Indent(n)) => *n,
            _ => 0,
        }
    }

    /// Consumes indent token if present
    fn consume_indent(&mut self) -> usize {
        match self.peek() {
            Some(Token::Indent(n)) => {
                let level = *n;
                self.pos += 1;
                level
            }
            _ => 0,
        }
    }

    /// Parses an object at a given depth level
    fn parse_object_at_depth(&mut self, expected_depth: usize) -> Result<Value> {
        let mut object = IndexMap::new();

        loop {
            self.skip_empty_lines();

            if self.is_eof() {
                break;
            }

            // Check indentation level
            let current_depth = self.consume_indent();

            // If we're at EOF after consuming indent, break
            if self.is_eof() {
                break;
            }

            // If depth is less than expected, we've exited this object
            if current_depth < expected_depth {
                // Put back the indent token if we consumed one
                if current_depth > 0 {
                    self.pos -= 1;
                }
                break;
            }

            // Parse the key
            let key = match self.next_token() {
                Some(Token::Ident(s)) => s.clone(),
                Some(Token::String(s)) => s.clone(),
                Some(token) => {
                    return Err(Error::Message(format!(
                        "expected key, found {:?}",
                        token
                    )))
                }
                None => return Err(Error::UnexpectedEof),
            };

            // Check if this is an array header (key[N]...)
            if let Some(Token::OpenBracket) = self.peek() {
                // Array header
                let arr = self.parse_array_header_rest()?;
                object.insert(key, arr);
            } else {
                // Regular key-value
                self.expect(&Token::Colon)?;
                let value = self.parse_value_after_colon(current_depth)?;
                object.insert(key, value);
            }
        }

        Ok(Value::Object(object))
    }

    /// Parses the rest of an array header after the key (already consumed)
    fn parse_array_header_rest(&mut self) -> Result<Value> {
        // Parse [length]
        self.expect(&Token::OpenBracket)?;
        let length = match self.next_token() {
            Some(Token::Number(n)) => n.parse::<usize>().map_err(|_| Error::InvalidNumber {
                text: n.clone(),
                pos: 0,
            })?,
            Some(token) => {
                return Err(Error::Message(format!(
                    "expected number in array length, found {:?}",
                    token
                )))
            }
            None => return Err(Error::UnexpectedEof),
        };
        self.expect(&Token::CloseBracket)?;

        // Parse optional {fields}
        let fields = if let Some(Token::OpenBrace) = self.peek() {
            self.pos += 1;
            let mut field_names = Vec::new();
            loop {
                match self.next_token() {
                    Some(Token::Ident(s)) => field_names.push(s.clone()),
                    Some(Token::String(s)) => field_names.push(s.clone()),
                    Some(token) => {
                        return Err(Error::Message(format!(
                            "expected field name, found {:?}",
                            token
                        )))
                    }
                    None => return Err(Error::UnexpectedEof),
                }

                match self.peek() {
                    Some(Token::Comma) => self.pos += 1,
                    Some(Token::CloseBrace) => {
                        self.pos += 1;
                        break;
                    }
                    Some(token) => {
                        return Err(Error::Message(format!(
                            "expected comma or }}, found {:?}",
                            token
                        )))
                    }
                    None => return Err(Error::UnexpectedEof),
                }
            }
            Some(field_names)
        } else {
            None
        };

        // Expect colon
        self.expect(&Token::Colon)?;

        // Parse array content
        if let Some(fields) = fields {
            // Tabular array
            self.parse_tabular_rows(&fields, length)
        } else {
            // Inline primitive array
            self.parse_inline_primitives(length)
        }
    }

    /// Parses value after a colon (at a given parent depth)
    fn parse_value_after_colon(&mut self, parent_depth: usize) -> Result<Value> {
        // Skip inline indents only, NOT newlines
        while matches!(self.peek(), Some(Token::Indent(_))) {
            self.pos += 1;
        }

        match self.peek() {
            Some(Token::True) => {
                self.pos += 1;
                Ok(Value::Bool(true))
            }
            Some(Token::False) => {
                self.pos += 1;
                Ok(Value::Bool(false))
            }
            Some(Token::Null) => {
                self.pos += 1;
                Ok(Value::Null)
            }
            Some(Token::Number(n)) => {
                let val = n.clone();
                self.pos += 1;
                Ok(Value::Number(val))
            }
            Some(Token::String(s)) => {
                let val = s.clone();
                self.pos += 1;
                Ok(Value::String(val))
            }
            Some(Token::Ident(s)) => {
                let mut val = s.clone();
                self.pos += 1;
                // Collect consecutive idents/numbers as a multi-word string
                while let Some(Token::Ident(ref w)) | Some(Token::Number(ref w)) = self.peek() {
                    if val == "true" || val == "false" || val == "null" {
                        break;
                    }
                    val.push(' ');
                    val.push_str(w);
                    self.pos += 1;
                }
                Ok(Value::String(val))
            }
            Some(Token::OpenBracket) => self.parse_bracket_array(),
            Some(Token::Hyphen) => self.parse_expanded_array(),
            Some(Token::Newline) => {
                // Value is on the next line - parse nested block
                self.pos += 1;
                self.parse_nested_block(parent_depth + 1)
            }
            Some(Token::Eof) => Ok(Value::Null),
            Some(token) => Err(Error::Message(format!(
                "unexpected token after colon: {:?}",
                token
            ))),
            None => Err(Error::UnexpectedEof),
        }
    }

    /// Parses a nested block at a given depth
    fn parse_nested_block(&mut self, expected_depth: usize) -> Result<Value> {
        self.skip_empty_lines();

        if self.is_eof() {
            return Ok(Value::Null);
        }

        // Check what's at this depth
        match self.peek() {
            Some(Token::Indent(n)) if *n >= expected_depth => {
                self.parse_object_at_depth(expected_depth)
            }
            Some(Token::Hyphen) => {
                // Could be expanded array starting at this depth
                self.parse_expanded_array()
            }
            _ => {
                // Single value
                self.parse_value()
            }
        }
    }

    /// Parses an expanded array with hyphens
    fn parse_expanded_array(&mut self) -> Result<Value> {
        let mut items = Vec::new();

        while let Some(Token::Hyphen) = self.peek() {
            self.pos += 1; // consume hyphen
            let value = self.parse_value()?;
            items.push(value);
            self.skip_whitespace();
        }

        Ok(Value::Array(items))
    }

    /// Parses an inline JSON-like array [1, 2, 3]
    fn parse_bracket_array(&mut self) -> Result<Value> {
        self.expect(&Token::OpenBracket)?;
        let mut values = Vec::new();

        loop {
            self.skip_whitespace();
            match self.peek() {
                Some(Token::CloseBracket) => {
                    self.pos += 1;
                    break;
                }
                _ => {
                    let value = self.parse_value()?;
                    values.push(value);

                    self.skip_whitespace();
                    match self.peek() {
                        Some(Token::Comma) => {
                            self.pos += 1;
                        }
                        Some(Token::CloseBracket) => {
                            self.pos += 1;
                            break;
                        }
                        _ => break,
                    }
                }
            }
        }

        Ok(Value::Array(values))
    }

    /// Parses inline primitive values separated by delimiters
    fn parse_inline_primitives(&mut self, expected_count: usize) -> Result<Value> {
        let mut values = Vec::new();
        let mut count = 0;

        while count < expected_count {
            self.skip_whitespace();

            if self.is_eof() {
                break;
            }

            let value = match self.peek() {
                Some(Token::Number(n)) => {
                    let val = n.clone();
                    self.pos += 1;
                    Value::Number(val)
                }
                Some(Token::String(s)) => {
                    let val = s.clone();
                    self.pos += 1;
                    Value::String(val)
                }
                Some(Token::Ident(s)) => {
                    let mut val = s.clone();
                    self.pos += 1;
                    // Collect consecutive idents/numbers as a multi-word string
                    loop {
                        if let Some(Token::Ident(ref w)) = self.peek() {
                            if val == "true" || val == "false" || val == "null" {
                                break;
                            }
                            val.push(' ');
                            val.push_str(w);
                            self.pos += 1;
                        } else if let Some(Token::Number(ref w)) = self.peek() {
                            if val == "true" || val == "false" || val == "null" {
                                break;
                            }
                            val.push(' ');
                            val.push_str(w);
                            self.pos += 1;
                        } else {
                            break;
                        }
                    }
                    if val == "true" {
                        Value::Bool(true)
                    } else if val == "false" {
                        Value::Bool(false)
                    } else if val == "null" {
                        Value::Null
                    } else {
                        Value::String(val)
                    }
                }
                Some(Token::True) => {
                    self.pos += 1;
                    Value::Bool(true)
                }
                Some(Token::False) => {
                    self.pos += 1;
                    Value::Bool(false)
                }
                Some(Token::Null) => {
                    self.pos += 1;
                    Value::Null
                }
                _ => break,
            };

            values.push(value);
            count += 1;

            // Check for delimiter
            match self.peek() {
                Some(Token::Comma) | Some(Token::Pipe) => {
                    self.pos += 1;
                }
                _ => break,
            }
        }

        if count != expected_count {
            return Err(Error::ArrayLengthMismatch {
                declared: expected_count,
                found: count,
                pos: 0,
            });
        }

        Ok(Value::Array(values))
    }

    /// Parses tabular array rows
    fn parse_tabular_rows(&mut self, fields: &[String], expected_count: usize) -> Result<Value> {
        let mut rows = Vec::new();
        let mut count = 0;

        while count < expected_count {
            self.skip_empty_lines();

            if self.is_eof() {
                break;
            }

            // Check if next line is a row (starts with indent)
            match self.peek() {
                Some(Token::Indent(_)) => {
                    self.consume_indent();
                }
                Some(Token::Ident(_)) | Some(Token::String(_)) | Some(Token::Hyphen) => {
                    // Could be a new key at parent level - stop
                    break;
                }
                _ => {
                    break;
                }
            }

            let mut row = IndexMap::new();
            let mut field_idx = 0;

            while field_idx < fields.len() {
                let value = match self.peek() {
                    Some(Token::Number(n)) => {
                        let val = n.clone();
                        self.pos += 1;
                        Value::Number(val)
                    }
                    Some(Token::String(s)) => {
                        let val = s.clone();
                        self.pos += 1;
                        Value::String(val)
                    }
                    Some(Token::Ident(s)) => {
                        let mut val = s.clone();
                        self.pos += 1;
                        // Collect consecutive idents/numbers as a multi-word string
                        loop {
                            if let Some(Token::Ident(ref w)) = self.peek() {
                                if val == "true" || val == "false" || val == "null" {
                                    break;
                                }
                                val.push(' ');
                                val.push_str(w);
                                self.pos += 1;
                            } else if let Some(Token::Number(ref w)) = self.peek() {
                                if val == "true" || val == "false" || val == "null" {
                                    break;
                                }
                                val.push(' ');
                                val.push_str(w);
                                self.pos += 1;
                            } else {
                                break;
                            }
                        }
                        if val == "true" {
                            Value::Bool(true)
                        } else if val == "false" {
                            Value::Bool(false)
                        } else if val == "null" {
                            Value::Null
                        } else {
                            Value::String(val)
                        }
                    }
                    Some(Token::True) => {
                        self.pos += 1;
                        Value::Bool(true)
                    }
                    Some(Token::False) => {
                        self.pos += 1;
                        Value::Bool(false)
                    }
                    Some(Token::Null) => {
                        self.pos += 1;
                        Value::Null
                    }
                    _ => break,
                };

                row.insert(fields[field_idx].clone(), value);
                field_idx += 1;

                // Check for delimiter
                match self.peek() {
                    Some(Token::Comma) | Some(Token::Pipe) => {
                        self.pos += 1;
                    }
                    _ => break,
                }
            }

            rows.push(Value::Object(row));
            count += 1;
        }

        if count != expected_count {
            return Err(Error::ArrayLengthMismatch {
                declared: expected_count,
                found: count,
                pos: 0,
            });
        }

        Ok(Value::Array(rows))
    }

    /// Parses a single value
    fn parse_value(&mut self) -> Result<Value> {
        self.skip_whitespace();

        match self.peek() {
            Some(Token::True) => {
                self.pos += 1;
                Ok(Value::Bool(true))
            }
            Some(Token::False) => {
                self.pos += 1;
                Ok(Value::Bool(false))
            }
            Some(Token::Null) => {
                self.pos += 1;
                Ok(Value::Null)
            }
            Some(Token::Number(n)) => {
                let val = n.clone();
                self.pos += 1;
                Ok(Value::Number(val))
            }
            Some(Token::String(s)) => {
                let val = s.clone();
                self.pos += 1;
                Ok(Value::String(val))
            }
            Some(Token::Ident(s)) => {
                let val = s.clone();
                self.pos += 1;
                Ok(Value::String(val))
            }
            Some(Token::OpenBracket) => self.parse_bracket_array(),
            Some(Token::Hyphen) => self.parse_expanded_array(),
            Some(token) => Err(Error::Message(format!(
                "unexpected token in value: {:?}",
                token
            ))),
            None => Err(Error::UnexpectedEof),
        }
    }
}

/// Convenience function to parse TOON string into Value
pub fn parse(input: &str) -> Result<Value> {
    let mut parser = Parser::new(input)?;
    parser.parse()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_simple_object() {
        let input = "id: 123\nname: Alice\nactive: true";
        let value = parse(input).unwrap();

        assert!(value.is_object());
        assert_eq!(value.get("id").unwrap().as_i64(), Some(123));
        assert_eq!(value.get("name").unwrap().as_str(), Some("Alice"));
        assert_eq!(value.get("active").unwrap().as_bool(), Some(true));
    }

    #[test]
    fn test_parse_nested_object() {
        let input = "user:\n  id: 1\n  name: Alice";
        let value = parse(input).unwrap();

        assert!(value.is_object());
        let user = value.get("user").unwrap();
        assert!(user.is_object());
        assert_eq!(user.get("id").unwrap().as_i64(), Some(1));
        assert_eq!(user.get("name").unwrap().as_str(), Some("Alice"));
    }

    #[test]
    fn test_parse_array_inline() {
        let input = "tags[3]: foo,bar,baz";
        let value = parse(input).unwrap();

        assert!(value.is_object());
        let arr = value.get("tags").unwrap();
        assert!(arr.is_array());
        assert_eq!(arr.as_array().unwrap().len(), 3);
        assert_eq!(arr.as_array().unwrap()[0].as_str(), Some("foo"));
        assert_eq!(arr.as_array().unwrap()[1].as_str(), Some("bar"));
        assert_eq!(arr.as_array().unwrap()[2].as_str(), Some("baz"));
    }

    #[test]
    fn test_parse_tabular_array() {
        let input = "users[2]{id,name,role}:\n  1,Alice,admin\n  2,Bob,user";
        let value = parse(input).unwrap();

        assert!(value.is_object());
        let arr = value.get("users").unwrap();
        assert!(arr.is_array());
        assert_eq!(arr.as_array().unwrap().len(), 2);

        let row1 = arr.as_array().unwrap()[0].as_object().unwrap();
        assert_eq!(row1.get("id").unwrap().as_i64(), Some(1));
        assert_eq!(row1.get("name").unwrap().as_str(), Some("Alice"));
        assert_eq!(row1.get("role").unwrap().as_str(), Some("admin"));

        let row2 = arr.as_array().unwrap()[1].as_object().unwrap();
        assert_eq!(row2.get("id").unwrap().as_i64(), Some(2));
        assert_eq!(row2.get("name").unwrap().as_str(), Some("Bob"));
        assert_eq!(row2.get("role").unwrap().as_str(), Some("user"));
    }

    #[test]
    fn test_parse_expanded_array() {
        let input = "- first\n- second\n- third";
        let value = parse(input).unwrap();

        assert!(value.is_array());
        let arr = value.as_array().unwrap();
        assert_eq!(arr.len(), 3);
        assert_eq!(arr[0].as_str(), Some("first"));
        assert_eq!(arr[1].as_str(), Some("second"));
        assert_eq!(arr[2].as_str(), Some("third"));
    }

    #[test]
    fn test_parse_complex_document() {
        let input = r#"context:
  task: Our favorite hikes together
  location: Boulder
  season: spring_2025
friends[3]: ana,luis,sam
users[2]{id,name,role}:
  1,Alice,admin
  2,Bob,user"#;

        let value = parse(input).unwrap();
        assert!(value.is_object());

        let context = value.get("context").unwrap();
        assert!(context.is_object());
        assert_eq!(
            context.get("task").unwrap().as_str(),
            Some("Our favorite hikes together")
        );

        let friends = value.get("friends").unwrap();
        assert!(friends.is_array());
        assert_eq!(friends.as_array().unwrap().len(), 3);

        let users = value.get("users").unwrap();
        assert!(users.is_array());
        let users_arr = users.as_array().unwrap();
        assert_eq!(users_arr.len(), 2);

        let user1 = users_arr[0].as_object().unwrap();
        assert_eq!(user1.get("name").unwrap().as_str(), Some("Alice"));
        assert_eq!(user1.get("role").unwrap().as_str(), Some("admin"));
    }
}