# simulates interactions of wild life
import math
import random
import pygame, sys
import random
import pdb
import time
from pygame.locals import *
import os


WINDOW_WIDTH = 1000
WINDOW_HEIGHT = 600

pygame.init()  # setsup pygame
screen = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))  # setsup screen size
clock = pygame.time.Clock()  # tells program how fast to update
timmer = 1  # how long program has gone on for

# colours
grey = (60, 60, 60)
dark_grey = (20, 20, 20)
dark_blue = (0, 0, 160)
black = (0, 0, 0)

preyPopulation = 0
predatorPopulation = 0



# classes-------------------------------------------------------------------
class Animal(pygame.sprite.Sprite):  # main class
    def __init__(self, image, x, y):
        super().__init__()
        self.image = image
        self.rect = self.image.get_rect(center=(x, y))
        self.energy = 10
        self.dist = 1000

    def move(self, mx, my):  # moves the sprite
        self.rect.x += mx
        self.rect.y += my

    def is_collided_with(self, sprite):  # is the eat function
        return self.rect.colliderect(sprite.rect)

    def checkEnergy(self):  # checks the energy of an animal
        EnergyVal = self.energy
        return EnergyVal



class Predator(Animal):  # class for predators
    def __init__(self, image, x, y):
        super().__init__(image, x, y)
        self.energy = 12
        self.starvetimmer = 0
        self.dist = 1000

    def reproduce(self):#reproduction function
        global predatorPopulation
        if self.energy >= 15:
            print("wolf reproducing...")
            predator = Predator(self.image, self.rect.x, self.rect.y)
            all_sprites.add(predator)
            Wolf_group.add(predator)
            self.energy -= 6#decreases sprites energy


    def Pack(self, predatorSpriteGroup):
        minDist = 200  # sets detect distance
        closestpredator = None
        hunted = False
        for predator in predatorSpriteGroup:
            tempdist = math.sqrt((self.rect.x - predator.rect.x) ** 2 + (self.rect.y - predator.rect.y) ** 2)
            if tempdist < self.dist and tempdist < minDist:
                minDist = tempdist
                closestpredator = predator
                hunted = True

        if closestpredator:
            xvariation = random.randint(-5, 5) * 10  # makes it so they arent always on the same position as
            yvariation = random.randint(-5, 5) * 10
            return closestpredator.rect.x + xvariation, closestpredator.rect.y + yvariation

    def findClosestPrey(self, preySpriteGroup):
        minDist = self.dist  # I'm guessing you are setting 1000 to be the max distance it will detect the prey?
        closestPrey = None
        for prey in preySpriteGroup:
            tempdist = math.sqrt((self.rect.x - prey.rect.x) ** 2 + (self.rect.y - prey.rect.y) ** 2)
            if tempdist < self.dist and tempdist < minDist:
                minDist = tempdist
                closestPrey = prey

        if closestPrey:
            return closestPrey.rect.x, closestPrey.rect.y

    def update(self):
        # something that should be done/checked in each game loop
        if self.energy <= 0:
            print("Wolf starved to death")
            self.kill()
        else:
            if self.starvetimmer == 160:
                self.energy -= 1
                self.starvetimmer = 0
            else:
                self.starvetimmer += 1

        if self.energy < 10:
            if Rabbit_group:
                preyX, preyY = self.findClosestPrey(Rabbit_group)
                movementx, movementy = Track(self.rect.x, preyX, self.rect.y, preyY)  # how the predators move
                self.move(movementx+0.2, movementy+0.2)
        else:
            self.Pack(Wolf_group)

        Leaving = leavingWindow(self.rect.x, self.rect.y)  # keeps sprites in window
        if Leaving == True:
            movementx, movementy = Boundry(self.rect.x, self.rect.y)
            self.rect.x = movementx
            self.rect.y = movementy


        rabbit_collision = pygame.sprite.spritecollide(self, Rabbit_group, True)
        if rabbit_collision:
            self.dist = 1000
            print("Ate rabbit")
            self.energy += 4  # increases the rabbits energy

        self.reproduce() #always call reproduce regardless because the function already checks energy requirements



class Prey(Animal):
    def __init__(self, image, x, y):
        super().__init__(image, x, y)
        self.energy = 7
        self.starvetimmer = 0
        self.dist = 1000

    def reproduce(self):
        global preyPopulation
        if self.energy >= 10 and preyPopulation < 20: #if enough energy and fewer than 20 total rabbits, reproduce
            print("Rabbit reproducing...")
            prey = Prey(self.image, self.rect.x - 50, self.rect.y + 50)  # elf.x, self.rect.y)
            all_sprites.add(prey)
            Rabbit_group.add(prey)
            self.energy -= 7
            preyPopulation += 1

    def findClosestPredator(self, predatorSpriteGroup):
        minDist = 100  # sets detect distance
        closestpredator = None
        hunted = False
        for predator in predatorSpriteGroup:
            tempdist = math.sqrt((self.rect.x - predator.rect.x) ** 2 + (self.rect.y - predator.rect.y) ** 2)
            if tempdist < self.dist and tempdist < minDist:
                minDist = tempdist
                closestpredator = predator
                hunted = True

        if closestpredator:
            return closestpredator.rect.x, closestpredator.rect.y, hunted
        else:
            return 0, 0, hunted

    def findClosestfood(self, foodSpriteGroup):

        minDist = self.dist  # sets detect distance
        closestfood = None
        for food in foodSpriteGroup:
            tempdist = math.sqrt((self.rect.x - food.rect.x) ** 2 + (self.rect.y - food.rect.y) ** 2)
            if tempdist < self.dist and tempdist < minDist:
                minDist = tempdist
                closestfood = food

        if closestfood:
            return closestfood.rect.x, closestfood.rect.y

    def update(self):
        # something that should be done/checked in each game loop
        if self.energy <= 0:
            print("Predator starved to death...")
            self.kill()
        else:
            if self.starvetimmer == 100:
                self.energy -= 1
                self.starvetimmer = 0
            else:
                self.starvetimmer += 1

        Leaving = leavingWindow(self.rect.x, self.rect.y)  # keeps sprites in window
        if Leaving == True:
            movementx, movementy = Boundry(self.rect.x, self.rect.y)
            self.rect.x = movementx
            self.rect.y = movementy

        wolfX, wolfY, hunted = self.findClosestPredator(Wolf_group)
        if hunted == True and self.energy >= 2:
            print("Running...")
            movementx, movementy = Runaway(self.rect.x, wolfX, self.rect.y, wolfY)  # how the prey move
            self.move(movementx, movementy)
        else:
            if self.energy < 10:
                if carrot_group:
                    foodX, foodY = self.findClosestfood(carrot_group)
                    movementx, movementy = Track(self.rect.x, foodX, self.rect.y, foodY)  # how the predators move
                    self.move(movementx, movementy)

        carrot_collision = pygame.sprite.spritecollide(self, carrot_group, True)
        if carrot_collision:
            self.dist = 1000
            print("Ate carrot")
            self.energy += 6 # increases the rabbits energy

        self.reproduce() #always call reproduce because the function already specifies energy requirements



class Carrot(pygame.sprite.Sprite):  # food for prey class
    def __init__(self, image, x, y):
        super().__init__()
        self.image = image
        self.rect = self.image.get_rect(center=(x, y))
        self.amount=0








# Functions--------------------------------------------------------------
def Track(AgressorX, DefenderX, AgressorY, DefenderY):  # finds comapres X and Y, tells sprite how to move
    if AgressorX > DefenderX:
        XMovement = -1
    elif AgressorX < DefenderX:
        XMovement = 1
    else:
        XMovement = 0

    if AgressorY > DefenderY:
        YMovement = -1
    elif AgressorY < DefenderY:
        YMovement = 1
    else:
        YMovement = 0
    return XMovement, YMovement


def Runaway(AgressorX, DefenderX, AgressorY, DefenderY):
    if AgressorX > DefenderX:
        XMovement = 1
    elif AgressorX < DefenderX:
        XMovement = -1
    else:
        XMovement = 1

    if AgressorY > DefenderY:
        YMovement = 1
    elif AgressorY < DefenderY:
        YMovement = -1
    else:
        YMovement = -1
    return XMovement, YMovement


def leavingWindow(Xpos, Ypos):  # boundry, keeps sprites in the window
    if Xpos <= 50:
        return True
    elif Xpos >= WINDOW_WIDTH-50:
        return True
    if Ypos <= 50:
        return True
    elif Ypos >= WINDOW_HEIGHT-50:
        return True


def Boundry(Xpos, Ypos):
    Xmovement = min(max(0, Xpos), WINDOW_WIDTH)
    ymovement = min(max(0, Ypos), WINDOW_HEIGHT)

    return Xmovement, ymovement


def button(screen, msg, x, y, width, height, inactiveColour, activecolour, action=None):  # setup buttons
    mouse = pygame.mouse.get_pos()  # gets mouses position
    click = pygame.mouse.get_pressed()  # sees if the mouse is clicked

    pygame.draw.rect(screen, activecolour, (x, y, width, height))
    txt = pygame.font.SysFont("comicsansms", 12)
    TextSurf, TextRect = text_objects(msg, txt)
    TextRect.center = (x + width // 2, y + height // 2)
    screen.blit(TextSurf, TextRect)

    global running

    if x + width > mouse[0] > x and y + height > mouse[1] > y:

        if click[0] == 1 and action != None:
            if action == "play":
                main_game()
            elif action == "quit":
                pygame.quit
                quit()
            elif action == "pause":
                paused()
            elif action == "unpause":
                return True
            elif action == "return":
                main_menu()
                running=False

    else:
        pygame.draw.rect(screen, inactiveColour, (x, y, width, height))
        txt = pygame.font.SysFont("comicsansms", 12)
        TextSurf, TextRect = text_objects(msg, txt)
        TextRect.center = (x + width // 2, y + height // 2)
        screen.blit(TextSurf, TextRect)

def Repopulate():
    if len(Rabbit_group)==0:
        for i in range(2):
            randomx = random.randrange(50, WINDOW_WIDTH-50)
            randomy = random.randrange(50, WINDOW_HEIGHT-50)

            prey = Prey(prey_image, randomx , randomy)
            all_sprites.add(prey)
            Rabbit_group.add(prey)

    if len(Wolf_group)==0:
        randomx = random.randrange(50, WINDOW_WIDTH-50)
        randomy = random.randrange(50, WINDOW_HEIGHT-50)

        predator = Predator(predator_image, randomx, randomy)
        all_sprites.add(predator)
        Wolf_group.add(predator)


#Test---------------------------------------------------------------------------------------------------------------

def text_objects(text, font):  # sets up the text
    textSurface = font.render(text, True, black)
    return textSurface, textSurface.get_rect()

#pause---------------------------------------------------------------------------------------------------------------
def paused():
    largeText = pygame.font.SysFont("comicsansms", 115)
    TextSurf, TextRect = text_objects("Paused", largeText)
    TextRect.center = ((1000 / 2), (200))
    screen.blit(TextSurf, TextRect)
    pause = True
    while pause:
        pygame.event.pump()

        for event in pygame.event.get():
            key = pygame.key.get_pressed()
            if event.type == pygame.QUIT:
                pause = False

            if key[pygame.K_ESCAPE]:
                pause = False

        if button(screen, "Continue", 350, 350, 100, 50, (25, 210, 25), (0, 255, 0), "unpause"):
            return
        button(screen, "Leave", 550, 350, 100, 50, (205, 25, 35), (255, 0, 0), "return")

        pygame.display.flip()

    pygame.quit()

    # classes and sprites--------------------------------------------------------


# setup sprite groups


prey_image = pygame.image.load('Prey.png')
predator_image=pygame.image.load('Icon.png')
carrot_image=pygame.image.load("carrot.png")

all_sprites = pygame.sprite.Group()

carrot_group = pygame.sprite.Group()

Wolf_group = pygame.sprite.Group()

Rabbit_group = pygame.sprite.Group()

# sets up multiple rabbits and carrots at start
for i in range(2):
    prey = Prey(prey_image, 100 * (i+1), 100)
    all_sprites.add(prey)
    Rabbit_group.add(prey)


predator = Predator(predator_image, 600, 500)
all_sprites.add(predator)
Wolf_group.add(predator)



for i in range(0, 10):  # makes random carrots
    randomx = random.randrange(50, WINDOW_WIDTH-50)
    randomy = random.randrange(50, WINDOW_HEIGHT-50)

    carrot = Carrot(carrot_image, randomx, randomy)
    carrot.amount+=1
    all_sprites.add(carrot)
    carrot_group.add(carrot)


# start of program
def main_game():
    timmer = 1
    carrotGrowth=0

    running = True
    while running:

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
        # buttons

        if carrotGrowth == 400:
            for i in range(0, 10):  # makes random carrots
                randomx = random.randrange(50, WINDOW_WIDTH - 50)
                randomy = random.randrange(50, WINDOW_HEIGHT - 50)

                carrot = Carrot(carrot_image, randomx, randomy)
                all_sprites.add(carrot)
                carrot_group.add(carrot)
                carrotGrowth = 0
        else:
            carrotGrowth += 1

        Repopulate()

        all_sprites.update()

        screen.fill((0, 128, 0))  # background
        all_sprites.draw(screen)  # makes the sprites
        button(screen, "pause", 0, 0, 100, 50, grey, dark_grey, "pause")
        pygame.display.flip()  # updates screen


        timmer += 1
        clock.tick(60)

    pygame.quit()
    exit()


# main menu setup-----------------------------------------------------


def main_menu():
    intro = True

    while intro:
        for event in pygame.event.get():

            if event.type == pygame.QUIT:
                pygame.quit()
                quit()

        screen.fill(dark_blue)
        largeText = pygame.font.SysFont("comicsansms", 100)
        TextSurf, TextRect = text_objects("Wildlife simulator", largeText)
        TextRect.center = ((1000 / 2), (200))
        screen.blit(TextSurf, TextRect)

        button(screen, "Start", 450, 300, 100, 50, grey, dark_grey, "play")
        button(screen, "Quit", 450, 400, 100, 50, grey, dark_grey, "quit")

        pygame.display.update()
        clock.tick(15)


play=True
while play==True:
    main_menu()


quit()