class andOrStack(object):
    '''
        A+B --> A and B
        A|B --> A or B
        purpose: get the final result
        example: (T+F) == F
                 (T|F) == T
                 (T+F)|F == F
        input: T means True
               F means False
    '''
    def __init__(self, inputString):
        print('addOrStack initialing')
        self.inputString = inputString
        self.stack = []
        self.leftBrackets = 0 # 左括号数量
        self.needManipulate = 0 # 是否需要处理运算
        self.firstLetter = True
        self.result = True
        self.letterLen = len(self.inputString) 
        # 计算结果
        result = self.getResult(self.inputString)

    def manipulateStack(self, idx, letter):
        print('leftBrackets now is {}'.format(self.leftBrackets))
        if len(self.stack) == 0:
            self.firstLetter = True
        if idx+1 == self.letterLen and len(self.stack)==0:
            if letter=='T':
                print('result is True')
                return True
            if letter=='F':
                print('result is False')
                return False
        print(idx, self.stack)
        if self.firstLetter == True:
            if letter=='T':
                self.firstLetter = False
                self.stack.append(True)
                print('first T')
                self.result = True
                print(self.stack)
                return None
            if letter=='F':
                self.firstLetter = False
                self.stack.append(False)
                self.result = False
                return None
            self.firstLetter = False
        print(idx, self.stack)
        # 计算字符
        # 如果是左括号，则存入栈
        if letter == '(':
            self.stack.append(letter)
            self.leftBrackets += 1
            print('leftBrackets now is {}'.format(self.leftBrackets))
        # 如果是右括号，则计算栈里的内容，并存入栈
        if letter == ')':
            aBool = self.stack.pop()
            relationship = self.stack.pop()
            bBool = self.stack.pop()
            self.stack.pop() # 去掉左括号
            self.leftBrackets -= 1
            print('leftBrackets now is {}'.format(self.leftBrackets))
            if relationship=='|':
                b = aBool or bBool
                self.result = b
                if b==True:
                    self.manipulateStack(idx, 'T')
                elif b==False:
                    self.manipulateStack(idx, 'F')
            if relationship=='+':
                b = aBool and bBool
                if b==True:
                    self.manipulateStack(idx, 'T')
                elif b==False:
                    self.manipulateStack(idx, 'F')

        # 如果为T或者F，则查看左一是否为运算符
        # 且左二是否为bool
        if letter == 'T':
            print('second T')
            if self.needManipulate > 0 and self.leftBrackets==0:
                aBool = True
                relationship = self.stack.pop()
                bBool = self.stack.pop()
                print(aBool, relationship, bBool)
                # 递归调用自身
                if relationship=='|':
                    b = aBool or bBool
                    self.result = b
                    if b==True:
                        self.manipulateStack(idx, 'T')
                    elif b==False:
                        self.manipulateStack(idx, 'F')
                if relationship=='+':
                    b = aBool and bBool
                    self.result = b
                    if b==True:
                        self.manipulateStack(idx, 'T')
                    elif b==False:
                        self.manipulateStack(idx, 'F')
                self.needManipulate -= 1
            else:
                self.needManipulate += 1
                letter = True
                self.stack.append(letter)
        if letter == 'F':
            if self.needManipulate > 0 and self.leftBrackets==0:
                aBool = False
                relationship = self.stack.pop()
                bBool = self.stack.pop()
                # 递归调用自身
                if relationship=='|':
                    b = aBool or bBool
                    self.result = b
                    if b==True:
                        self.manipulateStack(idx, 'T')
                    elif b==False:
                        self.manipulateStack(idx, 'F')
                if relationship=='+':
                    b = aBool and bBool
                    self.result = b
                    if b==True:
                        self.manipulateStack(idx, 'T')
                    elif b==False:
                        self.manipulateStack(idx, 'F')
                self.needManipulate -= 1
            else:
                self.needManipulate += 1
                letter = False
                self.stack.append(letter)

        if letter == '|':
            # 如果此时左边有没有左括号
            if self.leftBrackets == 0:
                self.needManipulate += 1
                self.stack.append(letter)
            else:
                self.stack.append(letter)
        if letter == '+':
            # 如果此时左边有没有左括号
            if self.leftBrackets == 0:
                self.needManipulate += 1
                self.stack.append(letter)
            else:
                self.stack.append(letter)
        print(idx, self.stack)
    def getResult(self, inputString):
        '''
            定义stack为list类型的栈
            设计一个栈结构，
            从左到右将字符压入栈底，
            有左括号则直到遇到右括号才吐出来，
            并计算括号内内容，将结果继续压入栈
            若没有左括号，
            则遇到两个值后吐出来计算，
            再压进去，直到完成所有字符读取。
        '''

        for idx, letter in enumerate(inputString):
            print(idx, letter)
            self.manipulateStack(idx, letter)
        print('final stack is:')
        print(self.stack)
        print('final result is:')
        print(self.result)
        return 
if __name__=='__main__':
    inputString = "(T+F)"
    print('*************')
    print("(T+F)")
    c = andOrStack("(T+F)")
    print('*************')
    print('*************')
    print("T+T")

    c = andOrStack("T+T")
    print('*************')
    print('*************')
    print('((T+F)|T)+(F|(T+F))')
    c = andOrStack("((T+F)|T)+(F|(T+F))")
    print('*************')
    print('*************')
    print('(((T+T)|F)+(T|(F+F)))|(T+F)')
    c = andOrStack("(((T+T)|F)+(T|(F+F)))|(T+F)")