#
from Tkinter import *
import time
import threading
window = Tk()
canvas = Canvas(window, width = 6400, height = 6000)
canvas.pack()

event = threading.Event()

def coordinator (tick_time_seconds):
    while (True):
        event.set()
        time.sleep (tick_time_seconds)

xrob=0
yrob=10
robCoordYleft=30    #START  COORDINATES
robCoordX1=70
robCoordX2=110
robCoordYright=30
obstacleStartY=200
obstacleStartX=40
obstacleEndX =350
obstacleEndY=220
finalY=250
avoid=0
distFirstLast = 30
# create ball:
frame = canvas.create_rectangle (0,0,1000,520)
robot11 = canvas.create_rectangle(60,40,80,60,tag='group0')
robot12 = canvas.create_rectangle(60,10,80,30,tag = 'group0')
robot21 = canvas.create_rectangle (100,40,120,60,tag='group0')
robot22 = canvas.create_rectangle (100,10,120,30,tag='group0')
obstacle = canvas.create_rectangle (obstacleStartX,obstacleStartY,obstacleEndX,obstacleEndY)
#which = canvas.create_oval(x0,y0,x1,y1,fill="blue", tag='blueBall')
distanceY = abs (robCoordYleft - obstacleStartY)


def left (robCoordXleft,robCoordYleft,obstacleStartX):
    while ((obstacleStartX - robCoordXleft)<10):
        xrob = -10
        yrob = 0
        event.wait()
        canvas.move(robot11,xrob,yrob)
        canvas.move(robot12,xrob,yrob)
        robCoordXleft=robCoordXleft + xrob
        event.clear()
        if (robCoordXleft<=10):
            break
        #canvas.after(1000)
        canvas.update()
    while (obstacleEndY>=robCoordYleft-distFirstLast):
        print (obstacleEndY, robCoordYleft)
        xrob=0
        yrob=10
        event.wait()
        canvas.move (robot11,xrob,yrob)
        canvas.move (robot12,xrob,yrob)
        robCoordYleft=robCoordYleft + yrob
        event.clear()
        #canvas.after(1000)
        canvas.update()


def right(robCoordXright,robCoordYright,obstacleEndX,obstacleEndY):
    print (robCoordXright,obstacleEndX)
    #while (robCoordXright<=obstacleEndX):
    while ((robCoordXright - obstacleEndX)< 10):
        #print ('skoko')
        #print (robCoordXright - obstacleEndX)
        xrob = 10
        yrob = 0
        event.wait()
        canvas.move (robot21, xrob,yrob)
        canvas.move (robot22, xrob,yrob)
        robCoordXright = robCoordXright + xrob
        event.clear()
        if (robCoordXright >=1000):
            break
        #canvas.after (1000)
        canvas.update ()
    while (obstacleEndY >= robCoordYright-distFirstLast):
        print (obstacleEndY, robCoordYright)
        xrob=0
        yrob=10
        event.wait()
        canvas.move (robot21,xrob,yrob)
        canvas.move (robot22,xrob,yrob)
        robCoordYright = robCoordYright +yrob
        event.clear()
        #canvas.after (1000)
        canvas.update ()


def recovery ():
    xrobleft = 10
    xrobright = -10
    yrob = 0
    distRob = robCoordXright - robCoordXleft
    while (distRob > 40):
        canvas.move(robot11, xrobleft,yrob)
        canvas.move(robot21, xrobright,yrob)
        robCoordleft = robCoordleft + xrobleft
        robCoordright = robCoordright+ xrobtight
        distRob = robCoordXright - robCoordXleft
        time.sleep(1)
        canvas.update()
#movement group 0 #2
def main(robCoordYleft,robCoordYright,distanceY,robCoordX1,obstacleEndX,obstacleStartX):
    while (robCoordYleft!=finalY):
        canvas.move('group0',xrob, yrob)
        robCoordYleft=robCoordYleft+yrob
        robCoordYright=robCoordYright+yrob
        distanceY=distanceY - yrob
        if (distanceY<=50 and robCoordX1<=obstacleEndX and robCoordX1>=obstacleStartX):
            break
            '''
            th1 = threading.Thread (target = left, args = (robCoordX1,robCoordYleft,obstacleStartX))
            th2 = threading.Thread (target = right, args = (robCoordX2,robCoordYright,obstacleEndX,obstacleEndY))
            th3 = threading.Thread (target = coordinator, args = [1])

            th1.start()
            th2.start()
            th3.start()
            '''
            #left(robCoordX1,obstacleStartX)
        time.sleep(1)
        canvas.update()

    th1 = threading.Thread (target = left, args = (robCoordX1,robCoordYleft,obstacleStartX))
    th2 = threading.Thread (target = right, args = (robCoordX2,robCoordYright,obstacleEndX, obstacleEndY))
    th3 = threading.Thread (target = coordinator, args = [1])

    th1.start()
    th2.start()
    th3.start()

    window.mainloop()
    th1.join()
    th2.join()
    th3.join()

#left(robCoordX1,robCoordY,obstacleStartX)
#right(robCoordX2,robCoordY2, obstacleEndX,obstacleEndY)
    #print (robCoordYright,robCoordYleft,obstacleEndY)
#if (robCoordYright > obstacleEndY and robCoordYleft > obstacleEndY):
#   recovery()
main(robCoordYleft,robCoordYright,distanceY,robCoordX1,obstacleEndX,obstacleStartX)
print ('OKKK')