from tkinter import *
import time
import math

# 以下为全局变量
TubeX0 = 50         # 栈的左上角坐标位置
TubeY0 = 150
TubeDeep = 5        # 栈的深度（能容纳5个球）
BallRaius = 50      # 每个球的半径
# 预先计算栈的其他坐标点
TubeX1 = TubeX0+BallRaius                       # 栈底部小球的中心坐标
TubeY1 = TubeY0+BallRaius*TubeDeep
TubeTopX = TubeX0+BallRaius/2                   # 栈顶部出入口外的中心坐标
TubeTopY = TubeY0 - BallRaius/2-BallRaius/4

QueueX0 = 200       # 待进栈小球的坐标位置
QueueY0 = 100

# 运算动画时的相关坐标
EvalX1 = TubeX1 + (BallRaius+2)*2
EvalY = TubeY1-BallRaius/2
EvalX2 = EvalX1 + (BallRaius+2)*2
EvalXe = (EvalX1+EvalX2)/2

Speed = 2  # 小球移动的速度

class Ball:     # window:TK窗口对象，canvas:画布对象，txt:小球的内容，txt:小球的坐标
    def __init__(self, window, canvas, txt, pos):
        self.window = window
        self.canvas = canvas
        self.txt = txt

        self.ballId = self.canvas.create_oval(
            pos[0]-BallRaius/2, pos[1]-BallRaius /
            2, pos[0]+BallRaius/2, pos[1]+BallRaius/2,
            fill='green', outline='green')
        self.numId = self.canvas.create_text(pos[0], pos[1],
                                             text=self.txt, fill='yellow',
                                             font=('', BallRaius-25))

    def getTxt(self):
        return self.txt

    # def getIndex(self):
    #     return self.index

    def getPos(self):
        pos = self.canvas.coords(self.ballId)
        return [(pos[0]+pos[2])/2, (pos[1]+pos[3])/2]

    def animate(self, poly):
        for pos in poly:                                        # 遍历路径的每一个途经点
            startPos = self.getPos()                            # 获得开始位置坐标
            distance = self.distance(startPos, pos)             # 获得每一步需移动的x和y的步长（可能为负数）
            while not self.match(self.getPos(), pos):  # 测试是否到途经点
                # 根据x和y的步长，分别移动小球和小球里的数字（符号）
                self.canvas.move(self.ballId, distance[0], distance[1])
                self.canvas.move(self.numId, distance[0], distance[1])
                self.window.update()
                time.sleep(0.01)

    def distance(self, pos1, pos2):
        dx = pos2[0]-pos1[0]                # 分别计算x坐标和y坐标的距离
        dy = pos2[1]-pos1[1]
        dist = math.sqrt(dx*dx+dy*dy)       # 利用勾股定理计算两点的距离
        dtime = dist/Speed                  # 走完行程所用的时间
        return [dx/dtime, dy/dtime]         # 返回每次移动的步长

    def match(self, pos1, pos2, mat=1):     # 判断两个坐标点pos1和pos2是否重合，mat为精度，即mat=1时，误差+-0.5都算重合
        if abs(pos2[0]-pos1[0]) < mat and abs(pos2[1]-pos1[1]) < mat: #简单计算而不用勾股定理计算距离
            return True
        return False

    def destory(self):
        self.canvas.delete(self.ballId)
        self.canvas.delete(self.numId)


class Stack:    # canvas:画布对象
    def __init__(self, canvas):
        self.stack = []
        self.canvas = canvas
        # 画出栈的外形
        self.canvas.create_line(TubeX0-2, TubeY0-2,
                                TubeX0-2, TubeY1+2,
                                TubeX1+2, TubeY1+2,
                                TubeX1+2, TubeY0-2,
                                width=4, fill='blue', joinstyle=BEVEL)

    def push(self, ball):
        index = len(self.stack)
        # 小球移动的动画，参数是两个坐标点，先到栈口上部，然后落到栈里
        ball.animate([[TubeTopX, TubeTopY], [TubeTopX, TubeY1-(index*BallRaius)-BallRaius/2]])
        self.stack.append(ball)

    def pop(self):
        index = len(self.stack)-1
        ball = self.stack.pop()
        # 出栈动画，小球移动到栈口上方
        ball.animate([[TubeTopX, TubeTopY]])
        return ball


def main():

    strBuf = '65+1-5*'  # 需解析的字符串
    queue = []          # 等待处理的球的队列

    window = Tk()
    window.title('Stack animate')
    # window.geometry('640x480+50+50')

    canvas = Canvas(window, width=640, height=480,)
    canvas.pack()

    stk = Stack(canvas)

    # 生成球的队列
    index = 0
    for char in strBuf:
        ball = Ball(window, canvas, char, [QueueX0+BallRaius*index, QueueY0])
        queue.append(ball)
        # print(ball.getPos())
        index += 1

    for ball in queue:
        c = ball.getTxt()
        if c.isnumeric():               # 判断球内的字符是否数字
            stk.push(ball)              # 是数字，球就进栈
        elif c == '+' or c == '-' or c == '*' or c == '/':
            #下面几个animate方法演示计算过程的动画
            ball.animate([[EvalXe, EvalY]])

            ball1 = stk.pop()
            ball1.animate([[TubeTopX+BallRaius, TubeTopY], [EvalX1, EvalY]])

            ball2 = stk.pop()
            ball2.animate([[TubeTopX+BallRaius, TubeTopY], [EvalX2, EvalY]])

            a1 = ball1.getTxt()
            a2 = ball2.getTxt()
            ball1.animate([[EvalXe, EvalY]])
            ball2.animate([[EvalXe, EvalY]])

            result = eval(a1+c+a2)
            newBall = Ball(window, canvas, str(result), ball.getPos())

            ball1.destory()
            ball2.destory()
            ball.destory()
            # ball.setTxt(str(result))
            stk.push(newBall)
            # 删除ball1,ball2

    ball = stk.pop()
    ball.animate([[EvalXe, EvalY]])
    # time.sleep(1)

    window.mainloop()


if __name__ == "__main__":
    main()