use crate::parser::{syntax_kind::SyntaxKind::*, CompletedMarker, Parser};

use self::{collection::collection, instruction::instr, lit::literal};

mod instruction;
mod lit;
mod collection {
    use enumset::enum_set;

    use crate::parser::{
        syntax_kind::{SyntaxKind::*, TokenSet},
        CompletedMarker, Parser,
    };

    use self::{attr_set::attr_set, matrix::matrix, vec::vec};

    const COLLECTION_START: TokenSet = enum_set!(MAT_KW | L_BRACK | L_BRACE);

    pub fn collection(p: &mut Parser) -> Option<CompletedMarker> {
        if !COLLECTION_START.contains(p.current()) {
            return None;
        }

        Some(match p.current() {
            MAT_KW => matrix(p),
            L_BRACK => vec(p),
            L_BRACE => attr_set(p),
            _ => unreachable!(),
        })
    }

    mod matrix;
    mod vec {
        use crate::parser::{CompletedMarker, Parser};

        pub fn vec(p: &mut Parser) -> CompletedMarker {
            todo!()
        }
    }
    mod attr_set {
        use crate::parser::{CompletedMarker, Parser};

        pub fn attr_set(p: &mut Parser) -> CompletedMarker {
            todo!()
        }
    }
}

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

    if atom(p).or_else(|| instr(p)).is_none() {
        expr.abandon(p);
        return None;
    }

    Some(expr.complete(p, EXPR))
}

pub fn atom(p: &mut Parser) -> Option<CompletedMarker> {
    literal(p).or_else(|| collection(p))
}