"""
定義節(jié)點：
NumberNode：表示數(shù)字節(jié)點，用于存儲數(shù)字的令牌（token）信息。
BinOpNode：表示二元操作符節(jié)點。其中：
            left_node（左節(jié)點），
            op_tok（操作符令牌），
            right_node（右節(jié)點）
UnaryOpNode：表示一元操作符節(jié)點。
            op_tok（操作符令牌）
            node（子節(jié)點）
"""
class NumberNode:
    def __init__(self, tok):
        self.tok = tok
    def __repr__(self):
        return f'{self.tok}'
class BinOpNode:
    def __init__(self, left_node, op_tok, right_node):
        self.left_node = left_node
        self.op_tok = op_tok
        self.right_node = right_node
    def __repr__(self):
        return f'({self.left_node}, {self.op_tok}, {self.right_node})'
class UnaryOpNode:
    def __init__(self, op_tok, node):
        self.op_tok = op_tok
        self.node = node
    def __repr__(self):
        return f'({self.op_tok}, {self.node})'

class InvalidSyntaxError(HlangError):
    def __init__(self, pos_start, pos_end, details=''):
            super().__init__(pos_start, pos_end, 'Invalid Syntax：語法錯誤', details)

class HlangError:
    def __init__(self, pos_start, pos_end, error_name, details):
        """
        :param pos_start: 錯誤開始未知
        :param pos_end: 錯誤結束未知
        :param error_name: 錯位類型
        :param details: 細節(jié)
        """
        self.pos_start = pos_start
        self.pos_end = pos_end
        self.error_name = error_name
        self.details = details
    def as_string(self):
        red_code = "\033[91m"
        reset_code = "\033[0m"
        result = f'{self.error_name}: {self.details}\n'
        result += f'File {self.pos_start.fn}, line {self.pos_start.ln + 1}'
        result += '\n\n' + string_with_arrows(self.pos_start.ftxt, self.pos_start, self.pos_end)
        return red_code+result+reset_code

class Position:
    def __init__(self, idx, ln, col, fn, ftxt):
            self.idx = idx
            self.ln = ln
            self.col = col
            self.fn = fn
            self.ftxt = ftxt
    def advance(self, current_char=None):
            self.idx += 1
            self.col += 1
            if current_char == '\n':
                    self.ln += 1
                    self.col = 0
            return self
    def copy(self):
            return Position(self.idx, self.ln, self.col, self.fn, self.ftxt)

def string_with_arrows(text, pos_start, pos_end):
    result = ''
    # 計算索引位置
    idx_start = max(text.rfind('\n', 0, pos_start.idx), 0)
    idx_end = text.find('\n', idx_start + 1)
    if idx_end < 0:
        idx_end = len(text)
    # 生成每一行
    line_count = pos_end.ln - pos_start.ln + 1
    for i in range(line_count):
        # 計算行的列數(shù)
        line = text[idx_start:idx_end]
        col_start = pos_start.col if i == 0 else 0
        col_end = pos_end.col if i == line_count - 1 else len(line) - 1
        # 添加到結果中
        result += line + '\n'
        result += ' ' * col_start + '^' * (col_end - col_start)
        # 重新計算索引位置
        idx_start = idx_end
        idx_end = text.find('\n', idx_start + 1)
        if idx_end < 0:
            idx_end = len(text)
    return result.replace('\t', '')

class ParseResult:
    def __init__(self):
        self.error = None
        self.node = None
    def register(self, res):
        if isinstance(res, ParseResult):
            if res.error: self.error = res.error
            return res.node
        return res
    def success(self, node):
        self.node = node
        return self
    def failure(self, error):
        self.error = error
        return self

    def bin_op(self, func, ops):
        res = ParseResult()
        #構造左邊的解析樹
        left = res.register(func())
        if res.error: return res
        while self.current_tok.type in ops:
            #如果，當前的token，是token，令牌是這個符合要求的運算符
            #那么拿到下一個token,然后看看能不能構造左邊的解析樹
            #記住我們這里是中綴表達式，從左到右的
            op_tok = self.current_tok
            res.register(self.advance())
            right = res.register(func())
            if res.error: return res
            #此時我們把左右合并，組裝成新的樹，但是如果沒有，
            # 那么左子樹就是當前的樹，不用構造，沒有新的層級
            left = BinOpNode(left, op_tok, right)
        return res.success(left)

    def factor(self):
        res = ParseResult()
        tok = self.current_tok
        if tok.type in (TT_PLUS, TT_MINUS):
            #如果是運算符號，那么它是一元操作符，找到下一個數(shù)字
            res.register(self.advance())
            factor = res.register(self.factor())
            if res.error: return res
            #返回到右子樹
            return res.success(UnaryOpNode(tok, factor))
        elif tok.type in (TT_INT, TT_FLOAT):
            #如果是一個數(shù)字，那么直接返回節(jié)點
            res.register(self.advance())
            return res.success(NumberNode(tok))
        #如果是(，那么說明這個玩意又是一個表達式
        elif tok.type == TT_LPAREN:
            res.register(self.advance())
            expr = res.register(self.expr())
            if res.error: return res
            if self.current_tok.type == TT_RPAREN:
                res.register(self.advance())
                return res.success(expr)
            else:
                return res.failure(InvalidSyntaxError(
                    self.current_tok.pos_start, self.current_tok.pos_end,
                    "應該是： ')'"
                ))
        return res.failure(InvalidSyntaxError(
            tok.pos_start, tok.pos_end,
            "應為：整型或浮點型"
        ))

假設要解析的表達式是`(5+3)*2`,那么我們這個解析器的流程是這樣的：
目標是這個：
            *
           / \
          +   2
         / \
        5   3
1. 表達式：`(5+3)*2`
2. 調用 `expr()` 方法開始解析表達式。
3. 在 `bin_op()` 方法內部，調用 `term()` 方法解析左操作數(shù)。
   - 調用 `term()` 方法開始解析項。
   - 在 `bin_op()` 方法內部，調用 `factor()` 方法解析左操作數(shù)。
     - 獲取數(shù)字 `5` 的令牌，并創(chuàng)建一個 NumberNode 對象表示該數(shù)字。
   - 返回左操作數(shù)的解析結果。
4. 循環(huán)檢查當前令牌，發(fā)現(xiàn)下一個令牌是 `+` 號。
5. 調用 `bin_op()` 方法解析加法運算符。
   - 調用 `term()` 方法作為參數(shù)傳遞給 `bin_op()` 方法，解析右操作數(shù)。
     - 調用 `term()` 方法開始解析項。
     - 在 `bin_op()` 方法內部，調用 `factor()` 方法解析右操作數(shù)。
       - 獲取數(shù)字 `3` 的令牌，并創(chuàng)建一個 NumberNode 對象表示該數(shù)字。
     - 返回右操作數(shù)的解析結果。
   - 創(chuàng)建一個 BinOpNode 對象，表示加法運算，左操作數(shù)為前面解析得到的 NumberNode 對象，右操作數(shù)為剛剛解析得到的數(shù)字 `3` 的 NumberNode 對象。
6. 返回加法運算的結果，即 BinOpNode 對象。
7. 循環(huán)檢查當前令牌，發(fā)現(xiàn)下一個令牌是 `*` 號。
8. 調用 `bin_op()` 方法解析乘法運算符。
   - 調用 `term()` 方法作為參數(shù)傳遞給 `bin_op()` 方法，解析右操作數(shù)。
     - 獲取數(shù)字 `2` 的令牌，并創(chuàng)建一個 NumberNode 對象表示該數(shù)字。
   - 創(chuàng)建一個 BinOpNode 對象，表示乘法運算，左操作數(shù)為前面解析得到的 BinOpNode 對象，右操作數(shù)為剛剛解析得到的數(shù)字 `2` 的 NumberNode 對象。
9. 返回乘法運算的結果，即 BinOpNode 對象。
10. 返回表達式的解析結果，即最終得到的抽象語法樹的根節(jié)點。