parser.py

from enum import Enum, auto
from typing import Any, Optional, Union

from ftml_ast import AstNode, DocumentRoot
from ftml_ast.blocks import BLOCKS
from ftml_ast.blocks.text import TextNode
from tokenizer3 import Token, TokenStream, TokenType, Tokenizer


class ParsingError(Exception):
    pass


class TokenStreamEOS(Exception):
    pass


class BrokenOpenTag(Exception):
    pass


class Parser:
    def __init__(self):
        self.tokenizer = Tokenizer()
        self.position = 0
        self.token_stream: TokenStream
        self.blocks: list[AstNode] = []
        self.pending_complete: dict[type[AstNode], list[int]] = {}

    def advance(self) -> Token:
        if self.eos():
            raise TokenStreamEOS()
        token = self.token_stream.tokens[self.position]
        self.position += 1
        return token
    
    def peek(self, offset=0) -> Token:
        if self.eos():
            raise TokenStreamEOS()
        return self.token_stream.tokens[self.position + offset]

    def mark(self):
        return self.position

    def rollback(self, mark: int):
        self.position = mark

    def parse(self, text: str) -> DocumentRoot:
        self.token_stream = self.tokenizer.tokenize(text)

        while not self.eos():
            last_point = self.mark()
            try:
                next_token = self.peek()
                match next_token.token_type:
                    case TokenType.OPEN_DOUBLE_BRACKET:
                        if self.peek(1).token_type == TokenType.SLASH:
                            self.parse_block_close()
                        else:
                            self.parse_block_open()
                    case _:
                        self.parse_text_node()
            except ParsingError as e: 
                self.rollback(last_point)
                self.parse_text_node()
                # raise e
            except TokenStreamEOS:
                pass
            

        return DocumentRoot(self.blocks)

    def eos(self):
        return self.position >= len(self.token_stream.tokens)

    def raw(self, token: Token) -> str:
        return self.token_stream.raw(token)
    
    def skip_to_token(self, token_type: TokenType):
        while self.peek().token_type != token_type:
            self.advance()

    def skip_whitespace(self, skip_newline=False):
        mask = TokenType.WHITESPACE
        if skip_newline:
            mask |= TokenType.NEWLINE
        while self.peek().token_type & mask:
            self.advance()

    def assert_token(self, token: Token, expected: TokenType, throw_error: bool=True):
        if token.token_type & expected == 0:
            if throw_error:
                raise ParsingError(f'Token is {token}')
            return False
        return True

    def parse_text_node(self):
        self.blocks.append(TextNode([], self.raw(self.advance())))

    def parse_block_open(self, no_verify=False):
        if not no_verify:
            self.assert_token(self.advance(), TokenType.OPEN_DOUBLE_BRACKET)
        self.skip_whitespace()

        tok = self.advance()
        self.assert_token(tok, TokenType.ASTERISK | TokenType.STRING)

        is_starred = False
        if tok.token_type == TokenType.ASTERISK:
            is_starred = True
            self.skip_whitespace()
            tok = self.advance()
            self.assert_token(tok, TokenType.STRING)

        block_cls = BLOCKS.get(self.raw(tok))
        if not block_cls:
            raise ParsingError()

        is_underscored = False
        if self.peek().token_type == TokenType.UNDERLINE:
            is_underscored = True

        kwargs = self.parse_arguments()

        self.assert_token(self.advance(), TokenType.CLOSE_DOUBLE_BRACKET)

        block = block_cls(
                is_starred=is_starred,
                is_underscorred=is_underscored,
                children=[],
                **kwargs
            )

        self.blocks.append(block)

        if block_cls in self.pending_complete:
            self.pending_complete[block_cls].append(len(self.blocks) - 1)
        else:
            self.pending_complete[block_cls] = [len(self.blocks) - 1]

    def parse_block_close(self, no_verify=False):
        if not no_verify:
            self.assert_token(self.advance(), TokenType.OPEN_DOUBLE_BRACKET)
            self.assert_token(self.advance(), TokenType.SLASH)
        self.skip_whitespace()

        tok = self.advance()
        self.assert_token(tok, TokenType.STRING)

        block_cls = BLOCKS.get(self.raw(tok))
        if not block_cls or not self.pending_complete.get(block_cls):
            raise ParsingError()

        unclosed_index = self.pending_complete[block_cls].pop()
        children_count = len(self.blocks) - unclosed_index - 1
        buf: list[Any] = [None] * children_count

        for i in range(children_count):
            buf[children_count-1 - i] = self.blocks.pop()

        self.blocks[unclosed_index].children = buf
        
        self.skip_whitespace()
        self.assert_token(self.advance(), TokenType.CLOSE_DOUBLE_BRACKET)

    def parse_arguments(self) -> dict[str, Any]:
        kwargs = {}

        while True:
            try:
                key_name = ""
                value = ""
                skip_broken = False

                self.skip_whitespace(skip_newline=True)

                if self.peek().token_type == TokenType.OPEN_DOUBLE_BRACKET:
                    raise BrokenOpenTag()

                if self.peek().token_type == TokenType.CLOSE_DOUBLE_BRACKET:
                    break

                while tok := self.peek():
                    if tok.token_type & (TokenType.UNDERLINE | TokenType.STRING):
                        key_name += self.raw(self.advance())
                        continue
                    elif tok.token_type & (TokenType.WHITESPACE | TokenType.EQUALS | TokenType.CLOSE_DOUBLE_BRACKET):
                        break
                    skip_broken = True
                    self.advance()
                    break
                if skip_broken:
                    continue

                self.skip_whitespace()

                if self.peek().token_type != TokenType.EQUALS:
                    kwargs.update({key_name: True})
                    continue
                
                self.advance()
                self.skip_whitespace()
                try:
                    self.assert_token(self.advance(), TokenType.QUOTE)
                except:
                    raise BrokenOpenTag()

                first_closing = 0
                try:
                    while tok := self.advance():
                        if tok.token_type != TokenType.EQUALS:
                            value += self.raw(tok)
                        elif not first_closing and tok.token_type == TokenType.CLOSE_DOUBLE_BRACKET:
                            first_closing = self.mark()
                except TokenStreamEOS:
                    self.rollback(first_closing)
                    raise BrokenOpenTag()
                
                kwargs.update({key_name: value})
            except ParsingError:
                pass
            except BrokenOpenTag:
                raise ParsingError()
        return kwargs


if __name__ == '__main__':
    pass