import random
import pygame
import sys
from elephant import Elephant
from giraffe import Giraffe
from penguin import Penguin
from parrot import Parrot
from bear import Bear
from agent import Agent
from enclosure import Enclosure
from spawner import Spawner
from state_space_search import graphsearch

BLACK = (0, 0, 0)

GRID_SIZE = 50
GRID_WIDTH = 30
GRID_HEIGHT = 15

pygame.init()

WINDOW_SIZE = (GRID_WIDTH * GRID_SIZE, GRID_HEIGHT * GRID_SIZE)
screen = pygame.display.set_mode(WINDOW_SIZE)
pygame.display.set_caption("Mini Zoo")



background_image = pygame.image.load('images/tło.jpg')
background_image = pygame.transform.scale(background_image, WINDOW_SIZE)
fenceH = pygame.image.load('images/fenceHor.png')
fenceV = pygame.image.load('images/fenceVer.png')
gate = pygame.image.load('images/gate.png')


fences = set()
animals_position = set()



an1 = Parrot(16, 2)
an2 = Penguin(8, 6)
an3 = Bear(14, 9)
old_an2 = Giraffe(18,4, adult=True)
old_an1 = Elephant(4, 7, adult=True)
an4 = Elephant(4,3)

Animals = [an1, an2, an3, an4, old_an1, old_an2]

# Enclosure (lewy_górny_x, lewy_górny_y, prawy_dolny_x, prawy_dolny_y, brama, klimat, fenceH, fenceV, gate_obrazek)
en1 = Enclosure(1,5,  9,11, (9,6),"medium", fenceH, fenceV, gate)
en2 = Enclosure(13,1, 29,3, (16,3), 'medium', fenceH, fenceV, gate)
en3 = Enclosure(11,5, 16,11, (12,5),'cold', fenceH, fenceV, gate)
en4 = Enclosure(19,5, 30,11, (25,5),'hot', fenceH, fenceV, gate)
en5 = Enclosure(4,13, 28,15, (16,13),'cold', fenceH, fenceV, gate)


Enclosures = [en1, en2, en3, en4, en5]


def draw_grid():
    for y in range(0, GRID_HEIGHT * GRID_SIZE, GRID_SIZE):
        for x in range(0, GRID_WIDTH * GRID_SIZE, GRID_SIZE):
            rect = pygame.Rect(x, y, GRID_SIZE, GRID_SIZE)
            pygame.draw.rect(screen, BLACK, rect, 1)

def draw_enclosures():
    for enclosure in Enclosures:
        enclosure.draw(screen, GRID_SIZE, fences)

def draw_gates():
    for enclosure in Enclosures:
        enclosure.gatebuild(screen, GRID_SIZE)

def opengates():
    for enclosure in Enclosures:
        enclosure.gateopen(fences)

def draw_Animals():
    for Animal in Animals:
        Animal.draw(screen, GRID_SIZE)
        if Animal.feed() == 'True':
           Animal.draw_exclamation(screen, GRID_SIZE, Animal.x, Animal.y)
        else: 
            Animal.draw_food(screen,GRID_SIZE,Animal.x,Animal.y)

def spawn_all_animals():
    for Animal in Animals:
        spawner1 = Spawner(Animal, Enclosures)
        spawner1.spawn_animal(fences, animals_position)

def generate_obstacles():
    obstacles = []

    for en in Enclosures:
        # Pobierz współrzędne bramy
        gate_x, gate_y = en.gate
        gate_x -= 1
        gate_y -= 1
        
        # Dodaj lewy brzeg prostokąta
        for y in range(en.y1, en.y2 + 1):
            if (en.x1, y) != (gate_x, gate_y):
                obstacles.append((en.x1, y))

        # Dodaj prawy brzeg prostokąta
        for y in range(en.y1, en.y2 + 1):
            if (en.x2, y) != (gate_x, gate_y):
                obstacles.append((en.x2, y))

        # Dodaj górny brzeg prostokąta
        for x in range(en.x1+1, en.x2):
            if (x, en.y1) != (gate_x, gate_y):
                obstacles.append((x, en.y1))

        # Dodaj dolny brzeg prostokąta
        for x in range(en.x1+1, en.x2):
            if (x, en.y2) != (gate_x, gate_y):
                obstacles.append((x, en.y2))

    return obstacles

# region Obstacles Tests
# WHITE = (255,255,255)
# TRANSPARENT_BLACK = (0, 0, 0, 128)  # Półprzezroczysty czarny
# def draw_obstacles(obstacles):
#     for obstacle in obstacles:
#         x, y = obstacle
#         pygame.draw.rect(screen, TRANSPARENT_BLACK, (x * GRID_SIZE, y * GRID_SIZE, GRID_SIZE, GRID_SIZE))

# def main():
#     obstacles = generate_obstacles()  # Załóżmy, że masz funkcję generate_obstacles, która generuje listę przeszkód

#     # Pętla główna
#     running = True
#     while running:
#         # Obsługa zdarzeń
#         for event in pygame.event.get():
#             if event.type == pygame.QUIT:
#                 running = False

#         # Czyszczenie ekranu
#         screen.fill(WHITE)

#         # Rysowanie przeszkód
#         draw_obstacles(obstacles)

#         # Odświeżenie ekranu
#         pygame.display.flip()

#     # Wyjście z Pygame
#     pygame.quit()

# endregion

def main():
    initial_state = (1,1,'W')
    agent = Agent(initial_state, 'images/agent1.png', GRID_SIZE)
    
    obstacles = generate_obstacles()
    
    actions = []
    clock = pygame.time.Clock()
    
    spawned = False
    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
            agent.handle_event(event, GRID_WIDTH, GRID_HEIGHT, Animals, obstacles)

        screen.blit(background_image,(0,0))
        draw_grid()
        draw_enclosures()
        draw_gates()
        if not spawned:
            spawn_all_animals()
            
            # region Test szukania ścieżki
            animal = random.choice(Animals)
            actions = graphsearch(agent.istate, (animal.x, animal.y), GRID_WIDTH, GRID_HEIGHT, obstacles)
            animal._feed = 2 # Ustawienie aby zwierzę było głodne
            # endregion

            spawned = True
        draw_Animals()
        opengates()
        agent.draw(screen, GRID_SIZE)
        pygame.display.flip()
        clock.tick(10)
        
        if actions:
            action = actions.pop(0)
            agent.move(action, GRID_WIDTH, GRID_HEIGHT, obstacles, Animals)
            pygame.time.wait(200)
        
if __name__ == "__main__":
    main()