TT_INT = "整數(shù)"
TT_FLOAT = "浮點(diǎn)數(shù)"
TT_PLUS = "加號"
TT_DIV = "除號"
TT_MINUS = "減號"
TT_LPAREN = "左括號"
TT_RPAREN = "右括號"
TT_MUL = "乘"
TT_POWER = "次冪"
DIGITS = "123456789"

class Token:
    def __init__(self,is_type,is_value=None):
        self.is_type = is_type
        self.is_value = is_value
    def __repr__(self):
        if self.is_value:
            return "|類型：{},值：{}|".format(self.is_type,self.is_value)
        return "|類型：{}|".format(self.is_type)
    def __str__(self):
        if(self.is_value):
            return "|{}|".format(self.is_value)
        return "|這個對象沒有值，類型為：{}|".format(self.is_type)

class Position:
    def __init__(self, idx, ln, col):
        self.idx = idx
        self.ln = ln
        self.col = col
    def advance(self, cur_char):
        self.idx += 1
        self.col += 1
        if cur_char == '\n':
            self.ln += 1
            self.col = 0
        return self

"""
頂級錯誤（老大）
"""
class HlangError:
    def __init__(self, pos_ln,in_fn,error_name, details):
        """
        :param pos_ln: 錯誤行
        :param in_fn: 輸入文件
        :param error_name: 錯誤名稱
        :param details: 錯誤細(xì)節(jié)，說明
        """
        self.pos_ln = pos_ln
        self.in_fn = in_fn
        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'來自 {self.in_fn}, line {self.pos_ln + 1}'
        return red_code+result+reset_code
class IllegalCharError(HlangError):
    """
    非法字符錯誤
    """
    def __init__(self, pos_ln,in_fn, details):
        super().__init__(pos_ln, in_fn, '非法字符', details)

"""
語法解析器
"""
class Lexer:
    def __init__(self, in_fn, text):
        """
        :param in_fn: 從哪里輸入的文本（文本所在文件，標(biāo)準(zhǔn)輸入，輸出也是一個文件）
        其實(shí)就是文件名~~~
        :param text: 待解析文本
        """
        self.in_fn = in_fn
        self.text = text
        self.pos = Position(-1, 0, -1)
        self.cur_char = None
        self.advance()
        #基本的符號處理
        self.char_pro_base = {
            '+':TT_PLUS,
            '-':TT_MINUS,
            '*':TT_MUL,
            '/':TT_DIV,
            '^':TT_POWER,
            '(':TT_LPAREN,
            ')':TT_RPAREN
        }
    def advance(self):
        self.pos.advance(self.cur_char)
        self.cur_char = self.text[self.pos.idx] if self.pos.idx < len(self.text) else None
    def __char_process(self,tokens,TT):
        """
        處理基本字符的方法，
        添加Token，并且移動字符指針
        :return:
        """
        tokens.append(Token(TT))
        self.advance()
    def make_tokens(self):
        """
        將文本當(dāng)中的字符添加到語法解析器當(dāng)中，將符合語法規(guī)范的內(nèi)容，封裝為Token,
        （就像Spring將對象信息再封裝為Wapper一樣，方便后續(xù)進(jìn)行操作。）
        :return:
        """
        tokens = []
        while self.cur_char != None:
            if self.cur_char in ' \t':
                #制表符（空格），沒有意義，往前移動
                self.advance()
            elif self.cur_char in DIGITS:
                #如果是數(shù)字，自動往前搜索，并且將數(shù)字進(jìn)行添加，并且判斷類型，
                #數(shù)字比較特殊，不是一個字符一個字符參與的（后面還要定義關(guān)鍵字也是類似的）
                tokens.append(self.make_number())
            else:
                TT = self.char_pro_base.get(self.cur_char)
                if(TT):
                    self.__char_process(tokens,TT)
                else:
                    char = self.cur_char
                    self.advance()
                    return [], IllegalCharError(self.pos.ln,self.in_fn, "'" + char + "'")
        return tokens, None
    def make_number(self):
        num_str = ''
        dot_count = 0
        while self.cur_char != None and self.cur_char in DIGITS + '.':
            if self.cur_char == '.':
                if dot_count == 1: break
                dot_count += 1
                num_str += '.'
            else:
                num_str += self.cur_char
            self.advance()
        if dot_count == 0:
            return Token(TT_INT, int(num_str))
        else:
            return Token(TT_FLOAT, float(num_str))

"""
語言解析，運(yùn)行入口
"""
def run(fn, text):
    lexer = Lexer(fn, text)
    tokens, error = lexer.make_tokens()
    return tokens, error

"""
Hlang is a Sample Language shell
Just a sample example for learning by Huterox
"""
import basic
while True:
    input_text = input("交互終端：")
    result, error = basic.run('<標(biāo)準(zhǔn)輸入>', input_text)
    if error: print(error.as_string())
    else: print(result)