# -*- coding: latin-1 -*-

#==========================================================================================================================================
import sys
import os
import copy

from Code.Constantes import *
from Code.Traducir import tr

import Configuracion
import ControlPosicion
import XGestorMotor
import Actualizar
import Util
import CPU
import Sonido
import Presentacion

import Entrenamientos

import GestorNueva
import GestorElo

import QT.DatosNueva as DatosNueva
import QT.Pantalla as Pantalla
import QT.QTUtil as QTUtil
import QT.QTUtil2 as QTUtil2
import QT.Controles as Controles
import QT.Iconos as Iconos
import QT.PantallaOpciones as PantallaOpciones
import QT.PantallaMotores as PantallaMotores
import QT.PantallaPuntuacion as PantallaPuntuacion
import QT.PantallaSonido as PantallaSonido
import QT.PantallaTraduccion as PantallaTraduccion
import QT.Colores as Colores
import QT.Info as Info
import QT.PantallaUsuarios as PantallaUsuarios
import QT.PantallaAperturas as PantallaAperturas
import QT.PantallaFavoritos as PantallaFavoritos

#==========================================================================================================================================
class Procesador(  ) :
    """
    Vínculo entre pantalla y gestores
    """

    #--------------------------------------------------------------------------------------------------------------------------------
    def iniciaConUsuario( self, user ) :

        self.user = user

        self.web = "http://lucaschess.host22.com"
        self.blog = "http://lucaschess.blogspot.com"

        self.liOpcionesInicio = [ k_terminar,k_nuevapartida,k_entrenamiento,k_opciones,k_informacion ] # Lo incluimos aquí porque sino no lo lee, en caso de aplazada

        self.configuracion = Configuracion.Configuracion(user)
        self.configuracion.lee()
        # for g in self.configuracion.grupos.liGrupos :
            # prlk( g.nombre )
            # for cm in g.liRivales :
                # prlk( "     ", cm.elo, "-", cm.nombre, "-", cm.autor, "-", cm.url )

        self.gestor = None
        self.teclaPanico = 32 #necesario

        self.siPrimeraVez = True
        self.siPresentacion = False # si está funcionando la presentación

        self.posicionInicial = ControlPosicion.ControlPosicion()
        self.posicionInicial.posInicial()

        self.xrival = None
        self.xtutor = None # creaTutor lo usa así que hay que definirlo antes

        self.replay = None
        self.replayBeep = None

        self.liMoscasActivas = []

    #--------------------------------------------------------------------------------------------------------------------------------
    def quitaMoscas( self ) :
        if hasattr( self, "liMoscasActivas" ) :
            for xmosca in self.liMoscasActivas :
                xmosca.terminar()

    #--------------------------------------------------------------------------------------------------------------------------------
    def iniciarGUI( self ) :
        self.pantalla = Pantalla.Pantalla(self)
        self.pantalla.ponGestor( self ) #antes que muestra
        self.pantalla.muestra()

        self.tablero = self.pantalla.tablero

        self.xtutor = self.creaTutor( self.configuracion.tutor, self.configuracion.tiempoTutor, None )

        self.entrenamientos = Entrenamientos.Entrenamientos(self)

        if self.configuracion.siAplazada :
            self.juegaAplazada( )
        else :
            self.inicio()

    #--------------------------------------------------------------------------------------------------------------------------------
    def compruebaReplay( self ) :
        if self.replay is None :
            self.replay = Sonido.Replay(self)

    #--------------------------------------------------------------------------------------------------------------------------------
    def finSonidos( self ) :
        if self.replay :
            self.replay.stop()

    #--------------------------------------------------------------------------------------------------------------------------------
    def terminarSonido( self ) :
        if hasattr(self, "replay") and self.replay :
            self.replay.terminar()

    #--------------------------------------------------------------------------------------------------------------------------------
    def playLista( self, li, siEsperar = False ) :
        self.compruebaReplay()
        self.replay.playLista( li, siEsperar )

    #--------------------------------------------------------------------------------------------------------------------------------
    def playClave( self, clave, siEsperar = False ) :
        self.compruebaReplay()

        self.replay.playClave( clave, siEsperar )

    #--------------------------------------------------------------------------------------------------------------------------------
    def playBeep( self ) :
        if self.replayBeep is None :
            db = Util.DicDiskBlob( self.configuracion.ficheroSounds, "general" )
            keys = db.keys()
            self.replayBeep = "MC" in keys

        if self.replayBeep :
            self.playClave( "MC", False )
        else :
            QTUtil.beep()

    #--------------------------------------------------------------------------------------------------------------------------------
    def inicio( self ) :
        self.pantalla.ponTamMinimo()
        self.pantalla.activaCapturas(False)
        self.pantalla.activaInformacionPGN(False)
        if self.gestor :
            self.gestor.finGestor()
            self.gestor = None
        self.pantalla.ponGestor( self ) # Necesario, no borrar
        self.tablero.indicadorSC.setVisible( False )
        self.pantalla.ponToolBar( self.liOpcionesInicio )
        self.pantalla.activaJuego( False, False )
        self.tablero.exePulsadoNum = None
        if self.siPrimeraVez :
            self.siPrimeraVez = False
            self.cpu = CPU.CPU(self.pantalla)
            self.presentacion()
        else :
            self.tablero.ponPosicion( self.posicionInicial )

    #--------------------------------------------------------------------------------------------------------------------------------
    def presentacion( self, siEmpezar = True ) :
        self.siPresentacion = siEmpezar
        if (not siEmpezar) or (not self.configuracion.efectosVisuales) :
            self.cpu.stop()
            self.tablero.ponPosicion( self.posicionInicial )
            self.tablero.setToolTip( "" )
        else :

            logo = ControlPosicion.ControlPosicion()
            logo.logo()

            self.cpu.ponPosicion( logo )
            hx = self.cpu.duerme( 2.0 )

            # Presentacion.basico( self, hx )
            Presentacion.partidaDia( self, hx )

            self.cpu.start()

    #--------------------------------------------------------------------------------------------------------------------------------
    def juegaAplazada( self ) :
        aplazamiento = self.configuracion.aplazamiento
        self.cpu = CPU.CPU(self.pantalla)

        tipoJuego = aplazamiento["TIPOJUEGO"]
        siBlancas = aplazamiento["SIBLANCAS"]

        if tipoJuego == kJugNueva :
            categoria = self.configuracion.rival.categorias.segunClave(aplazamiento["CATEGORIA"])
            nivel = aplazamiento["NIVEL"]
            puntos = aplazamiento["PUNTOS"]
            self.gestor = GestorNueva.GestorNueva( self )
            self.gestor.inicio( categoria, nivel, siBlancas, puntos, aplazamiento )
        elif tipoJuego == kJugEntMaq :
            self.entrenamientos.entrenaMaquina( aplazamiento["EMDIC"], aplazamiento )
        elif tipoJuego == kJugElo :
            self.gestor = GestorElo.GestorElo( self )
            self.gestor.inicio( None, aplazamiento )

    #--------------------------------------------------------------------------------------------------------------------------------
    def creaGestorMotor( self, xgestor, confMotor, tiempo, nivel, siMultiPV = False ) :

        if xgestor is None :
            xgestor = XGestorMotor.GestorMotor( self, confMotor )
        else :
            if xgestor.clave != confMotor.clave :
                xgestor.terminar()
                xgestor = XGestorMotor.GestorMotor( self, confMotor )
        xgestor.opciones( tiempo, nivel, siMultiPV )
        # if not xgestor.siIniMotor :
            # xgestor.iniciarMotor()

        return xgestor

    #--------------------------------------------------------------------------------------------------------------------------------
    def creaRival( self, confMotor, tiempo, nivel, siMulti=False ) :
        # prlk( "debug-procesador-creaRival-225 "*10 )
        # confMotor.debug( "rival" )
        if self.xrival :
            self.xrival.terminar()
        self.xrival = self.creaGestorMotor( None, confMotor, tiempo, nivel, siMulti )
        return self.xrival

    #--------------------------------------------------------------------------------------------------------------------------------
    def creaTutor( self, confMotor, tiempo, nivel ) :
        # prlk( "debug-procesador-creaTutor-242"*10 )
        # confMotor.debug( "h" )
        self.xtutor = self.creaGestorMotor( self.xtutor, confMotor, tiempo, nivel, True )
        return self.xtutor

    #--------------------------------------------------------------------------------------------------------------------------------
    def pararMotores( self ) :
        if hasattr(self, "xtutor") and self.xtutor :
            self.xtutor.terminar()
        if hasattr(self, "xrival") and self.xrival :
            self.xrival.terminar()

    #--------------------------------------------------------------------------------------------------------------------------------
    def pararRival( self ) :
        if self.xrival :
            self.xrival.terminar()
            self.xrival = None

    #--------------------------------------------------------------------------------------------------------------------------------
    def cambiaRival( self, nuevo ) :
        """
        Llamado desde DatosNueva, cuando elegimos otro motor para jugar.
        """
        self.configuracion.rival = self.configuracion.buscaRival( nuevo )
        self.configuracion.graba()

    #--------------------------------------------------------------------------------------------------------------------------------
    def procesarAccion( self, clave ) :

        if self.siPresentacion :
            self.presentacion( False )

        if clave == k_terminar :
            self.cpu.stop()
            self.pantalla.guardarVideo()
            self.pantalla.accept()

        elif clave == k_nuevapartida :
            self.nuevaPartida()

        elif clave == k_entrenamiento :
            self.entrenamientos.lanza()

        elif clave == k_opciones :
            self.opciones()

        elif clave == k_informacion :
            self.informacion()

    #--------------------------------------------------------------------------------------------------------------------------------
    def opciones( self ) :

        menu = Controles.LMenu(puntos=10)

        menu.opcion( "configuracion", tr( "CONFIGURACION" ), Iconos.TB_Opciones() )
        menu.separador()
        menu.opcion( "favoritos", tr("FAVORITOS" ), Iconos.Corazon() )
        menu.separador()

        liTemas = Util.recuperaVar( self.configuracion.ficheroTemas  )
        if liTemas :
            menu1 = menu.submenu( tr("COLORES" ), Iconos.Colores() )
            menu1.opcion( "colores", tr( "COLORES" ), Iconos.Temas() )
            ico = Iconos.PuntoNaranja()
            for n, tema in enumerate(liTemas) :
                menu1.separador()
                menu1.opcion( "c_%d"%n, tema["NOMBRE"], ico )
        else :
            menu.opcion( "colores", tr( "COLORES" ), Iconos.Colores() )

        menu.separador()
        menu.opcion( "motores", tr( "MOTORES_EXTERNOS" ), Iconos.TB_Motores() )
        menu.separador()

        menu1 = menu.submenu( tr("OPCIONES_AVANZADAS" ), Iconos.Mas() )
        menu1.opcion( "traduccion", tr( "TRADUCCION_EDICION" ), Iconos.Traduccion() )
        menu1.separador()
        menu1.opcion( "sonidos", tr( "SONIDOS_EDICION" ), Iconos.TB_S_Play() )
        menu1.separador()
        menu1.opcion( "aperturaspers", tr( tr("APERTURAS_PERSONALES") ), Iconos.Apertura() )
        menu1.separador()
        menu1.opcion( "inicial", tr( "POSICION_INICIAL" ), Iconos.LM() )
        if self.configuracion.siMain :
            menu1.separador()
            menu1.opcion( "usuarios", tr( "USUARIOS" ), Iconos.Usuarios() )

        resp = menu.lanza()
        if resp :
            if resp == "colores" :
                self.cambiaColores(None)
            elif resp.startswith("c_") :
                self.cambiaColores( liTemas[int(resp[2:])] )
            elif resp == "configuracion" :
                self.cambiaConfiguracion()
            elif resp == "motores" :
                self.motoresExternos()
            elif resp == "sonidos" :
                self.sonidos()
            elif resp == "traduccion" :
                self.entrenamientos.menu = None # ya que puede cambiar y las etiquetas serán diferentes
                self.traduccion()
            elif resp == "usuarios" :
                self.usuarios()
            elif resp == "aperturaspers" :
                self.aperturaspers()
            elif resp == "favoritos" :
                PantallaFavoritos.miraFavoritos( self.entrenamientos )
            elif resp == "inicial" :
                self.cpu.stop()
                del self.cpu
                self.siPrimeraVez = True
                self.inicio()

    #--------------------------------------------------------------------------------------------------------------------------------
    def cambiaConfiguracion( self ) :

        if PantallaOpciones.Opciones( self.pantalla, self.configuracion ) :
            self.configuracion.graba()
            self.pantalla.accept()
            QTUtil.salirAplicacion(kFinReinicio)
    #--------------------------------------------------------------------------------------------------------------------------------
    def cambiaColores( self, tema ) :
        if not tema :
            w = Colores.WColores( self.pantalla, self.configuracion )
            if w.exec_() :
                self.tablero.cambiaColores( self.configuracion.cTableroN )
                self.configuracion.graba()
        else :
            anchoPieza = self.configuracion.cTableroN.anchoPieza
            self.configuracion.cTableroN.lee( tema["CONFIG"] )
            self.configuracion.cTableroN.anchoPieza = anchoPieza
            anchoPieza = self.configuracion.cTableroT.anchoPieza
            self.configuracion.cTableroT.lee( tema["CONFIG"] )
            self.configuracion.cTableroT.anchoPieza = anchoPieza
            self.configuracion.graba()
            self.tablero.cambiaColores( self.configuracion.cTableroN )

    #--------------------------------------------------------------------------------------------------------------------------------
    def motoresExternos( self ) :
        w = PantallaMotores.WMotores( self.pantalla, self.configuracion.ficheroMExternos )
        w.exec_()

    #--------------------------------------------------------------------------------------------------------------------------------
    def sonidos( self ) :
        w = PantallaSonido.WSonidos( self )
        w.exec_()

    #--------------------------------------------------------------------------------------------------------------------------------
    def traduccion( self ) :
        w = PantallaTraduccion.WTraduccion( self )
        w.show()

    #--------------------------------------------------------------------------------------------------------------------------------
    def aperturaspers( self ) :
        w = PantallaAperturas.AperturasPersonales( self )
        w.exec_()

    #--------------------------------------------------------------------------------------------------------------------------------
    def usuarios( self ) :
        PantallaUsuarios.editaUsuarios(self)

    #--------------------------------------------------------------------------------------------------------------------------------
    def informacion( self ) :
        menu = Controles.LMenu(puntos=10)

        menu.opcion( "ayuda", tr( "TIT_AYUDA" ), Iconos.Ayuda() )
        menu.separador()
        menu.opcion( "faq", tr( "FAQ_BOLOKAY" ), Iconos.FAQ() )
        menu.separador()
        menu.opcion( "web", tr( "WEB" ), Iconos.Web() )
        menu.separador()
        menu.opcion( "blog", "Fresh news", Iconos.Blog() )
        menu.separador()
        menu.opcion( "mail", tr( "MAIL" ), Iconos.Mail() )
        menu.separador()
        if not self.configuracion.modoNoCompetitivo :
            menu.opcion( "puntuacion", tr( "PUNTUACION" ), Iconos.Puntuacion() )
            menu.separador()
        if self.configuracion.siMain :
            menu.opcion( "actualiza", tr( "TIT_ACTUALIZA" ), Iconos.Actualiza() )
            menu.separador()
        menu.opcion( "acercade", tr( "TIT_ACERCADE" ), Iconos.Aplicacion() )

        resp = menu.lanza()
        if resp == "acercade" :
            self.acercade()
        elif resp == "ayuda" :
            self.ayuda()
        elif resp == "faq" :
            self.faq()
        elif resp == "blog" :
            os.startfile( self.blog )
        elif resp == "web" :
            if self.configuracion.traductor in ( "english", "deutsch", "portuguese" ) :
                idioma = ""
            elif self.configuracion.traductor == "francais" :
                idioma = "FR"
            else :
                idioma = "ES"
            os.startfile( "%s/index%s.htm"%(self.web,idioma) )
        elif resp == "mail" :
            os.startfile( "mailto:lukasmonk@gmail.com" )
        elif resp == "actualiza" :
            self.actualiza( self.web )

        elif resp == "puntuacion" :
            self.puntuacion(self.web)

    #--------------------------------------------------------------------------------------------------------------------------------
    def adTitulo( self ) :
        return "<b>"+tr( "El ajedrez de Lucas" ) + "</b><br>" + tr( "VERSION", self.version )

    #--------------------------------------------------------------------------------------------------------------------------------
    def adPie( self ) :
        return '<hr><br><b>%s</b>'%tr("AUTOR") + \
                ': <a href="mailto:lukasmonk@gmail.com">Lucas Monge</a> -' + \
                ' <a href="%s">%s</a></a>'%(self.web,self.web) + \
                '(%s <a href="http://www.gnu.org/copyleft/gpl.html"> GPL</a>).<br>'%tr( "LICENCIA" )

    #--------------------------------------------------------------------------------------------------------------------------------
    def ayuda( self ) :
        titulo = self.adTitulo()
        ancho, alto = QTUtil.tamEscritorio()
        ancho = min( ancho, 700 )

        txt = tr( "AYUDA") + self.adPie()

        Info.info( self.pantalla, tr( "El ajedrez de Lucas" ), titulo, txt, ancho, Iconos.pmAyudaGR() )
    #--------------------------------------------------------------------------------------------------------------------------------
    def faq( self ) :
        os.startfile( "Lucas Chess FAQ.pdf")
    #--------------------------------------------------------------------------------------------------------------------------------
    def acercade( self ) :
        w = Info.WAbout( self )
        w.exec_()

    #--------------------------------------------------------------------------------------------------------------------------------
    def actualiza( self, web ) :

        tipo = "w" if sys.argv[0].endswith( ".exe" ) else "py"

        if Actualizar.actualiza( web, self.version, self.pantalla, tipo ) :
            self.pantalla.accept()
            QTUtil.salirAplicacion(kFinReinicio)

    #--------------------------------------------------------------------------------------------------------------------------------
    def puntuacion( self, web ) :
        PantallaPuntuacion.lanzaPuntuacion( web, self )

    #--------------------------------------------------------------------------------------------------------------------------------
    def unMomento( self ) :
        return QTUtil2.mensEspera.inicio( self.pantalla, tr( "UN_MOMENTO" ), posicion = "ad" )

    #--------------------------------------------------------------------------------------------------------------------------------
    def numDatos( self ) :
        return 0

    #--------------------------------------------------------------------------------------------------------------------------------
    def nuevaPartida( self ) :
        opciones = DatosNueva.datos( self.pantalla, self.configuracion, self )
        if opciones :
            self.tipoJuego = kJugNueva
            categoria, nivel, siBlancas, puntos = opciones

            self.gestor = GestorNueva.GestorNueva( self )
            self.gestor.inicio( categoria, nivel, siBlancas, puntos )

    #--------------------------------------------------------------------------------------------------------------------------------
    def finalX( self ) :
        return True
    #--------------------------------------------------------------------------------------------------------------------------------
    def finalX0( self ) :
        return True

#==========================================================================================================================================
class ProcesadorVariantes( Procesador ) :

    #--------------------------------------------------------------------------------------------------------------------------------
    def __init__( self, gestorBase ) :

        self.gestorBase = gestorBase
        self.liMoscasActivas = gestorBase.procesador.liMoscasActivas

        self.configuracion = copy.deepcopy( gestorBase.configuracion )
        self.configuracion.cTableroN = self.configuracion.cTableroT

        self.pantalla = Pantalla.Pantalla(self,self.gestorBase.pantalla)
        self.pantalla.ponGestor( self )

        self.tablero = self.pantalla.tablero

        self.teclaPanico = None
        self.xtutor = gestorBase.xtutor
        self.xrival = None

