import pygame
import sys
import random

pygame.init()

WIDTH = 800
HEIGHT = 800
CELL_SIZE = 40
GRID_SIZE = WIDTH // CELL_SIZE

WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
player_colors = [(255, 0, 0), (0, 0, 255)]

grid = []


def initialize_grid():
    global grid
    grid = [[None] * GRID_SIZE for _ in range(GRID_SIZE)]


def draw_pion(screen, x, y, color):
    position = (x * CELL_SIZE + CELL_SIZE // 2, y * CELL_SIZE + CELL_SIZE // 2)
    pygame.draw.circle(screen, color, position, CELL_SIZE // 2 - 2)


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

            if grid[y][x] is not None:
                color = pygame.Color(player_colors[grid[y][x]])
                draw_pion(screen, x, y, color)


def place_pion(player, x, y):
    global grid
    if grid[y][x] is None:
        grid[y][x] = player
        return True
    return False


def change_pion(player, x, y):
    global grid
    if grid[y][x] is not None and grid[y][x] != player:
        grid[y][x] = player
        return True





def expand_pions(player):
    global grid
    new_positions = []

    for y in range(GRID_SIZE):
        for x in range(GRID_SIZE):
            if grid[y][x] == player:
                for dy in (-1, 0, 1):
                    for dx in (-1, 0, 1):
                        ny, nx = y + dy, x + dx
                        if 0 <= nx < GRID_SIZE and 0 <= ny < GRID_SIZE and grid[ny][nx] is None:
                            new_positions.append((nx, ny))

    for position in new_positions:
        grid[position[1]][position[0]] = player


def check_neighbors(x, y, player):
    global grid
    neighbors = [
        (x - 1, y),
        (x + 1, y),
        (x, y - 1),
        (x, y + 1),
    ]

    colors_found = set()
    for nx, ny in neighbors:
        if 0 <= nx < GRID_SIZE and 0 <= ny < GRID_SIZE and grid[ny][nx] is not None:
            colors_found.add(grid[ny][nx])

    return colors_found


def pierre_feuille_ciseaux(player1, player2):
    choices = ["pierre", "feuille", "ciseaux"]
    choice1 = choices[random.randint(0, 2)]
    choice2 = choices[random.randint(0, 2)]

    print("Joueur", player1 + 1, ":", choice1)
    print("Joueur", player2 + 1, ":", choice2)

    if (choice1 == "pierre" and choice2 == "ciseaux") or (choice1 == "feuille" and choice2 == "pierre") or (
            choice1 == "ciseaux" and choice2 == "feuille"):
        return player1
    if choice1 == choice2:
        return None
    return player2


def is_game_over(start_phase):
    if start_phase:
        return False
    for row in grid:
        if None in row:
            return False
    return True


def count_pions(player):
    count = 0
    for row in grid:
        for cell in row:
            if cell == player:
                count += 1
    return count


def play_game():
    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    clock = pygame.time.Clock()
    pygame.display.set_caption("Jeu de connexion")

    initialize_grid()

    start_phase = True
    running = True
    game_over = False
    turn = 0
    grid_x, grid_y = -1, -1
    
    while running:
        colors_found = set()
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.MOUSEBUTTONUP:
                x, y = pygame.mouse.get_pos()
                grid_x, grid_y = x // CELL_SIZE, y // CELL_SIZE
                if start_phase:
                    if count_pions(turn) == 0:
                        place_pion(turn, grid_x, grid_y)
                        turn = (turn + 1) % len(player_colors)
                    if count_pions(turn) == 1:
                        start_phase = False
                        turn = 0
                else:
                    if place_pion(turn, grid_x, grid_y):
                        neighbors = [
                            (grid_x - 1, grid_y),
                            (grid_x + 1, grid_y),
                            (grid_x, grid_y - 1),
                            (grid_x, grid_y + 1),
                        ]
    
                        for nx, ny in neighbors:
                            if 0 <= nx < GRID_SIZE and 0 <= ny < GRID_SIZE and grid[ny][nx] is not None:
                                colors_found.add(grid[ny][nx])
    
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_SPACE and len(colors_found) == 2 and (grid[grid_y][grid_x] is None or grid[grid_y][grid_x] is not None and len(check_neighbors(grid_x, grid_y, grid[grid_y][grid_x])) < 4):
                    winner = pierre_feuille_ciseaux(list(colors_found)[0], list(colors_found)[1])

                    if winner is not None:
                        print("Le gagnant est le joueur", winner + 1)
                        change_pion(winner, grid_x, grid_y)
                        expand_pions(turn)
                    turn = (turn + 1) % len(player_colors)

            screen.fill(WHITE)
            draw_grid(screen)
            pygame.display.flip()
            clock.tick(60)

            if not game_over and is_game_over(start_phase):
                winner = 0 if count_pions(0) > count_pions(1) else 1
                print("Le joueur", winner + 1, "a gagné!")
                game_over = True
            
            
    pygame.quit()
    sys.exit()


if __name__ == "__main__":
    play_game()
    la touche espace ne fonctionne pas