import pygame as pg
import random


# Opciones
TAM_VENTANA = 400
TAM_PIXEL = 20
COLOR_FONDO = 255, 255, 255
NEGRO = 0, 0, 0
COLOR_MANZANA = 87,166,57
COLOR_SERPIENTE = 255,69,0
FPS = 10


# Variables globales
CENTRO= [int(TAM_VENTANA / 2)] * 2
cuadricula = int(TAM_VENTANA / TAM_PIXEL)
posiciones_serpiente = []
contrario = {pg.K_UP: pg.K_DOWN, pg.K_DOWN: pg.K_UP, pg.K_LEFT: pg.K_RIGHT, pg.K_RIGHT: pg.K_LEFT}
pierde = False


class Manzana:
    def __init__(self):
        self.tam = TAM_PIXEL
        self.img = pg.Surface((TAM_PIXEL, TAM_PIXEL))
        self.img.fill(COLOR_MANZANA)
        self.mover()

    def _celdas_libres(self):
        for y in range(cuadricula):
            for x in range(cuadricula):
                pos = [x * TAM_PIXEL, y *TAM_PIXEL]
                if pos not in posiciones_serpiente:
                    yield pos

    def mover(self):
        celdas_libres = list(self._celdas_libres())
        self.pos = random.choice(celdas_libres)


class Serpiente:
    def __init__(self):
        self.pos = [CENTRO]
        self.pixel = pg.Surface((TAM_PIXEL, TAM_PIXEL))
        self.pixel.fill(COLOR_SERPIENTE)

    def mover_cabeza(self, tecla):
        if tecla == pg.K_UP:
            self.pos[0][1] -= 1 * TAM_PIXEL
        elif tecla == pg.K_DOWN:
            self.pos[0][1] += 1 * TAM_PIXEL
        if tecla == pg.K_RIGHT:
            self.pos[0][0] += 1 * TAM_PIXEL
        elif tecla == pg.K_LEFT:
            self.pos[0][0] -= 1 * TAM_PIXEL
        self.pos[0] = self.desborde(self.pos[0])

    def comprobar_pierde(self):
        global pierde
        # Se come a si misma
        if self.pos[0] in self.pos[1:]:
            pierde = True

    def desborde(self, pos):
        suma = 0,0
        # Desborde horizontal
        if pos[1] < 0:
            suma = 0, TAM_VENTANA
        elif pos[1] >= TAM_VENTANA:
            suma = 0, -(TAM_VENTANA + TAM_PIXEL)
        # Desborde vertical
        if pos[0] < 0:
            suma = TAM_VENTANA, 0
        elif pos[0] >= TAM_VENTANA:
            suma = -(TAM_VENTANA + TAM_PIXEL), 0

        pos[0] += suma[0]
        pos[1] += suma[1]
        return pos

    def mover(self, tecla):
        global posiciones_serpiente
        x_ant, y_ant = self.pos[0]
        self.mover_cabeza(tecla)
        # Mover el cuerpo hacia delante
        for pos in self.pos[1:]:
            x, y = x_ant, y_ant
            x_ant, y_ant = pos[0], pos[1]
            pos[0], pos[1] = x, y
        self.comprobar_pierde()
        posiciones_serpiente = self.pos

    def crecer(self, posicion_manzana):
        self.pos.append(posicion_manzana)


def main():
    pg.init()
    ventana = pg.display.set_mode((TAM_VENTANA, TAM_VENTANA))
    serpiente = Serpiente()
    manzana = Manzana()
    pg.display.set_caption('Snake')
    fuente_puntos = pg.font.SysFont('arial', 30, bold=True)
    fuente_game_over = pg.font.SysFont('arial', 40, bold=True)
    run = True
    tecla = None
    while run:
        ventana.fill(COLOR_FONDO)
        if pierde:
            ventana.fill(NEGRO)
            ventana.blit(fuente_game_over.render('GAME OVER', 1, (255,255,255)), (75,125))
            for e in pg.event.get():
                if e.type == pg.QUIT: run = False
        else:
            for e in pg.event.get():
                if e.type == pg.QUIT: run = False

                if e.type == pg.KEYDOWN: # Se apreta una tecla
                    if tecla != contrario[e.key]: # No se puede cambiar de dirección
                        tecla = e.key
                        break

            for pos in serpiente.pos:
                ventana.blit(serpiente.pixel, pos)

            ventana.blit(manzana.img, manzana.pos)

            puntos = fuente_puntos.render(str(len(serpiente.pos)), 1, (0, 0, 0))
            ventana.blit(puntos, (2, 2))

            # Mover la serpiente
            if tecla:
                serpiente.mover(tecla)

            # Aumetar el tamaño si come
            if serpiente.pos[0] == manzana.pos:
                serpiente.mover(tecla)
                serpiente.crecer(manzana.pos)
                manzana.mover()

        # Redibujar
        pg.display.flip()
        pg.time.Clock().tick(FPS)

    # Al salir del bucle se cierra
    pg.quit()

main()