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

#   Main.py por:
#   Flavio Danesse <fdanesse@gmail.com>
#   CeibalJAM! - Uruguay

# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

import pygame, sys, threading, random, gc, gtk, pygtk
from pygame.locals import *

gc.enable()

import BiblioJAM
from BiblioJAM.JAMButton import JAMButton
from BiblioJAM.JAMLabel import JAMLabel
from BiblioJAM.JAMDialog import JAMDialog
import BiblioJAM.JAMGlobals as JAMG

import Globals as VG
from Cria_Bichos_Main import Cria_Bichos_Main, Ooteca
from Archivos_y_Directorios import Archivos_y_Directorios
from Bicho import Bicho

def Traduce_posiciones(VA, VH):
	eventos= pygame.event.get(pygame.MOUSEBUTTONDOWN)
	for event in eventos:
		x, y = event.pos
		xx= x/VA
		yy= y/VH
		event_pos= (xx, yy)
	for event in eventos:
		evt = pygame.event.Event(pygame.MOUSEBUTTONDOWN, pos= event_pos, button=event.button)
		pygame.event.post(evt)

	eventos= pygame.event.get(pygame.MOUSEMOTION)
	for event in eventos:
		x, y = event.pos
		xx= x/VA
		yy= y/VH
		event_pos= (xx, yy)
	for event in eventos:
		evt = pygame.event.Event(pygame.MOUSEMOTION, pos= event_pos, rel=event.rel, buttons=event.buttons)
		pygame.event.post(evt)

class Main():
	def __init__(self, res= None):
		self.resolucionreal= res
		# Variables para JAMatrix
		self.ventana= None
		self.name= "CucaraSims"

		# Variables del Juego
		self.fondo= None
		self.reloj= None

		# Escalado
		self.ventana_real= None
		self.VA= None
		self.VH= None

		self.sonido_select = None
		self.sprites = pygame.sprite.OrderedUpdates()
		self.Archivos_y_Directorios = None
		self.base_de_datos = None
		self.creditos = None
		self.dialog_cerrar = None
		self.menu = None
		self.mensaje = None
		self.Cria_Bichos= None

		self.interval = 0
		self.nivel = None

		self.Juegos_guardados = None

		self.preset()
		self.load()
		self.run()

	def run(self):
		self.nivel = "Menu"
		self.sprites= self.menu
		self.RunMenu()

	def RunMenu(self):
		pygame.mouse.set_visible(True)
		self.Cria_Bichos.set_musica()
		self.fondo= self.get_fondo2()
		self.ventana.blit(self.fondo, (0,0))
		self.ventana_real.blit(pygame.transform.scale(self.ventana, self.resolucionreal), (0,0))
		pygame.display.update()
		
		while self.nivel == "Menu":
			self.reloj.tick(35)
			while gtk.events_pending():
			    	gtk.main_iteration(False)
			Traduce_posiciones(self.VA, self.VH)
			if self.mensaje: self.pause_menu()
			self.sprites.clear(self.ventana, self.fondo)
			self.sprites.update()
			self.handle_event()
			pygame.event.clear()
			self.sprites.draw(self.ventana)
			self.ventana_real.blit(pygame.transform.scale(self.ventana, self.resolucionreal), (0,0))
			pygame.display.update()

		if self.nivel == "CucaraSims":
			self.Cria_Bichos.Run()
		if self.nivel == "Creditos":
			self.RunCreditos()

	def handle_event(self):
		if pygame.event.get(pygame.VIDEORESIZE): print "OK"
		for event in pygame.event.get(pygame.KEYDOWN):
			tecla= event.key
			if tecla== pygame.K_ESCAPE:
				if self.nivel == "Menu" and not self.mensaje:
					self.selecciona_mensaje_cerrar(None)					
				elif self.nivel == "Creditos":
					self.nivel = "Menu"
				elif self.mensaje:
					self.deselecciona_mensaje(None)

	def pause_menu(self):
		self.ventana.blit(self.fondo, (0,0))
		while self.mensaje.sprites():
			self.reloj.tick(35)
			while gtk.events_pending():
			    	gtk.main_iteration(False)
			Traduce_posiciones(self.VA, self.VH)
			self.mensaje.clear(self.ventana, self.fondo)
			self.mensaje.update()
			self.handle_event()
			pygame.event.clear()
			self.mensaje.draw(self.ventana)
			self.ventana_real.blit(pygame.transform.scale(self.ventana, self.resolucionreal), (0,0))
			pygame.display.update()

	def deselecciona_mensaje(self, button= None):
		self.mensaje= pygame.sprite.OrderedUpdates()

	def selecciona_mensaje_cerrar(self, button= None):
		self.mensaje= self.dialog_cerrar

	def selecciona_menu_cargar(self, button= None):
		self.deselecciona_mensaje(None)
		self.Juegos_guardados= Juegos_Guardados(self.Archivos_y_Directorios, self)
		self.mensaje= self.Juegos_guardados
	
	def cargar_juego(self, datos):
	# Carga el juegon Juego guardado seleccionado
		# poner todo a cero
		self.Cria_Bichos.Bichos.empty()
		self.Cria_Bichos.cadaveres.empty()
		self.Cria_Bichos.alimento.empty()
		self.Cria_Bichos.ootecas.empty()
		self.Cria_Bichos.agua.empty()
		self.Cria_Bichos.ficha = pygame.sprite.OrderedUpdates()
		self.Cria_Bichos.puntos = 0
		self.Cria_Bichos.tiempo_de_juego = 0
		self.Cria_Bichos.horas = 0
		self.Cria_Bichos.dias = 0
		self.Cria_Bichos.anios = 0
		self.Cria_Bichos.machos, self.Cria_Bichos.hembras = 0,0

		self.Cria_Bichos.secuencia_muda = 0
		self.Cria_Bichos.reproduccion = 0
		self.Cria_Bichos.nacimientos = 0
		self.Cria_Bichos.muertes = 0
		self.Cria_Bichos.plaga = 0

		# recuperar datos
		(base, datos_juego, cucas, ootecas) = datos # return (base, datos_juego, cucas, Ootecas)

		self.base_de_datos = base

		# datos generales del juego
		# datos 0 Tabla Juego [anios, dias, horas, puntos]
		self.Cria_Bichos.anios = int(datos_juego[1])
		self.Cria_Bichos.dias = int(datos_juego[2])
		self.Cria_Bichos.horas = int(datos_juego[3])
		self.Cria_Bichos.puntos = int(datos_juego[4])

		for cuca in cucas:
		# datos de cucarachas
		# datos 1 Tabla Cucas [sexo, anios, dias, horas, hambre, sed]
			contador, sexo, anios, dias, horas, hambre, sed = cuca
			tipo = None
			while tipo != sexo:
				bicho = Bicho(self.Cria_Bichos)
				tipo = bicho.sexo
			self.Cria_Bichos.Bichos.add(bicho)

			if bicho.sexo == "M":
				self.Cria_Bichos.machos += 1
			elif bicho.sexo == "F":
				self.Cria_Bichos.hembras += 1

			bicho.anios = int(anios)
			bicho.dias = int(dias)
			bicho.horas = int(horas)
			bicho.hambre = int(hambre)
			bicho.sed = int(sed)

			# escalar
			for dia in range (0, bicho.dias):
			# desde dia cero hasta los dias que tiene el bicho
				if dia == bicho.control_mudas: # bicho.control_mudas es una lista de dias de mudas

					indice = bicho.dias_mudas.index(dia)
					bicho.set_muda(escala=bicho.escalas_mudas[indice]) # se obtiene el tamaño
					bicho.velocidad += int(bicho.velocidad/3)
	
					if indice+1 < len(bicho.dias_mudas):
						bicho.control_mudas = bicho.dias_mudas[indice+1]
					else:
						bicho.control_mudas = bicho.dias_mudas[0]

			print "CUCA: ", bicho.anios, bicho.dias, bicho.horas, bicho.hambre, bicho.sed

		if self.Cria_Bichos.hembras + self.Cria_Bichos.machos != len(cucas):
			print "HAY INCOHERENCIAS DE CANTIDAD DE BICHOS ALMACENADOS/CARGADOS"

		for ooteca in ootecas:
		# datos de cucarachas
		# datos 2 Tabla ootecas [dias, horas, huevos]
			contador, dias, horas, huevos = ooteca
			ooteca = Ooteca(self.Cria_Bichos, posicion=(0,0))
			self.Cria_Bichos.ootecas.add(ooteca)
			ooteca.dias = int(dias)
			ooteca.horas = int(horas)
			ooteca.huevos = int(huevos)
			print "ooteca: ", ooteca.dias, ooteca.horas, ooteca.huevos

		self.deselecciona_mensaje(None)
		self.nivel = "CucaraSims"

	def get_new_game(self, button):
		self.base_de_datos= self.Archivos_y_Directorios.CrearBasededatos()
		self.Cria_Bichos.get_nuevo_Juego()
		if self.base_de_datos:
			self.nivel = "CucaraSims"
		else:
			print "Error al crear la base de datos"
		#self.nivel = "CucaraSims"

	def RunCreditos(self):
		pygame.mixer.music.load(VG.MUSICA2)
		pygame.mixer.music.play(-1, 0.0)
		self.ventana.blit(self.fondo, (0,0))
		pygame.display.update()
		while self.nivel == "Creditos":
			self.reloj.tick(35)
			while gtk.events_pending():
			    	gtk.main_iteration(False)
			Traduce_posiciones(self.VA, self.VH)
			self.creditos.clear(self.ventana, self.fondo)
			self.creditos.update()
			self.handle_event()
			pygame.event.clear()
			self.creditos.draw(self.ventana)
			self.ventana_real.blit(pygame.transform.scale(self.ventana, self.resolucionreal), (0,0))
			pygame.display.update()
		if self.nivel == "Menu":
			self.RunMenu()

	def get_fondo2(self, tamanio=VG.RESOLUCION):
		superficie = pygame.transform.scale(pygame.image.load(VG.FONDO4), (VG.RESOLUCION))
		return superficie

	def get_creditos(self, button):
		self.nivel= "Creditos"

	def preset(self):
		pygame.mouse.set_visible(False)
		pygame.display.set_mode( (0,0), pygame.DOUBLEBUF | pygame.FULLSCREEN, 0)
		A, B= VG.RESOLUCION
		self.ventana= pygame.Surface( (A, B), flags=HWSURFACE )
		self.ventana_real= pygame.display.get_surface()
		C, D= (0, 0)
		if not self.resolucionreal:
			C= pygame.display.Info().current_w
			D= pygame.display.Info().current_h
			self.resolucionreal= (C,D)
		else:
			C, D= self.resolucionreal
		self.VA= float(C)/float(A)
		self.VH= float(D)/float(B)
		pygame.display.set_caption("CucaraSims")
		pygame.event.set_blocked([JOYAXISMOTION, JOYBALLMOTION, JOYHATMOTION, JOYBUTTONUP, JOYBUTTONDOWN,
					KEYUP, VIDEORESIZE, VIDEOEXPOSE, USEREVENT, QUIT, ACTIVEEVENT])
		pygame.event.set_allowed([MOUSEMOTION, MOUSEBUTTONUP, MOUSEBUTTONDOWN, KEYDOWN])

	def load(self):
		pygame.mixer.init()
		if not self.Archivos_y_Directorios: self.Archivos_y_Directorios= Archivos_y_Directorios(VG.DIRECTORIO_DATOS)
 		if not self.sonido_select: self.sonido_select= JAMG.get_sound_select()
		if not self.reloj: self.reloj= pygame.time.Clock()
		if not self.fondo: self.fondo= self.get_fondo()
		if not self.menu:
			self.menu= Menu()
			self.menu.boton_nuevo.connect(callback= self.get_new_game, sonido_select= self.sonido_select)
			self.menu.boton_cargar.connect(callback= self.selecciona_menu_cargar, sonido_select= self.sonido_select)
			self.menu.boton_creditos.connect(callback= self.get_creditos, sonido_select= self.sonido_select)
			self.menu.boton_salir.connect(callback= self.selecciona_mensaje_cerrar, sonido_select= self.sonido_select)

		if not self.creditos: self.creditos= Creditos(self)

		if not self.dialog_cerrar:
			a,b,c= JAMG.get_estilo_naranja()
			self.dialog_cerrar= JAMDialog(mensaje= "¿Deseas Salir del Juego?",
				funcion_ok= self.salir, funcion_cancel= self.deselecciona_mensaje)
			self.dialog_cerrar.set_colors_dialog(base= c, bordes= b)
			self.dialog_cerrar.set_colors_buttons(colorbas= a, colorbor= b, colorcara= c)

		if not self.Cria_Bichos: self.Cria_Bichos= Cria_Bichos_Main(self)

	def get_fondo(self, color=(0,0,0,1), tamanio=VG.RESOLUCION):
		superficie = pygame.Surface( tamanio, flags=HWSURFACE )
		superficie.fill(color)
		return superficie

	def salir(self, button):
		pygame.quit()
		sys.exit()	

class Menu(pygame.sprite.OrderedUpdates):
	def __init__(self):
		pygame.sprite.OrderedUpdates.__init__(self)

		separador = 40
		ancho = 500
		alto = 100

		a,b,c= JAMG.get_estilo_celeste()
		self.boton_nuevo = JAMButton("Juego Nuevo", None)
		self.boton_cargar = JAMButton("Cargar Juego", None)
		self.boton_creditos = JAMButton("Creditos", None)
		self.boton_salir = JAMButton("Salir", None)

		self.boton_nuevo.set_text(tamanio= 50)
		self.boton_cargar.set_text(tamanio= 50)
		self.boton_creditos.set_text(tamanio= 50)
		self.boton_salir.set_text(tamanio= 50)

		self.boton_nuevo.set_tamanios(tamanio= (ancho,alto))
		self.boton_cargar.set_tamanios(tamanio= (ancho,alto))
		self.boton_creditos.set_tamanios(tamanio= (ancho,alto))
		self.boton_salir.set_tamanios(tamanio= (ancho,alto))

		self.boton_nuevo.set_colores(colorbas= a, colorbor= b, colorcara= c)
		self.boton_cargar.set_colores(colorbas= a, colorbor= b, colorcara= c)
		self.boton_creditos.set_colores(colorbas= a, colorbor= b, colorcara= c)
		self.boton_salir.set_colores(colorbas= a, colorbor= b, colorcara= c)

		y = 150
		x = VG.RESOLUCION[0]/2 - self.boton_nuevo.get_tamanio()[0]/2
		self.boton_nuevo.set_posicion(punto=(x,y))

		y += self.boton_nuevo.get_tamanio()[1] + separador
		x = VG.RESOLUCION[0]/2 - self.boton_cargar.get_tamanio()[0]/2
		self.boton_cargar.set_posicion(punto=(x,y))

		y += self.boton_cargar.get_tamanio()[1] + separador
		x = VG.RESOLUCION[0]/2 - self.boton_creditos.get_tamanio()[0]/2
		self.boton_creditos.set_posicion(punto=(x,y))

		y += self.boton_creditos.get_tamanio()[1] + separador
		x = VG.RESOLUCION[0]/2 - self.boton_salir.get_tamanio()[0]/2
		self.boton_salir.set_posicion(punto=(x,y))

		self.add(self.boton_nuevo)
		self.add(self.boton_cargar)
		self.add(self.boton_creditos)
		self.add(self.boton_salir)

class Creditos(pygame.sprite.OrderedUpdates):
	def __init__(self, main):
		pygame.sprite.OrderedUpdates.__init__(self)
		self.grupo1 = {}
		self.grupo2 = {}
		self.get_sprites()
		self.seleccion = 1
		self.velocidad = 4
	
		self.main= main
		self.cerrar= JAMButton("", None)
		self.cerrar.set_imagen(origen= JAMG.get_icon_exit())
		self.cerrar.set_tamanios(grosorbor= 1, espesor= 1)
		self.cerrar.set_posicion(punto= (VG.RESOLUCION[0] - self.cerrar.get_tamanio()[0], 0) )
		self.cerrar.connect(callback= self.salir, sonido_select= None)
		a,b,c= JAMG.get_estilo_celeste()
		self.cerrar.set_colores(colorbas= a, colorbor= b, colorcara= c)
		self.add(self.cerrar)

	def salir(self, button):
		self.main.nivel = "Menu"

	def update(self):
		if self.seleccion == 1:
			for num in self.grupo1.keys():
				etiqueta, (x,y) = self.grupo1[num]
				x, y= etiqueta.get_posicion()
				y -= self.velocidad
				etiqueta.set_posicion((x,y))
			if y < -50:
				self.seleccion = 2
				for num in self.grupo1.keys():
					etiqueta, (x,y) = self.grupo1[num]
					etiqueta.set_posicion((x,y))

		if self.seleccion == 2:
			for num in self.grupo2.keys():
				etiqueta, (x,y) = self.grupo2[num]
				x, y= etiqueta.get_posicion()
				y -= self.velocidad
				etiqueta.set_posicion((x,y))
			if y < -50:
				self.seleccion = 1
				for num in self.grupo2.keys():
					etiqueta, (x,y) = self.grupo2[num]
					etiqueta.set_posicion((x,y))
		self.cerrar.update()
		
	def get_sprites(self):	
		Textos1 = ["CucaraSims.",
		"El Sims de las Cucarachas.",
		"Para Aprender Jugando y Jugar Aprendiendo.",
		"Dedicado con Cariño a mis Compañeros Voluntarios de",
		"CeibalJAM!, RAP Ceibal y a Todos los Niños y Jóvenes",
		"del Uruguay y demás comunidades Sugar."]

		Textos2 = ["Idea Original, Edición de Audio y Video,",
		"Diseño Gráfico, Desarrollo y Contenidos:",
		"Flavio Danesse - fdanesse@gmail.com",
		"Imágenes e Información: Wikipedia - Wikiespecies",
		"Música: MATI - ARUAL - http://www.jamendo.com"]

		color= JAMG.get_celeste1()
		contador= 1

		#logo= JAMLabel("")
		#logo.set_imagen(origen= VG.LOGO)
		logo= Logo()
		x, y = VG.RESOLUCION[0]/2 - logo.get_tamanio()[0]/2, VG.RESOLUCION[1]
		logo.set_posicion((x,y))
		self.add(logo)
		self.grupo1[contador]= logo, (x,y)

		y += 95
		contador += 1
		# textos1
		for texto in Textos1:
			etiqueta= JAMLabel(texto)
			etiqueta.set_text(tamanio= 40, color= color)

			x = VG.RESOLUCION[0]/2 - etiqueta.get_tamanio()[0]/2
			etiqueta.set_posicion((x,y))
			self.add(etiqueta)
			self.grupo1[contador] = etiqueta, (x,y)
			y += 100
			contador += 1
		
		contador = 1
		y = VG.RESOLUCION[1]
		for texto in Textos2:
			etiqueta= JAMLabel(texto)
			etiqueta.set_text(tamanio= 40, color= color)
			x = VG.RESOLUCION[0]/2 - etiqueta.get_tamanio()[0]/2
			etiqueta.set_posicion((x,y))
			self.add(etiqueta)
			self.grupo2[contador] = etiqueta, (x,y)
			y += 100
			contador += 1

class Logo(pygame.sprite.Sprite):
	def __init__(self):
		pygame.sprite.Sprite.__init__(self)
		self.image= pygame.image.load(VG.LOGO)
		self.rect= self.image.get_rect()
	def get_tamanio(self):
		return (self.rect.w, self.rect.h)
	def set_posicion(self, punto= (0,0)):
		self.rect.x, self.rect.y= punto
	def get_posicion(self, punto= (0,0)):
		return (self.rect.x, self.rect.y)

class Juegos_Guardados(pygame.sprite.OrderedUpdates):
	def __init__(self, archivosydirectorios, main):
		pygame.sprite.OrderedUpdates.__init__(self)
		self.juego_base= main
		self.Archivos_y_Directorios= archivosydirectorios
		lista_juegos_guardados= self.Archivos_y_Directorios.get_juegos()
		self.directorio= lista_juegos_guardados[0]	# string
		self.juegos= lista_juegos_guardados[1]		# lista
	
		y = 50
		self.items = []
		w, h= (0,0)
		for juego in self.juegos:
			item= Item_Juego(self.Archivos_y_Directorios, juego, self)
			item.agregate(self)
			if item.etiqueta_juego.get_tamanio()[1] > h: h= item.etiqueta_juego.get_tamanio()[1]
			if item.etiqueta_juego.get_tamanio()[0] > w: w= item.etiqueta_juego.get_tamanio()[0]
			self.items.append(item)
		for item in self.items:
			x= VG.RESOLUCION[0]/2 - w/2
			item.set_posicion(punto= (x, y))
			y+= h+ 30

		self.cerrar= JAMButton("", None)
		self.cerrar.set_imagen(origen= JAMG.get_icon_exit())
		self.cerrar.set_tamanios(grosorbor= 1, espesor= 1)
		self.cerrar.set_posicion(punto= (VG.RESOLUCION[0] - self.cerrar.get_tamanio()[0], 0) )
		self.cerrar.connect(callback= self.salir, sonido_select= None)
		a,b,c= JAMG.get_estilo_celeste()
		self.cerrar.set_colores(colorbas= a, colorbor= b, colorcara= c)

		self.add(self.cerrar)

	def salir(self, button= None):
		self.juego_base.deselecciona_mensaje(None)

	def reordenar_juegos(self, item):
		self.items.remove(item)
		#y= 50
		#for item in self.items:
		#	x = VG.RESOLUCION[0]/2 - item.etiqueta_juego.rect.w/2
		#	item.set_posicion(punto= (x, y))
		#	y += item.etiqueta_juego.get_tamanio()[1] + 30
	
class Item_Juego():
	def __init__(self, archivosydirectorios, juego, grupo):
		self.grupo= grupo
		self.Archivos_y_Directorios= archivosydirectorios
		self.juego= juego
		self.separador= 10

		a,b,c= JAMG.get_estilo_celeste()
		self.etiqueta_juego= JAMLabel(juego)
		self.etiqueta_juego.set_text(tamanio= 40)
		self.etiqueta_juego.set_text(color= c)

		self.boton_borrar= JAMButton("Borrar", None)
		self.boton_borrar.set_text(tamanio= 30)
		self.boton_borrar.set_tamanios(tamanio= (50, self.etiqueta_juego.get_tamanio()[1]), grosorbor= 1, espesor= 1)
		self.boton_borrar.set_colores(colorbas= a, colorbor= b, colorcara= c)

		self.boton_load= JAMButton("Cargar", None)
		self.boton_load.set_text(tamanio= 30)
		self.boton_load.set_tamanios(tamanio= (50, self.etiqueta_juego.get_tamanio()[1]), grosorbor= 1, espesor= 1)
		self.boton_load.set_colores(colorbas= a, colorbor= b, colorcara= c)

		self.boton_borrar.connect(callback= self.delete_game, sonido_select= None)
		self.boton_load.connect(callback= self.carga_game, sonido_select= None)

	def agregate(self, grupo):
		grupo.add(self.etiqueta_juego)
		grupo.add(self.boton_borrar)
		grupo.add(self.boton_load)

	def set_posicion(self, punto= (0,0)):
		(x,y)= punto
		self.etiqueta_juego.set_posicion((x,y))
		a= x - self.separador - self.boton_borrar.get_tamanio()[0]
		self.boton_borrar.set_posicion((a,y))
		b= x + self.separador + self.etiqueta_juego.get_tamanio()[0]
		self.boton_load.set_posicion((b,y))

	def delete_game(self, button= None):
		self.Archivos_y_Directorios.borrar_tabla(self.juego)
		self.etiqueta_juego.kill()
		self.boton_borrar.kill()
		self.boton_load.kill()
		self.grupo.reordenar_juegos(self)
		return

	def carga_game(self, button= None):
		self.grupo.juego_base.cargar_juego(self.Archivos_y_Directorios.Leer_Base_de_Datos(self.juego))