libconfig/

de.rs

//! Deserializer for libconfig format

use std::cell::Cell;

use serde::Deserialize;
use serde::de::{self, DeserializeSeed, IntoDeserializer, MapAccess, SeqAccess, Visitor};

use crate::error::{Error, Result};

thread_local! {
    /// Tracks whether the current sequence being deserialized is a list `(...)`.
    /// Used by ValueVisitor to distinguish Array from List.
    static IS_LIST_CONTEXT: Cell<bool> = const { Cell::new(false) };
}

/// Returns true if the current deserialization context is a list.
pub(crate) fn is_list_context() -> bool {
    IS_LIST_CONTEXT.with(|c| c.get())
}

/// A structure that deserializes libconfig format into Rust values
pub struct Deserializer<'de> {
    input: &'de str,
}

impl<'de> Deserializer<'de> {
    /// Create a deserializer from a `&str`
    pub fn from_str(input: &'de str) -> Self {
        Deserializer { input }
    }

    /// Look at the first character without consuming it
    fn peek_char(&self) -> Result<char> {
        self.input.chars().next().ok_or(Error::Eof)
    }

    /// Consume and return the next character
    fn next_char(&mut self) -> Result<char> {
        let ch = self.peek_char()?;
        self.input = &self.input[ch.len_utf8()..];
        Ok(ch)
    }

    /// Skip whitespace and comments
    fn skip_whitespace(&mut self) {
        loop {
            // Skip whitespace
            self.input = self.input.trim_start();

            if self.input.is_empty() {
                return;
            }

            // Check for comments
            if self.input.starts_with('#') {
                // Skip to end of line
                if let Some(pos) = self.input.find('\n') {
                    self.input = &self.input[pos + 1..];
                } else {
                    self.input = "";
                    return;
                }
            } else if self.input.starts_with("//") {
                // Skip to end of line
                if let Some(pos) = self.input.find('\n') {
                    self.input = &self.input[pos + 1..];
                } else {
                    self.input = "";
                    return;
                }
            } else if self.input.starts_with("/*") {
                // Skip to */
                if let Some(pos) = self.input.find("*/") {
                    self.input = &self.input[pos + 2..];
                } else {
                    self.input = "";
                    return;
                }
            } else {
                return;
            }
        }
    }

    /// Check if the input starts with an identifier followed by '=' or ':',
    /// indicating the start of a setting in an implicit group.
    /// This is used by `deserialize_any` to disambiguate between booleans
    /// (true/false) and identifiers that happen to start with t/T/f/F.
    fn is_implicit_group_start(&self) -> bool {
        let input = self.input;

        // Skip the identifier: [A-Za-z\*][-A-Za-z0-9_\*]*
        let mut len = 0;
        let mut first = true;
        for ch in input.chars() {
            if first {
                if ch.is_ascii_alphabetic() || ch == '*' {
                    len += ch.len_utf8();
                    first = false;
                } else {
                    return false;
                }
            } else if ch.is_alphanumeric() || ch == '_' || ch == '-' || ch == '*' {
                len += ch.len_utf8();
            } else {
                break;
            }
        }

        if len == 0 {
            return false;
        }

        // Skip whitespace after identifier
        let rest = input[len..].trim_start();

        // Check for '=' or ':'
        matches!(rest.chars().next(), Some('=' | ':'))
    }

    /// Parse a boolean value (case-insensitive per libconfig spec)
    fn parse_bool(&mut self) -> Result<bool> {
        self.skip_whitespace();
        if self.input.len() >= 4
            && self.input[..4].eq_ignore_ascii_case("true")
            && !self.input[4..]
                .chars()
                .next()
                .map_or(false, |c| c.is_alphanumeric() || c == '_')
        {
            self.input = &self.input[4..];
            Ok(true)
        } else if self.input.len() >= 5
            && self.input[..5].eq_ignore_ascii_case("false")
            && !self.input[5..]
                .chars()
                .next()
                .map_or(false, |c| c.is_alphanumeric() || c == '_')
        {
            self.input = &self.input[5..];
            Ok(false)
        } else {
            Err(Error::ExpectedBoolean)
        }
    }

    /// Parse an identifier (setting name)
    /// Per spec: names must match `[A-Za-z*][-A-Za-z0-9_*]*`
    fn parse_identifier(&mut self) -> Result<&'de str> {
        self.skip_whitespace();
        let start = self.input;
        let mut len = 0;
        let mut first = true;

        for ch in self.input.chars() {
            if first {
                if ch.is_ascii_alphabetic() || ch == '*' {
                    len += ch.len_utf8();
                    first = false;
                } else {
                    break;
                }
            } else if ch.is_alphanumeric() || ch == '_' || ch == '-' || ch == '*' {
                len += ch.len_utf8();
            } else {
                break;
            }
        }

        if len == 0 {
            return Err(Error::ExpectedIdentifier);
        }

        let ident = &start[..len];
        self.input = &self.input[len..];
        Ok(ident)
    }

    /// Parse a single quoted string (without adjacent concatenation)
    fn parse_single_string(&mut self) -> Result<String> {
        if self.next_char()? != '"' {
            return Err(Error::ExpectedString);
        }

        let mut result = String::new();
        let mut escape = false;

        loop {
            if self.input.is_empty() {
                return Err(Error::Eof);
            }

            let ch = self.next_char()?;

            if escape {
                match ch {
                    '"' => result.push('"'),
                    '\\' => result.push('\\'),
                    'n' => result.push('\n'),
                    'r' => result.push('\r'),
                    't' => result.push('\t'),
                    'f' => result.push('\x0C'),
                    'b' => result.push('\x08'),
                    'v' => result.push('\x0B'),
                    'a' => result.push('\x07'),
                    'x' => {
                        // Parse hex escape \xNN
                        if self.input.len() < 2 {
                            return Err(Error::InvalidEscape);
                        }
                        let hex = &self.input[..2];
                        if let Ok(byte) = u8::from_str_radix(hex, 16) {
                            result.push(byte as char);
                            self.input = &self.input[2..];
                        } else {
                            return Err(Error::InvalidEscape);
                        }
                    }
                    _ => return Err(Error::InvalidEscape),
                }
                escape = false;
            } else if ch == '\\' {
                escape = true;
            } else if ch == '"' {
                break;
            } else {
                result.push(ch);
            }
        }

        Ok(result)
    }

    /// Parse a string value with adjacent string concatenation
    /// Per spec: "hello" " world" => "hello world"
    fn parse_string(&mut self) -> Result<String> {
        self.skip_whitespace();
        let mut result = self.parse_single_string()?;

        // Check for adjacent strings (concatenation)
        loop {
            self.skip_whitespace();
            if self.input.starts_with('"') {
                result.push_str(&self.parse_single_string()?);
            } else {
                break;
            }
        }

        Ok(result)
    }

    /// Parse a number (integer or float)
    fn parse_number(&mut self) -> Result<Number> {
        self.skip_whitespace();
        let start = self.input;
        let mut len = 0;
        let mut is_float = false;
        let mut is_long = false;
        let mut is_hex = false;
        let mut is_binary = false;
        let mut is_octal = false;
        let mut has_sign = false;

        // Check for sign
        if let Some(ch) = self.input.chars().next() {
            if ch == '-' || ch == '+' {
                has_sign = true;
                len += 1;
            }
        }

        // Check for leading decimal point (e.g. .5)
        if self.input[len..].starts_with('.') {
            is_float = true;
            len += 1;
        }
        // Check for hex (0x), binary (0b), or octal (0o/0q) — no sign allowed
        else if !has_sign
            && (self.input[len..].starts_with("0x") || self.input[len..].starts_with("0X"))
        {
            is_hex = true;
            len += 2;
        } else if !has_sign
            && (self.input[len..].starts_with("0b") || self.input[len..].starts_with("0B"))
        {
            is_binary = true;
            len += 2;
        } else if !has_sign
            && (self.input[len..].starts_with("0o")
                || self.input[len..].starts_with("0O")
                || self.input[len..].starts_with("0q")
                || self.input[len..].starts_with("0Q"))
        {
            is_octal = true;
            len += 2;
        }

        // Parse digits
        let mut digit_count = 0usize;
        for ch in self.input[len..].chars() {
            if is_hex && ch.is_ascii_hexdigit() {
                len += ch.len_utf8();
                digit_count += 1;
            } else if is_binary && (ch == '0' || ch == '1') {
                len += ch.len_utf8();
                digit_count += 1;
            } else if is_octal && ch.is_digit(8) {
                len += ch.len_utf8();
                digit_count += 1;
            } else if !is_hex && !is_binary && !is_octal && ch.is_ascii_digit() {
                len += ch.len_utf8();
                digit_count += 1;
            } else if ch == '.' && !is_hex && !is_binary && !is_octal && !is_float {
                is_float = true;
                len += ch.len_utf8();
            } else if (ch == 'e' || ch == 'E') && !is_hex && !is_binary && !is_octal {
                is_float = true;
                len += ch.len_utf8();
                // Check for sign after exponent
                if let Some(next_ch) = self.input[len..].chars().next() {
                    if next_ch == '+' || next_ch == '-' {
                        len += 1;
                    }
                }
            } else if ch == 'L' {
                is_long = true;
                len += ch.len_utf8();
                break;
            } else {
                break;
            }
        }

        if len == 0
            || (len == 1 && has_sign)
            || (is_float && digit_count == 0)
            || ((is_hex || is_binary || is_octal) && digit_count == 0)
        {
            return Err(Error::ExpectedInteger);
        }

        let num_str = &start[..len];
        self.input = &self.input[len..];

        if is_float {
            let val = num_str.parse::<f64>().map_err(|_| Error::InvalidNumber)?;
            Ok(Number::Float(val))
        } else if is_hex {
            let hex_str = num_str
                .trim_start_matches("0x")
                .trim_start_matches("0X")
                .trim_end_matches('L');
            let val = i64::from_str_radix(hex_str, 16).map_err(|_| Error::InvalidNumber)?;
            if is_long || digit_count > 8 {
                Ok(Number::I64(val))
            } else {
                Ok(Number::I32(val as i32))
            }
        } else if is_binary {
            let bin_str = num_str
                .trim_start_matches("0b")
                .trim_start_matches("0B")
                .trim_end_matches('L');
            let val = i64::from_str_radix(bin_str, 2).map_err(|_| Error::InvalidNumber)?;
            if is_long || digit_count > 32 {
                Ok(Number::I64(val))
            } else {
                Ok(Number::I32(val as i32))
            }
        } else if is_octal {
            let oct_str = num_str
                .trim_start_matches("0o")
                .trim_start_matches("0O")
                .trim_start_matches("0q")
                .trim_start_matches("0Q")
                .trim_end_matches('L');
            let val = i64::from_str_radix(oct_str, 8).map_err(|_| Error::InvalidNumber)?;
            if is_long || digit_count > 10 {
                Ok(Number::I64(val))
            } else {
                Ok(Number::I32(val as i32))
            }
        } else {
            let trimmed = num_str.trim_end_matches('L');
            if is_long {
                let val = trimmed.parse::<i64>().map_err(|_| Error::InvalidNumber)?;
                Ok(Number::I64(val))
            } else {
                // Auto-promote to i64 if value exceeds i32 range
                match trimmed.parse::<i32>() {
                    Ok(val) => Ok(Number::I32(val)),
                    Err(_) => {
                        let val = trimmed.parse::<i64>().map_err(|_| Error::InvalidNumber)?;
                        Ok(Number::I64(val))
                    }
                }
            }
        }
    }
}

/// Deserialize an instance of type `T` from a string of libconfig text
pub fn from_str<'a, T>(s: &'a str) -> Result<T>
where
    T: Deserialize<'a>,
{
    let mut deserializer = Deserializer::from_str(s);
    let t = T::deserialize(&mut deserializer)?;
    deserializer.skip_whitespace();
    if deserializer.input.is_empty() {
        Ok(t)
    } else {
        Err(Error::TrailingCharacters)
    }
}

#[derive(Debug, Clone)]
enum Number {
    I32(i32),
    I64(i64),
    Float(f64),
}

impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
    type Error = Error;

    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        self.skip_whitespace();
        match self.peek_char()? {
            't' | 'T' | 'f' | 'F' => {
                // Could be a boolean OR the start of an identifier in an implicit group.
                // Look ahead: if this is an identifier followed by '=' or ':', it's a setting.
                if self.is_implicit_group_start() {
                    visitor.visit_map(ImplicitGroupAccess::new(self))
                } else {
                    self.deserialize_bool(visitor)
                }
            }
            '"' => self.deserialize_string(visitor),
            '[' => self.deserialize_seq(visitor),
            '(' => self.deserialize_seq(visitor), // Lists are treated as sequences
            '{' => self.deserialize_map(visitor),
            '-' | '+' | '0'..='9' | '.' => {
                // Try to parse as number
                let num = self.parse_number()?;
                match num {
                    Number::I32(v) => visitor.visit_i32(v),
                    Number::I64(v) => visitor.visit_i64(v),
                    Number::Float(v) => visitor.visit_f64(v),
                }
            }
            c if c.is_ascii_alphabetic() || c == '*' => {
                // Starts with a letter or '*' — must be an implicit group setting
                visitor.visit_map(ImplicitGroupAccess::new(self))
            }
            _ => Err(Error::Syntax),
        }
    }

    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        visitor.visit_bool(self.parse_bool()?)
    }

    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        let num = self.parse_number()?;
        match num {
            Number::I32(v) => visitor.visit_i8(v as i8),
            Number::I64(v) => visitor.visit_i8(v as i8),
            Number::Float(v) => visitor.visit_i8(v as i8),
        }
    }

    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        let num = self.parse_number()?;
        match num {
            Number::I32(v) => visitor.visit_i16(v as i16),
            Number::I64(v) => visitor.visit_i16(v as i16),
            Number::Float(v) => visitor.visit_i16(v as i16),
        }
    }

    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        let num = self.parse_number()?;
        match num {
            Number::I32(v) => visitor.visit_i32(v),
            Number::I64(v) => visitor.visit_i32(v as i32),
            Number::Float(v) => visitor.visit_i32(v as i32),
        }
    }

    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        let num = self.parse_number()?;
        match num {
            Number::I32(v) => visitor.visit_i64(v as i64),
            Number::I64(v) => visitor.visit_i64(v),
            Number::Float(v) => visitor.visit_i64(v as i64),
        }
    }

    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        let num = self.parse_number()?;
        match num {
            Number::I32(v) => visitor.visit_u8(v as u8),
            Number::I64(v) => visitor.visit_u8(v as u8),
            Number::Float(v) => visitor.visit_u8(v as u8),
        }
    }

    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        let num = self.parse_number()?;
        match num {
            Number::I32(v) => visitor.visit_u16(v as u16),
            Number::I64(v) => visitor.visit_u16(v as u16),
            Number::Float(v) => visitor.visit_u16(v as u16),
        }
    }

    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        let num = self.parse_number()?;
        match num {
            Number::I32(v) => visitor.visit_u32(v as u32),
            Number::I64(v) => visitor.visit_u32(v as u32),
            Number::Float(v) => visitor.visit_u32(v as u32),
        }
    }

    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        let num = self.parse_number()?;
        match num {
            Number::I32(v) => visitor.visit_u64(v as u64),
            Number::I64(v) => visitor.visit_u64(v as u64),
            Number::Float(v) => visitor.visit_u64(v as u64),
        }
    }

    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        let num = self.parse_number()?;
        match num {
            Number::I32(v) => visitor.visit_f32(v as f32),
            Number::I64(v) => visitor.visit_f32(v as f32),
            Number::Float(v) => visitor.visit_f32(v as f32),
        }
    }

    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        let num = self.parse_number()?;
        match num {
            Number::I32(v) => visitor.visit_f64(v as f64),
            Number::I64(v) => visitor.visit_f64(v as f64),
            Number::Float(v) => visitor.visit_f64(v),
        }
    }

    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        let s = self.parse_string()?;
        let mut chars = s.chars();
        let ch = chars.next().ok_or(Error::ExpectedString)?;
        if chars.next().is_some() {
            return Err(Error::ExpectedString);
        }
        visitor.visit_char(ch)
    }

    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        self.skip_whitespace();
        // Check if it's a quoted string or an identifier (for map keys)
        if self.peek_char()? == '"' {
            visitor.visit_string(self.parse_string()?)
        } else {
            // It's an identifier (unquoted)
            visitor.visit_str(self.parse_identifier()?)
        }
    }

    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        self.skip_whitespace();
        // Check if it's a quoted string or an identifier (for map keys)
        if self.peek_char()? == '"' {
            visitor.visit_string(self.parse_string()?)
        } else {
            // It's an identifier (unquoted)
            visitor.visit_string(self.parse_identifier()?.to_string())
        }
    }

    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        self.deserialize_seq(visitor)
    }

    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        self.deserialize_seq(visitor)
    }

    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        visitor.visit_some(self)
    }

    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        visitor.visit_unit()
    }

    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        self.deserialize_unit(visitor)
    }

    fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        visitor.visit_newtype_struct(self)
    }

    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        self.skip_whitespace();
        let ch = self.peek_char()?;

        if ch == '[' {
            self.next_char()?;
            IS_LIST_CONTEXT.with(|c| c.set(false));
            let value = visitor.visit_seq(ArrayAccess::new(self, ']', false))?;
            self.skip_whitespace();
            if self.next_char()? == ']' {
                Ok(value)
            } else {
                Err(Error::ExpectedArrayEnd)
            }
        } else if ch == '(' {
            self.next_char()?;
            IS_LIST_CONTEXT.with(|c| c.set(true));
            let value = visitor.visit_seq(ArrayAccess::new(self, ')', true))?;
            self.skip_whitespace();
            if self.next_char()? == ')' {
                Ok(value)
            } else {
                Err(Error::ExpectedListEnd)
            }
        } else {
            Err(Error::ExpectedArray)
        }
    }

    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        self.deserialize_seq(visitor)
    }

    fn deserialize_tuple_struct<V>(
        self,
        _name: &'static str,
        _len: usize,
        visitor: V,
    ) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        self.deserialize_seq(visitor)
    }

    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        self.skip_whitespace();
        if self.next_char()? == '{' {
            let value = visitor.visit_map(GroupAccess::new(self))?;
            self.skip_whitespace();
            if self.next_char()? == '}' {
                Ok(value)
            } else {
                Err(Error::ExpectedGroupEnd)
            }
        } else {
            Err(Error::ExpectedGroup)
        }
    }

    fn deserialize_struct<V>(
        self,
        _name: &'static str,
        _fields: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        self.skip_whitespace();
        // Check if the struct is wrapped in braces or is a top-level implicit group
        if self.peek_char()? == '{' {
            self.deserialize_map(visitor)
        } else {
            // Top-level struct without explicit braces - treat as implicit group
            let value = visitor.visit_map(ImplicitGroupAccess::new(self))?;
            Ok(value)
        }
    }

    fn deserialize_enum<V>(
        self,
        _name: &'static str,
        _variants: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        self.skip_whitespace();
        if self.peek_char()? == '"' {
            // Unit variant
            visitor.visit_enum(self.parse_string()?.into_deserializer())
        } else {
            // Other variant types - not fully supported yet
            Err(Error::TypeNotSupported("complex enum variants".to_string()))
        }
    }

    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        visitor.visit_str(self.parse_identifier()?)
    }

    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        self.deserialize_any(visitor)
    }
}

struct ArrayAccess<'a, 'de: 'a> {
    de: &'a mut Deserializer<'de>,
    first: bool,
    end_char: char,
    is_list: bool,
}

impl<'a, 'de> ArrayAccess<'a, 'de> {
    fn new(de: &'a mut Deserializer<'de>, end_char: char, is_list: bool) -> Self {
        ArrayAccess {
            de,
            first: true,
            end_char,
            is_list,
        }
    }
}

impl<'de, 'a> SeqAccess<'de> for ArrayAccess<'a, 'de> {
    type Error = Error;

    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
    where
        T: DeserializeSeed<'de>,
    {
        self.de.skip_whitespace();

        // Check if we're at the end
        if self.de.peek_char()? == self.end_char {
            return Ok(None);
        }

        // Require comma between elements (except first)
        if !self.first {
            if self.de.peek_char()? == ',' {
                self.de.next_char()?;
                self.de.skip_whitespace();
                // Check for trailing comma
                if self.de.peek_char()? == self.end_char {
                    return Ok(None);
                }
            } else {
                return Err(Error::ExpectedArrayComma);
            }
        }
        self.first = false;

        // Set thread-local so ValueVisitor can distinguish Array vs List
        IS_LIST_CONTEXT.with(|c| c.set(self.is_list));

        seed.deserialize(&mut *self.de).map(Some)
    }
}

struct GroupAccess<'a, 'de: 'a> {
    de: &'a mut Deserializer<'de>,
    first: bool,
}

impl<'a, 'de> GroupAccess<'a, 'de> {
    fn new(de: &'a mut Deserializer<'de>) -> Self {
        GroupAccess { de, first: true }
    }
}

struct ImplicitGroupAccess<'a, 'de: 'a> {
    de: &'a mut Deserializer<'de>,
    first: bool,
}

impl<'a, 'de> ImplicitGroupAccess<'a, 'de> {
    fn new(de: &'a mut Deserializer<'de>) -> Self {
        ImplicitGroupAccess { de, first: true }
    }
}

impl<'de, 'a> MapAccess<'de> for GroupAccess<'a, 'de> {
    type Error = Error;

    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
    where
        K: DeserializeSeed<'de>,
    {
        self.de.skip_whitespace();

        // Check if we're at the end
        if self.de.peek_char()? == '}' {
            return Ok(None);
        }

        // Require semicolon or comma between settings (except first)
        if !self.first {
            let ch = self.de.peek_char()?;
            if ch == ';' || ch == ',' {
                self.de.next_char()?;
                self.de.skip_whitespace();
                // Check for trailing separator
                if self.de.peek_char()? == '}' {
                    return Ok(None);
                }
            }
            // Semicolons are optional, so don't error if missing
        }
        self.first = false;

        seed.deserialize(&mut *self.de).map(Some)
    }

    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
    where
        V: DeserializeSeed<'de>,
    {
        self.de.skip_whitespace();

        // Expect '=' or ':'
        let ch = self.de.next_char()?;
        if ch != '=' && ch != ':' {
            return Err(Error::ExpectedEquals);
        }

        seed.deserialize(&mut *self.de)
    }
}

impl<'de, 'a> MapAccess<'de> for ImplicitGroupAccess<'a, 'de> {
    type Error = Error;

    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
    where
        K: DeserializeSeed<'de>,
    {
        self.de.skip_whitespace();

        // Check if we're at the end (end of input)
        if self.de.input.is_empty() {
            return Ok(None);
        }

        // Require semicolon or comma between settings (except first)
        if !self.first {
            let ch = self.de.peek_char()?;
            if ch == ';' || ch == ',' {
                self.de.next_char()?;
                self.de.skip_whitespace();
                // Check for trailing separator
                if self.de.input.is_empty() {
                    return Ok(None);
                }
            }
            // Semicolons are optional, so don't error if missing
        }
        self.first = false;

        seed.deserialize(&mut *self.de).map(Some)
    }

    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
    where
        V: DeserializeSeed<'de>,
    {
        self.de.skip_whitespace();

        // Expect '=' or ':'
        let ch = self.de.next_char()?;
        if ch != '=' && ch != ':' {
            return Err(Error::ExpectedEquals);
        }

        seed.deserialize(&mut *self.de)
    }
}

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

    #[test]
    fn test_deserialize_primitives() {
        assert_eq!(from_str::<u32>("42").unwrap(), 42);
        assert_eq!(from_str::<i64>("42L").unwrap(), 42);
        assert_eq!(from_str::<f64>("3.14").unwrap(), 3.14);
        assert_eq!(from_str::<bool>("true").unwrap(), true);
        assert_eq!(from_str::<String>("\"hello\"").unwrap(), "hello");
    }

    #[test]
    fn test_deserialize_array() {
        let arr: Vec<i32> = from_str("[1, 2, 3]").unwrap();
        assert_eq!(arr, vec![1, 2, 3]);
    }

    #[test]
    fn test_deserialize_struct() {
        #[derive(Debug, Deserialize, PartialEq)]
        struct Test {
            a: i32,
            b: String,
        }

        let input = r#"{ a = 42; b = "hello"; }"#;
        let result: Test = from_str(input).unwrap();
        assert_eq!(
            result,
            Test {
                a: 42,
                b: "hello".to_string()
            }
        );
    }

    #[test]
    fn test_deserialize_with_comments() {
        let input = r#"
            # This is a comment
            {
                // Another comment
                a = 42; /* inline comment */
                b = "hello";
            }
        "#;

        #[derive(Debug, Deserialize, PartialEq)]
        struct Test {
            a: i32,
            b: String,
        }

        let result: Test = from_str(input).unwrap();
        assert_eq!(
            result,
            Test {
                a: 42,
                b: "hello".to_string()
            }
        );
    }

    #[test]
    fn test_case_insensitive_booleans() {
        assert_eq!(from_str::<bool>("true").unwrap(), true);
        assert_eq!(from_str::<bool>("True").unwrap(), true);
        assert_eq!(from_str::<bool>("TRUE").unwrap(), true);
        assert_eq!(from_str::<bool>("false").unwrap(), false);
        assert_eq!(from_str::<bool>("False").unwrap(), false);
        assert_eq!(from_str::<bool>("FALSE").unwrap(), false);
        assert_eq!(from_str::<bool>("FaLsE").unwrap(), false);
    }

    #[test]
    fn test_bool_word_boundary() {
        // "trueblah" should not parse as bool true
        assert!(from_str::<bool>("trueblah").is_err());
        assert!(from_str::<bool>("falsehood").is_err());
    }

    #[test]
    fn test_adjacent_string_concatenation() {
        let result: String = from_str(r#""hello" " world""#).unwrap();
        assert_eq!(result, "hello world");

        let result: String = from_str(r#""a" "b" "c""#).unwrap();
        assert_eq!(result, "abc");
    }

    #[test]
    fn test_integer_auto_promotion() {
        // Value exceeding i32 range should auto-promote to i64
        let val: i64 = from_str("3000000000").unwrap();
        assert_eq!(val, 3_000_000_000i64);
    }

    #[test]
    fn test_hex_binary_octal() {
        assert_eq!(from_str::<i32>("0xFF").unwrap(), 255);
        assert_eq!(from_str::<i32>("0b1010").unwrap(), 10);
        assert_eq!(from_str::<i32>("0o17").unwrap(), 15);
        assert_eq!(from_str::<i32>("0q17").unwrap(), 15);
    }

    #[test]
    fn test_hex_auto_promotion_by_digit_count() {
        // 9+ hex digits should auto-promote to i64
        let val: i64 = from_str("0x1FFFFFFFF").unwrap();
        assert_eq!(val, 0x1FFFFFFFFi64);
    }

    #[test]
    fn test_float_leading_dot() {
        let val: f64 = from_str(".5").unwrap();
        assert_eq!(val, 0.5);
    }

    #[test]
    fn test_list_deserialization() {
        let arr: Vec<i32> = from_str("(1, 2, 3)").unwrap();
        assert_eq!(arr, vec![1, 2, 3]);
    }

    #[test]
    fn test_implicit_group_as_value() {
        use crate::Value;

        let raw_string = r#"
            title = "My HTTP server";
            listen_ports = [ 80, 443 ];
            misc = {
                owner = "Chuck Norris";
                location = "CA";
                contact = {
                    phone = "415-256-9999";
                    emails = ["chuck@norris.com", "chuck.norris@gmail.com"];
                };
            };"#;

        let parsed_value: Value = from_str(raw_string).expect("Failed to parse value");
        assert_eq!(parsed_value["title"], "My HTTP server");
        assert_eq!(parsed_value["listen_ports"][0], 80);
        assert_eq!(parsed_value["listen_ports"][1], 443);
        assert_eq!(parsed_value["misc"]["owner"], "Chuck Norris");
        assert_eq!(parsed_value["misc"]["contact"]["phone"], "415-256-9999");
    }

    #[test]
    fn test_implicit_group_bool_key() {
        // Identifiers starting with t/f should work as setting names
        use crate::Value;

        let input = r#"flag = true; total = 100;"#;
        let v: Value = from_str(input).expect("Failed to parse");
        assert_eq!(v["flag"], true);
        assert_eq!(v["total"], 100);
    }

    #[test]
    fn test_standalone_bool_still_works() {
        // Plain booleans without '=' should still parse as booleans
        assert_eq!(from_str::<bool>("true").unwrap(), true);
        assert_eq!(from_str::<bool>("false").unwrap(), false);

        use crate::Value;
        let v: Value = from_str("true").unwrap();
        assert_eq!(v, Value::Bool(true));

        let v: Value = from_str("false").unwrap();
        assert_eq!(v, Value::Bool(false));
    }

    #[test]
    fn test_optional_semicolons() {
        #[derive(Debug, Deserialize, PartialEq)]
        struct Test {
            a: i32,
            b: i32,
            c: i32,
        }

        // With semicolons
        let result: Test = from_str(r#"{ a = 1; b = 2; c = 3; }"#).unwrap();
        assert_eq!(result, Test { a: 1, b: 2, c: 3 });

        // Without semicolons (settings separated only by whitespace)
        let result: Test = from_str("{ a = 1\n b = 2\n c = 3 }").unwrap();
        assert_eq!(result, Test { a: 1, b: 2, c: 3 });

        // Mixed: some with, some without
        let result: Test = from_str("{ a = 1; b = 2\n c = 3 }").unwrap();
        assert_eq!(result, Test { a: 1, b: 2, c: 3 });

        // Trailing semicolon before closing brace
        let result: Test = from_str(r#"{ a = 1; b = 2; c = 3; }"#).unwrap();
        assert_eq!(result, Test { a: 1, b: 2, c: 3 });
    }

    #[test]
    fn test_commas_as_setting_separators() {
        #[derive(Debug, Deserialize, PartialEq)]
        struct Test {
            a: i32,
            b: i32,
            c: i32,
        }

        // Commas instead of semicolons
        let result: Test = from_str(r#"{ a = 1, b = 2, c = 3 }"#).unwrap();
        assert_eq!(result, Test { a: 1, b: 2, c: 3 });

        // Trailing comma before closing brace
        let result: Test = from_str(r#"{ a = 1, b = 2, c = 3, }"#).unwrap();
        assert_eq!(result, Test { a: 1, b: 2, c: 3 });
    }

    #[test]
    fn test_optional_separators_in_implicit_group() {
        use crate::Value;

        // Implicit group (no braces) without semicolons
        let v: Value = from_str("a = 1\nb = 2\nc = 3").unwrap();
        assert_eq!(v["a"], 1);
        assert_eq!(v["b"], 2);
        assert_eq!(v["c"], 3);

        // Implicit group with semicolons
        let v: Value = from_str("a = 1; b = 2; c = 3;").unwrap();
        assert_eq!(v["a"], 1);
        assert_eq!(v["b"], 2);
        assert_eq!(v["c"], 3);
    }

    #[test]
    fn test_auto_promotion_i64_via_value() {
        use crate::Value;

        // i32 range value stays as Integer
        let v: Value = from_str("42").unwrap();
        assert!(v.is_i32());
        assert_eq!(v, Value::Integer(42));

        // Value exceeding i32::MAX auto-promotes to Integer64
        let v: Value = from_str("3000000000").unwrap();
        assert!(v.is_i64());
        assert_eq!(v.as_i64(), Some(3_000_000_000i64));

        // Explicit L suffix produces Integer64
        let v: Value = from_str("42L").unwrap();
        assert!(v.is_i64());
        assert_eq!(v.as_i64(), Some(42i64));

        // Negative value exceeding i32::MIN auto-promotes to Integer64
        let v: Value = from_str("-3000000000").unwrap();
        assert!(v.is_i64());
        assert_eq!(v.as_i64(), Some(-3_000_000_000i64));

        // i32::MAX is still i32
        let v: Value = from_str("2147483647").unwrap();
        assert!(v.is_i32());

        // i32::MAX + 1 promotes to i64
        let v: Value = from_str("2147483648").unwrap();
        assert!(v.is_i64());
    }

    #[test]
    fn test_negative_numbers() {
        // Negative integer
        assert_eq!(from_str::<i32>("-42").unwrap(), -42);
        assert_eq!(from_str::<i32>("-1").unwrap(), -1);

        // Negative i64
        assert_eq!(from_str::<i64>("-42L").unwrap(), -42);

        // Negative float
        assert_eq!(from_str::<f64>("-3.14").unwrap(), -3.14);
        assert_eq!(from_str::<f64>("-0.5").unwrap(), -0.5);

        // Negative in a struct
        #[derive(Debug, Deserialize, PartialEq)]
        struct Coords {
            x: i32,
            y: i32,
            z: f64,
        }

        let result: Coords = from_str(r#"{ x = -10; y = -20; z = -1.5; }"#).unwrap();
        assert_eq!(
            result,
            Coords {
                x: -10,
                y: -20,
                z: -1.5,
            }
        );

        // Negative via Value
        use crate::Value;
        let v: Value = from_str("-42").unwrap();
        assert_eq!(v, Value::Integer(-42));

        let v: Value = from_str("-3.14").unwrap();
        assert_eq!(v, Value::Float(-3.14));
    }

    #[test]
    fn test_identifier_must_start_with_letter_or_asterisk() {
        #[derive(Debug, Deserialize)]
        #[allow(dead_code)]
        struct Test {
            a: i32,
        }
        // Valid identifiers
        let _: Test = from_str(r#"{ a = 1; }"#).unwrap();

        // Identifier starting with digit should fail
        assert!(from_str::<Test>(r#"{ 1a = 1; }"#).is_err());
    }
}