import sys
import random
import pygame as pg
from modules.agente import Agente
from modules.mapa import Mapa
import modules.estrategia as ModEstrategia

flags = 0


def devolveCor(agente: Agente | None) -> tuple[int, int, int, int]:
    if type(agente) is None:
        return (0, 0, 0, 0)
    else:
        match agente.estrategia:
            case "Neutro":
                return (255, 255, 255, 0)
            case "Tit4Tat":
                return (255, 255, 0, 0)
            case "Vingativo":
                return (255, 0, 0, 0)
            case "Lunatico":
                return (0, 0, 255, 0)
            case _:
                return (0, 0, 0, 0)


def criarTabuleiro(
    surface: pg.Surface,
    dimensao_tabuleiro: tuple[int, int],
    mapa: Mapa | None,
) -> None:
    dimensoes_surface_principal: tuple[int, int] = surface.get_size()
    max_altura: int = int(
        (dimensoes_surface_principal[0]-20)/dimensao_tabuleiro[0])
    max_largura: int = int(
        (dimensoes_surface_principal[1]-20)/dimensao_tabuleiro[1])
    tamanho_quadrado: int = max_altura if max_altura < max_largura else max_largura
    cor_quadrado: tuple[int, int, int, int]

    for pos_y in range(0, dimensao_tabuleiro[0]):
        for pos_x in range(0, dimensao_tabuleiro[1]):
            agente: Agente | None = mapa.posicao((pos_y, pos_x))
            cor_quadrado = devolveCor(agente)
            pg.draw.rect(surface,
                         cor_quadrado,
                         [10+(tamanho_quadrado*pos_y),
                          10+(tamanho_quadrado*pos_x),
                          tamanho_quadrado, tamanho_quadrado],
                         0)


def popularMapa(mapa: Mapa) -> None:
    for pos_y in range(0, mapa.dimensao[0]):
        for pos_x in range(0, mapa.dimensao[1]):
            # escolher uma estrategia aleatoria
            tmp_estrategia = random.choice(
                ModEstrategia.listaNomesEstrategias())
            # criar Agente com estrategia aleatoria e colocar na posicao y e x
            mapa.mundo[pos_y][pos_x] = Agente(tmp_estrategia)


def mostrarEstatisticas(mapa: Mapa | None) -> None:
    if mapa is None:
        print("SEM MAPA!!")
    else:
        stats_estrategias: dict = {}
        n_total_agentes: int = 0
        print("estatisticas mapa:")
        for tipo_estrategia in ModEstrategia.lista_estrategias:
            stats_estrategias[tipo_estrategia] = 0
        for pos_y in range(0, mapa.dimensao[0]):
            for pos_x in range(0, mapa.dimensao[1]):
                tmp_agente = mapa.posicao((pos_y, pos_x))
                stats_estrategias[tmp_agente.estrategia] += 1
                n_total_agentes += 1
        for tipo_estrategia in stats_estrategias:
            print(f"{tipo_estrategia}: {
                  (stats_estrategias[tipo_estrategia]/n_total_agentes)*100:3.2f}")


def main(mapa: Mapa | None):
    if mapa is None:
        print("SEM MAPA!!")
    pg.init()
    janela = pg.display.set_mode((1280, 800), flags)
    pg.display.set_caption("Game Theory of Life")
    clock = pg.time.Clock()

    running: bool = True
    cor1: tuple[int, int, int, int] = (255, 0, 0, 0)
    cor2: tuple[int, int, int, int] = (0, 255, 0, 0)

    while running:
        for event in pg.event.get():
            if event.type == pg.QUIT:
                running = False
            if event.type == pg.KEYDOWN:
                if event.key == pg.K_q:
                    running = False
                if event.key == pg.K_c:
                    mapa = Mapa((30, 30))
                    popularMapa(mapa)
                if event.key == pg.K_s:
                    mostrarEstatisticas(mapa)
                if event.key == pg.K_n:
                    # correr proxima iteracao do jogo
                    pass

        # (367, 250)
        criarTabuleiro(janela, mapa.dimensao, mapa)
        correrInteraccoesEntreAgentes(mapa)
        pg.display.flip()
        clock.tick(60)

    pg.quit()
    sys.exit()


if __name__ == '__main__':
    mapa_mundo: Mapa = Mapa((10, 10))
    app = main(mapa_mundo)