use crate::{grammar::value, syntax_error::SyntaxError, syntax_kind::SyntaxKind};

use super::{CompletedMarker, Parser, BASIC_VALUE_TOKENS};

pub(super) fn object(p: &mut Parser) -> Option<CompletedMarker> {
    let obj_start = p.start("object");

    if !p.eat(SyntaxKind::BRACE_OPEN) {
        obj_start.abandon(p);
        return None;
    }

    member(p);
    while p.at(SyntaxKind::COMMA) {
        // not always an error, later configurable
        let potential_trailing_comma = p.start("potential_trailing_comma");
        p.eat(SyntaxKind::COMMA);

        if member(p).is_none() {
            potential_trailing_comma.complete(p, SyntaxKind::TRAILING_COMMA);
        } else {
            potential_trailing_comma.abandon(p);
        }
    }

    Some(if p.eat(SyntaxKind::BRACE_CLOSE) {
        obj_start.complete(p, SyntaxKind::OBJECT)
    } else {
        obj_start.error(p, SyntaxError::UnclosedObject)
    })
}

fn member(p: &mut Parser) -> Option<CompletedMarker> {
    let member_start = p.start("member");

    if p.at(SyntaxKind::BRACE_CLOSE) {
        member_start.abandon(p);
        return None;
    } else if p.at(SyntaxKind::STRING) {
        let member_name_start = p.start("member_name");
        p.eat(SyntaxKind::STRING);
        member_name_start.complete(p, SyntaxKind::MEMBER_NAME);
    } else {
        return todo!("handle other tokens: {:?}", p.current());
    }

    if !p.eat(SyntaxKind::COLON) {
        todo!("handle wrong tokens")
    }

    let member_value_start = p.start("member_value_start");
    if value(p) {
        member_value_start.complete(p, SyntaxKind::MEMBER_VALUE);
        Some(member_start.complete(p, SyntaxKind::MEMBER))
    } else {
        member_value_start.abandon(p);
        let e = member_start.error(p, SyntaxError::MemberMissingValue);
        Some(
            e.precede(p, "member but failed already")
                .complete(p, SyntaxKind::MEMBER),
        )
    }
}