use crate::{
    lexer::{Kwarg, Token},
    node::Node,
};
pub enum ParserError {}

pub fn parse_vec(mut tokens: &[Token]) {
    let mut nodes: Node = Node {
        text: Some("Root"),
        children: vec![],
    };

    let mut current_token: Option<Token> = None;
    let mut kwargs: Vec<&Kwarg> = vec![];
    let mut strin = &String::new();

    let mut expr_finished = false;
    // let mut

    for i in 1..tokens.len() - 1 {
        let token = &tokens[i];
        match token {
            Token::Tag(ref tag) => match tag.as_str() {
                "text" => {
                    current_token = Some(Token::Tag(tag.to_string()));
                }
                "title" => {}
                _ => {}
            },
            Token::Kwarg(kwarg) => kwargs.push(kwarg),
            Token::Strg(strg) => {
                let st = strg;
                strin = st
            }
            Token::EndParen => expr_finished = true,
            /*
            Token::Quote => todo!(),
            Token::StartParen => todo!(),
            Token::Num(_) => todo!(),
            Token::Float(_) => todo!(),
            Token::HexaDec(_) => todo!(),
            Token::Error => todo!(),
            */
            _ => {}
        }

        if expr_finished {
            // panic!()
            println!("text finished");
            expr_finished = false;

            let node = Node {
                text: Some(&strin),
                children: vec![],
            };

            nodes.children.push(node)
        }
    }

    println!("{}", nodes);
}

pub enum TagTypes {
    Text,
    Unknown,
}