from tkinter import *
from PIL import Image, ImageTk
import time, random

WINDOW_WIDTH = 1200
WINDOW_HEIGHT = 600
GEOMETRY_STRING = str(WINDOW_WIDTH)+'x'+str(WINDOW_HEIGHT)


paddle_1_image = "pong.gif"
paddle_2_image = "beer_pong.gif"
paddle_width, paddle_height = 100, 50
pong_ball_width, pong_ball_height = 50, 50

class Pong(Frame):
    def __init__(self, master = None):

        Frame.__init__(self,master)


        self.master = master
        self.master.title("PONG VS BEER PONG!")
        self.pong_dx = random.randint(5, 15)
        self.pong_dy = random.randint(5, 10)
        self.init_canvas()
        self.init_bindings()


    def init_canvas(self):
        C1 = Canvas(self.master)
        C2 = Canvas(self.master)
        self.C1 = C1
        self.C2 = C2
        C1.pack(side = 'left', fill = BOTH, expand = True)
        C2.pack(side = 'right', fill = BOTH, expand = True)


        self.C1_photo = ImageTk.PhotoImage(file = "space_background.gif")
        self.C1.create_image(0, 0, image = self.C1_photo, anchor = NW)
        self.C2_photo = ImageTk.PhotoImage(file = "space_4.gif")
        self.C2.create_image(0, 0, image = self.C2_photo,
                             anchor = NW)
        self.paddle_1_image = "pong.gif"
        self.original = Image.open(paddle_1_image)
        self.resized = self.original.resize((paddle_width, paddle_height),
                                            Image.ANTIALIAS)
        self.paddle_1_image = ImageTk.PhotoImage(self.resized)
        self.paddle_1 = C1.create_image(WINDOW_WIDTH / 4,
                                        0 + paddle_height / 2,
                                        image = self.paddle_1_image)

        self.paddle_2_image = "beer_pong.gif"
        self.original = Image.open(paddle_2_image)
        self.resized = self.original.resize((paddle_width, paddle_height),
                                            Image.ANTIALIAS)
        self.paddle_2_image = ImageTk.PhotoImage(self.resized)
        self.paddle_2 = C1.create_image(WINDOW_WIDTH / 4,
                                        WINDOW_HEIGHT - paddle_height / 2,
                                        image = self.paddle_2_image)

        self.animated_ball_image = "pong_ball.gif"
        self.original = Image.open(self.animated_ball_image)
        self.resized = self.original.resize((pong_ball_width,
                                             pong_ball_height),
                                            Image.ANTIALIAS)
        self.animated_ball_image = ImageTk.PhotoImage(self.resized)
        self.animated_ball = C1.create_image(WINDOW_WIDTH / 4,
                                             WINDOW_HEIGHT / 2,
                                             image = self.animated_ball_image)

        menu = Menu(self.master)
        self.master.config(menu = menu)

        file = Menu(menu)
        file.add_command(label = 'Resume', command = self.negate_chronos)
        file.add_command(label = 'Pause', command = self.chronos)
        file.add_command(label = 'Exit', command = self.client_exit)
        menu.add_cascade(label = 'File', menu = file)

        edit = Menu(menu)

        edit.add_command(label = 'New Ball Velocity',
                         command = self.new_velocity)
        edit.add_command(label = 'Slower Ball Velocity',
                         command = self.slower_ball_velocity)
        edit.add_command(label = 'Faster Ball Velocity',
                         command = self.faster_ball_velocity)
        #edit.add_command(label = 'Change Background',
                         #command = self.change_background)
        menu.add_cascade(label = 'Configure', menu = edit)

    def init_bindings(self):
        self.master.bind('<KeyPress-Up>', self.move_player_two)
        self.master.bind('<KeyPress-Down>', self.move_player_two)
        self.master.bind('<KeyPress-Left>', self.move_player_two)
        self.master.bind('<KeyPress-Right>', self.move_player_two)
        self.master.bind('<KeyPress-w>', self.move_player_two)
        self.master.bind('<KeyPress-s>', self.move_player_two)
        self.master.bind('<KeyPress-a>', self.move_player_two)
        self.master.bind('<KeyPress-d>', self.move_player_two)
        self.master.bind('<B1-Motion>', self.move_player_one)
        self.master.bind_all(self.animate_pong_ball)

    def new_velocity(self):
        self.pong_dx = random.randint(5, 15)
        self.pong_dy = random.randint(5, 10)

    def slower_ball_velocity(self):
        self.pong_dx = self.pong_dx / 2
        self.pong_dy = self.pong_dy / 2

    def faster_ball_velocity(self):
        self.pong_dx = self.pong_dx * 2
        self.pong_dy = self.pong_dy * 2

    def negate_chronos(self):
        time.sleep(0)

    def chronos(self):
        time.sleep(1000)

    def resize_paddles(self, image):
        original = Image.open(image)
        resized = original.resize((paddle_width, paddle_height),
                                  Image.ANTIALIAS)
        new_image = ImageTk.PhotoImage(resized)

        return new_image

    def client_exit(self):
        exit()

    def move_player_one(self, event):

        x1, y1 = self.C1.coords(self.paddle_1)
        x2 = self.C1.canvasx(event.x)
        y2 = self.C1.canvasy(event.y)
        self.C1.move(self.paddle_1, x2 - x1, y2 - y1)

    def move_player_two(self, event):

        DX = 10
        DY = 10

        if event.keysym == 'Up':
            self.C1.move(self.paddle_2, 0, -DY)
        elif event.keysym == 'Down':
            self.C1.move(self.paddle_2, 0, DY)
        elif event.keysym == 'Right':
            self.C1.move(self.paddle_2, DX, 0)
        elif event.keysym == 'Left':
            self.C1.move(self.paddle_2, -DX, 0)
        elif event.keysym == 'w':
            self.C1.move(self.paddle_2, 0, -DY)
        elif event.keysym == 's':
            self.C1.move(self.paddle_2, 0, DY)
        elif event.keysym == 'a':
            self.C1.move(self.paddle_2, -DX, 0)
        else:
            self.C1.move(self.paddle_2, DX, 0)

    def animate_pong_ball(self):
        self.C1.move(self.animated_ball, self.pong_dx, self.pong_dy)
        x1, y1 = self.C1.coords(self.animated_ball)
        if x1 <= 0:
            self.pong_dx *= -1
        elif x1 > WINDOW_WIDTH / 2:
            self.pong_dx *= -1
        if y1 <= 0:
            self.pong_dy *= -1
        elif y1 > WINDOW_HEIGHT:
            self.pong_dy *= -1

    def detect_collisions(self):

        p1_x, p1_y = self.C1.coords(self.paddle_1)
        p2_x, p2_y = self.C1.coords(self.paddle_2)
        b_x, b_y = self.C1.coords(self.animated_ball)

        if p1_x == b_x or p2_x == b_x:
            self.pong_dx *= -1
        if p1_y == b_y or p2_y == b_y:
            self.pong_dy *= -1
root = Tk()
root.geometry(GEOMETRY_STRING)

pong_app = Pong(root)
pong_app.pack()
pong_app.animate_pong_ball()

for x in range(100000):
    time.sleep(0.025)
    pong_app.animate_pong_ball()
    pong_app.detect_collisions()
    pong_app.C2.update()
root.mainloop()