#!usr/bin/env python
# -*- coding: utf-8 -*-

# Se importan los modulos necesarios para el videojuego.
import pygame, sys
from pygame.locals import *
from random import choice, randint
from configuracion import *
from constantes import *
from utilidades import *

# Se importan las funciones del modulo funciones.py
from funciones import atrapar_insectos, brote_de_insectos, obtener_resultados, calcular_puntaje, obtener_estadisticas

# Se inicializan los modulos de pygame.
pygame.init()

# Se crea la ventana de juego.
ventana = pygame.display.set_mode((800, 600))
pygame.display.set_caption(TITULO_VENTANA)

# Se crean y se cargan los graficos del juego.
fondo_mapa = pygame.image.load("img/"+FONDO_MAPA).convert()
if fondo_mapa.get_size() != (800, 500): 
    fondo_mapa = pygame.transform.scale(fondo_mapa, (800, 500))

imagenes_insectos = dict()
for tipo, archivo in IMAGENES_ENEMIGOS.items():
    imagen = pygame.image.load("img/"+archivo).convert_alpha()
    if imagen.get_size() != (50, 50):
        imagen = pygame.transform.scale(imagen, (50, 50))
    if MODO_TEST:
        pygame.draw.circle(imagen, ROJO, (25, 25), 3)
        
    imagenes_insectos[tipo] = imagen

imagen_titulo = pygame.image.load("img/"+IMAGEN_TITULO).convert()
imagen_resultados = pygame.image.load("img/"+IMAGEN_RESULTADOS).convert()

imagen_monticulo = pygame.image.load("img/"+IMAGEN_MONTICULO).convert_alpha()
if imagen_monticulo.get_size() != (50, 50):
    imagen_monticulo = pygame.transform.scale(imagen_monticulo, (50, 50))
if MODO_TEST:
    w, h = imagen_monticulo.get_size()
    pygame.draw.circle(imagen_monticulo, ROJO, (w / 2, h / 2), 3)
    imagen_temp = pygame.Surface((2 * ALCANCE_MONTICULO, 2 * ALCANCE_MONTICULO))
    imagen_temp.fill(AZUL)
    imagen_temp.set_colorkey(AZUL)
    imagen_temp.blit(imagen_monticulo, (ALCANCE_MONTICULO - w / 2, ALCANCE_MONTICULO - h / 2))
    pygame.draw.rect(imagen_temp, ROJO, (0, 0, 2 * ALCANCE_MONTICULO, 2*ALCANCE_MONTICULO), 2)
    pygame.draw.line(imagen_temp, NEGRO, (ALCANCE_MONTICULO, ALCANCE_MONTICULO), (2 * ALCANCE_MONTICULO, ALCANCE_MONTICULO), 2)
    imagen_monticulo = imagen_temp

# Creacion del cursor.
imagen_cursor = pygame.Surface((RADIO_CURSOR * 2, RADIO_CURSOR * 2))
imagen_cursor.fill(NEGRO)
imagen_cursor.set_colorkey(NEGRO)
pygame.draw.circle(imagen_cursor, ROJO, (RADIO_CURSOR, RADIO_CURSOR), RADIO_CURSOR, 2)
pygame.draw.line(imagen_cursor, ROJO, (0, RADIO_CURSOR), (RADIO_CURSOR - 5, RADIO_CURSOR), 2)
pygame.draw.line(imagen_cursor, ROJO, (RADIO_CURSOR + 5, RADIO_CURSOR), (RADIO_CURSOR * 2, RADIO_CURSOR), 2)
pygame.draw.line(imagen_cursor, ROJO, (RADIO_CURSOR, 0), (RADIO_CURSOR, RADIO_CURSOR - 5), 2)
pygame.draw.line(imagen_cursor, ROJO, (RADIO_CURSOR, RADIO_CURSOR + 5), (RADIO_CURSOR, RADIO_CURSOR * 2), 2)

# Se cargan las fuentes de escritura y se renderizan algunos textos.
fuente_de_texto = pygame.font.Font("fuentes/PressStart2P.ttf", 11)
texto_objetivo = fuente_de_texto.render(TEXTO_OBJETIVO, True, BLANCO)
texto_tiempo = fuente_de_texto.render(TEXTO_TIEMPO, True, BLANCO)
texto_elementos_restantes = fuente_de_texto.render(TEXTO_ELEMENTOS_RESTANTES, True, BLANCO)
texto_advertencia = fuente_de_texto.render(TEXTO_ADVERTENCIA, True, BLANCO)

# Se crea el hud (zona que indica los datos de la partida).
fondo_hud = pygame.Surface((800, 100))
fondo_hud.fill(NEGRO)
hud = pygame.Surface((800, 100))
hud.fill(NEGRO)
hud.blit(texto_objetivo, (400 - texto_objetivo.get_width() / 2, 10))
hud.blit(texto_advertencia, (700, 10))
hud.blit(texto_elementos_restantes, (20, 50))
hud.blit(texto_tiempo, (20, 10))
hud.set_colorkey(NEGRO)

# Se carga el audio del juego.
ruido_fondo = pygame.mixer.Sound("audio/"+RUIDO_FONDO)
musica_fondo = pygame.mixer.Sound("audio/"+MUSICA_FONDO)
sonido_captura = pygame.mixer.Sound("audio/"+SONIDO_CAPTURA)
sonido_cambio_objetivo = pygame.mixer.Sound("audio/"+SONIDO_CAMBIO_OBJETIVO)

# Inicializacion y parametros de juego.
tipos_insectos = sorted(list(IMAGENES_ENEMIGOS))
insectos = inicializar_insectos(tipos_insectos, N_INSECTOS)
insectos_restantes = len(insectos)
atrapados = []
VELOCIDAD_INSECTOS = 25 * NIVEL_DE_JUEGO
monticulos = aparecer_monticulos(N_MONTICULOS)
objetivo = choice(tipos_insectos)
objetivo, peligro = establecer_objetivos(objetivo, tipos_insectos)
objetivo_actualizado = False

# Creacion de pantalla de resultados.
DIMENSIONES_BLOQUE = (500, 400)
ancho = DIMENSIONES_BLOQUE[0] / 5
alto = DIMENSIONES_BLOQUE[1] / (len(tipos_insectos) + 6)
bloque_resultados = pygame.Surface(DIMENSIONES_BLOQUE)
bloque_resultados.fill(NEGRO)
fuente_cantidades = pygame.font.Font("fuentes/PressStart2P.ttf", alto / 2)

# Se muestra la pantalla de titulo.
ventana.blit(imagen_titulo, (0, 0))
pygame.display.flip()

# Se espera hasta que el usuario presione la tecla Enter para comenzar.
tiempo_de_juego = -(pygame.time.get_ticks() / 1000.0)
esperando_click = True
while esperando_click:
    for event in pygame.event.get():
        if event.type == QUIT:
            sys.exit()
        elif event.type == KEYDOWN and event.key == K_ESCAPE:
            sys.exit()
        elif event.type == MOUSEBUTTONDOWN and event.button == 1:
            esperando_click = False
            break

# Se reproducen el ruido y la musica de fondo.
if PERMITIR_SONIDO:
    ruido_fondo.play(-1)
    musica_fondo.play(-1)

# Inicializacion del juego.
FPS_MAX = 30
reloj = pygame.time.Clock()
pygame.mouse.set_visible(False)
segundos = TIEMPO_TOTAL
salir = False

# Bucle principal del juego.
while segundos > 0 and (len(insectos) > 0 or len(monticulos) > 0):
    
    milisegundos = reloj.tick(FPS_MAX)
    pygame.display.set_caption("{0} | FPS: {1}".format(TITULO_VENTANA, int(reloj.get_fps())))
    tiempo_de_juego += milisegundos / 1000.0
    segundos = TIEMPO_TOTAL - int(tiempo_de_juego)
    
    # Manejo de eventos.
    for event in pygame.event.get():
        if event.type == QUIT:
            pygame.quit()
            sys.exit()
            
        if event.type == KEYDOWN:
            if event.key == K_ESCAPE:
                salir = True
                break
        
        if event.type == MOUSEBUTTONDOWN:
            if event.button == 1:
                cursor = (event.pos, RADIO_CURSOR)
                insectos, atrapados = atrapar_insectos(cursor, insectos, atrapados, objetivo, peligro)
                monticulos = brote_de_insectos(cursor, insectos, monticulos, tipos_insectos, N_INSECTOS_MONTICULO, ALCANCE_MONTICULO)
                insectos_restantes = len(insectos)
                if PERMITIR_SONIDO:
                    sonido_captura.play()
    
    # Salir del juego.
    if salir:
        break
    
    # Movimiento de los insectos.
    if not MODO_TEST:
        mover_insectos(insectos, milisegundos / 1000.0, VELOCIDAD_INSECTOS)
    
    # Se cambia el objetivo cada cierta cantidad de segundos.
    if segundos % TIEMPO_CAMBIO_OBJETIVO == 0:
        if not objetivo_actualizado:
            objetivo, peligro = establecer_objetivos(objetivo, tipos_insectos)
            if PERMITIR_SONIDO:
                sonido_cambio_objetivo.play()
        objetivo_actualizado = True
    else:
        objetivo_actualizado = False
        
    # Se renderizan los textos informativos.
    texto_tiempo_restante = fuente_de_texto.render("{0:02}:{1:02}".format(segundos / 60, segundos % 60), True, BLANCO)
    texto_insectos_restantes = fuente_de_texto.render(str(insectos_restantes), True, BLANCO)
    
    # Se actualiza el hud.    
    fondo_hud.fill(NEGRO)
    fondo_hud.blit(hud, (0, 0))
    fondo_hud.blit(imagenes_insectos[objetivo], (400 - imagenes_insectos[objetivo].get_width() / 2, 30))
    fondo_hud.blit(imagenes_insectos[peligro], (715, 30))
    fondo_hud.blit(texto_tiempo_restante, (20, 30))
    fondo_hud.blit(texto_insectos_restantes, (20, 70))
    
    # Se dibujan los elementos graficos.
    ventana.fill(NEGRO)
    ventana.blit(fondo_mapa, (0,0))
    dibujar_monticulos(ventana, monticulos, imagen_monticulo)
    dibujar_insectos(ventana, insectos, imagenes_insectos)
    
    # Obtencion de posicion y dibujado del cursor.
    x, y = pygame.mouse.get_pos()
    x -= RADIO_CURSOR
    y -= RADIO_CURSOR
    ventana.blit(imagen_cursor, (x, y))
    
    # Dibujado del hud.
    ventana.blit(fondo_hud, (0, 500))
    
    # Se refrezca la pantalla.
    pygame.display.update()

# Se detiene la musica de fondo.
if PERMITIR_SONIDO:
	pygame.mixer.stop()

# Se intenta obtener los resultados, puntaje y estadisticas de la partida.
try:
    resultados = obtener_resultados(atrapados, tipos_insectos)
    estadisticas = obtener_estadisticas(resultados)
    puntaje = calcular_puntaje(resultados, NIVEL_DE_JUEGO)
    dibujar_resultados(resultados, estadisticas, tipos_insectos, bloque_resultados, fuente_cantidades, alto, puntaje, TIEMPO_TOTAL - segundos)
except:
    pass
    
imagen_resultados.blit(bloque_resultados, (200, 90))
ventana.blit(imagen_resultados, (0, 0))
pygame.display.update()


# Se guarda una imagen de la pantalla de resultados.
pygame.image.save(imagen_resultados, "ultimo_resultado.jpg")

# Se espera a que el usuario haga click o presione la tecla Enter para salir.
pygame.mouse.set_visible(True)
esperando_click = True
while esperando_click:
    for event in pygame.event.get():
        if event.type == QUIT:
            esperando_click = False
        elif event.type == KEYDOWN and (event.key == K_ESCAPE or event.key == K_RETURN):
            esperando_click = False
        elif event.type == MOUSEBUTTONDOWN and event.button == 1:
            esperando_click = False

# Se finalizan los modulos de pygame.
pygame.quit()
sys.exit()

