use chumsky::{
    prelude::{filter, Simple},
    primitive::{any, choice, end, just},
    recursive::recursive,
    select, Parser,
};

use std::vec;

use chumsky::{
    primitive::take_until,
    text::{ident, int, TextParser},
};

pub type Tokens = Vec<Token>;

#[derive(PartialEq, Eq, Debug, Clone, Hash)]
pub enum Token {
    HtmlFragment(String),
    Inline(Stack),
    Expression(Stack),
    Client(Stack),
    Both(Stack),
    LayoutSel(Stack),
    InlineBlock(Stack),
    Component(Stack),
    Function(Stack),
    Else,
    ClientClose,
    BothClose,
    LayoutSelClose,
    InlineClose,
    ComponentClose,
    FunctionClose(String),
}

pub type Stack = Vec<StackToken>;

#[derive(PartialEq, Eq, Debug, Clone, Hash)]
pub enum StackToken {
    Function(String),
    Ident(Ident),
    Literal(Literal),
}

pub type Ident = Vec<IdentSpecifiers>;

#[derive(PartialEq, Eq, Debug, Clone, Hash)]
pub enum IdentSpecifiers {
    Ident(String),
    Expr(Stack),
}

#[derive(PartialEq, Eq, Debug, Clone, Hash)]
pub enum Literal {
    Str(String),
    Nr(i32),
}

fn literal() -> impl Parser<char, Literal, Error = Simple<char>> {
    let literal_str = just('\'')
        .ignore_then(take_until(just('\'')))
        .map(|(between, _)| between)
        .or(just('"')
            .ignore_then(take_until(just('"')))
            .map(|(between, _)| between))
        .collect::<String>()
        .map(Literal::Str);
    let literal_nr = int(10).from_str().unwrapped().map(Literal::Nr);
    literal_nr.or(literal_str).padded()
}

fn mustache<T>(
    parser: impl Parser<char, T, Error = Simple<char>>,
) -> impl Parser<char, T, Error = Simple<char>> {
    just("{{")
        .ignore_then(parser.padded())
        .then_ignore(just("}}"))
}

fn my_ident<T: Parser<char, Stack, Error = Simple<char>> + Clone>(
    arg_parser: T,
) -> impl Parser<char, Ident, Error = Simple<char>> {
    let bracket = just('[')
        .ignore_then(arg_parser)
        .then_ignore(just(']'))
        .map(IdentSpecifiers::Expr);

    let dot = just('.').ignore_then(ident()).map(IdentSpecifiers::Ident);

    let initial = ident().map(IdentSpecifiers::Ident).or(bracket.clone());

    initial.chain(dot.or(bracket).repeated())
}

fn stack() -> impl Parser<char, Stack, Error = Simple<char>> {
    recursive(|expr| {
        let function = just('!').ignore_then(ident()).map(StackToken::Function);
        let ident = my_ident(expr).map(StackToken::Ident);
        choice((function, ident, literal().map(StackToken::Literal)))
            .padded()
            .repeated()
    })
}

fn flat_token() -> impl Parser<char, Token, Error = Simple<char>> {
    let inline = mustache(just("Inline").ignore_then(stack())).map(Token::Inline);
    let expression_mus = mustache(stack()).map(Token::Expression);
    inline.or(expression_mus)
}

fn block_token() -> impl Parser<char, Token, Error = Simple<char>> {
    fn block_mus(name: &'static str) -> impl Parser<char, Stack, Error = Simple<char>> {
        mustache(just('#').padded().then(just(name)).ignore_then(stack()))
    }

    let function = mustache(just('#').padded().ignore_then(stack()));

    choice((
        block_mus("client").map(Token::Client),
        block_mus("Both").map(Token::Both),
        block_mus("Layout").map(Token::LayoutSel),
        block_mus("Inline").map(Token::InlineBlock),
        block_mus("Component").map(Token::Component),
        function.map(Token::Function),
    ))
}

fn block_close() -> impl Parser<char, Token, Error = Simple<char>> {
    fn block_mus(name: &'static str) -> impl Parser<char, (), Error = Simple<char>> {
        mustache(just('/').padded().then(just(name)).ignored())
    }

    let function = mustache(just('/').padded().ignore_then(ident()));

    choice((
        block_mus("client").to(Token::ClientClose),
        block_mus("Both").to(Token::BothClose),
        block_mus("Layout").to(Token::LayoutSelClose),
        block_mus("Inline").to(Token::InlineClose),
        block_mus("Component").to(Token::ComponentClose),
        function.map(Token::FunctionClose),
    ))
}

fn non_html() -> impl Parser<char, Token, Error = Simple<char>> {
    let else_token = mustache(just("Else")).to(Token::Else);
    choice((block_token(), else_token, block_close(), flat_token()))
}

pub fn token_parser() -> impl Parser<char, Tokens, Error = Simple<char>> {
    take_until(non_html())
        .map(|(html, token)| vec![Token::HtmlFragment(html.into_iter().collect()), token])
        .repeated()
        .flatten()
        .chain(any().repeated().collect().map(Token::HtmlFragment))
        .then_ignore(end())
}

pub type AST = Vec<Node>;

#[derive(PartialEq, Eq, Debug, Clone)]
pub enum Node {
    Html(Html),
    Inline(Stack),
    Expression(Stack),
    Client(Stack, AST),
    Both(Stack, AST),
    InlineBlock(Stack, AST),
    LayoutSel(Stack, AST),
    Component(Stack, AST),
    FunctionBlock(Stack, AST),
    FunctionDoubleBlock(Stack, AST, AST),
}

#[derive(PartialEq, Eq, Debug, Clone)]
pub enum Html {
    Node(String, AST, String),
    Leaf(String),
}

fn flat() -> impl Parser<Token, Node, Error = Simple<Token>> {
    select! {
        Token::Inline(x) => Node::Inline(x),
        Token::Expression(x) => Node::Expression(x)
    }
}

// there are more beautiful solutions, but I'm not smart enough
macro_rules! matching {
    ($pat_open:pat $(if $guard_open:expr)?, $middle:expr, $pat_close:pat $(if $guard_close:expr)?, $convert:expr) => {
        filter(|open| matches!(open, $pat_open $(if $guard_open)?))
            .then($middle)
            .then_with(|(open, ast)|{
                let $pat_open = open.clone() else {
                    panic!("Token does not match same pattern twice. This cannot happen")
                };
                filter(move |close| matches!(close, $pat_close $(if $guard_close)?)).to({
                    let $pat_open = open else {
                        panic!("Token does not match same pattern twice. This cannot happen")
                    };
                    $convert(ast)
                })
            })
    };
}

fn block<T: Parser<Token, AST, Error = Simple<Token>> + Clone>(
    ast_parser: T,
) -> impl Parser<Token, Node, Error = Simple<Token>> {
    let ast_clone = move || ast_parser.clone();
    let client = matching!(Token::Client(x), ast_clone(), Token::ClientClose, |ast| {
        Node::Client(x, ast)
    });
    let both = matching!(Token::Both(x), ast_clone(), Token::BothClose, |ast| {
        Node::Both(x, ast)
    });
    let inline_block = matching!(
        Token::InlineBlock(x),
        ast_clone(),
        Token::InlineClose,
        |ast| { Node::InlineBlock(x, ast) }
    );
    let layout_sel = matching!(
        Token::LayoutSel(x),
        ast_clone(),
        Token::LayoutSelClose,
        |ast| { Node::LayoutSel(x, ast) }
    );
    let component = matching!(
        Token::Component(x),
        ast_clone(),
        Token::ComponentClose,
        |ast| { Node::Component(x, ast) }
    );
    let function = matching!(
        Token::Function(x) if matches!(x.as_slice(), [StackToken::Function(_)]),
        ast_clone(),
        Token::FunctionClose(y) if matches!(x.as_slice(), [StackToken::Function(z)] if z == y),
        |ast| { Node::FunctionBlock(x, ast) }
    );
    let function_double_block = matching!(
        Token::Function(x) if matches!(x.as_slice(), [StackToken::Function(_)]),
        ast_clone().then_ignore(just(Token::Else)).then(ast_clone()),
        Token::FunctionClose(y) if matches!(x.as_slice(), [StackToken::Function(z)] if z == y),
        |(ast1, ast2)| { Node::FunctionDoubleBlock(x, ast1, ast2) }
    );

    choice((
        client,
        both,
        inline_block,
        layout_sel,
        component,
        function,
        function_double_block,
    ))
}

fn html<T: Parser<Token, AST, Error = Simple<Token>> + Clone>(
    ast_parser: T,
) -> impl Parser<Token, Node, Error = Simple<Token>> {
    let html_frag = select! { Token::HtmlFragment(x) => x };
    let node = html_frag
        .clone()
        .then(ast_parser)
        .then(html_frag.clone())
        .map(|((before, middle), after)| Html::Node(before, middle, after));
    let leaf = html_frag.map(|str| Html::Leaf(str));
    node.or(leaf).map(|html| Node::Html(html))
}

pub fn ast_parser() -> impl Parser<Token, AST, Error = Simple<Token>> {
    recursive(|ast| choice((html(ast.clone()), block(ast), flat())).repeated()).then_ignore(end())
}

#[test]
fn ast_just_html() {
    let simple_html = "\
<html>
<body>
<span>
hello world
</span>
</body>
</html>\
";
    let tokens = token_parser().parse(simple_html).unwrap();
    let ast = ast_parser().parse(tokens);
    assert_eq!(
        ast,
        Ok(vec![Node::Html(Html::Leaf(simple_html.to_string()))])
    )
}

#[test]
fn ast_simple() {
    let simple_html = "\
<html>
<body>
<span>
{{ x }}
</span>
</body>
</html>\
";
    let first_part = "\
<html>
<body>
<span>
"
    .to_string();
    let last_part = "
</span>
</body>
</html>\
"
    .to_string();
    let tokenized = token_parser().parse(simple_html).unwrap();
    let ast = ast_parser().parse(tokenized);
    assert_eq!(
        ast,
        Ok(vec![Node::Html(Html::Node(
            first_part,
            vec![Node::Expression(vec![StackToken::Ident(vec![
                IdentSpecifiers::Ident('x'.to_string())
            ])])],
            last_part
        ))])
    )
}

#[test]
fn ast_if_else() {
    let simple_html = "\
<html>
<body>
<span>
{{#!if}}
span hello
{{Else}}
span world
{{/if}}
</span>
</body>
</html>\
";
    let first_part = "\
<html>
<body>
<span>
"
    .to_string();
    let last_part = "
</span>
</body>
</html>\
"
    .to_string();
    let tokenized = token_parser().parse(simple_html).unwrap();
    let ast = ast_parser().parse(tokenized);
    assert_eq!(
        ast,
        Ok(vec![Node::Html(Html::Node(
            first_part,
            vec![Node::FunctionDoubleBlock(
                vec![StackToken::Function("if".to_string())],
                vec![Node::Html(Html::Leaf("\nspan hello\n".to_string()))],
                vec![Node::Html(Html::Leaf("\nspan world\n".to_string()))]
            )],
            last_part
        ))])
    )
}