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

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

import random

import Jugada
import GM
import MotoresExternos
import XMotorRespuesta

import Gestor

import QT.QTUtil2 as QTUtil2
import QT.PantallaGM as PantallaGM

#==========================================================================================================================================
class GestorGM( Gestor.Gestor ) :

    #--------------------------------------------------------------------------------------------------------------------------------
    def inicio( self, gm, siBlancas, siJuez, motor, tiempo, mostrar, jugContrario, jugInicial ) :

        self.tipoJuego = kJugGM

        self.ayudas = 9999 # Para que analice sin problemas

        self.siJuez, self.motor, self.tiempo, self.mostrar, self.jugContrario, self.jugInicial = siJuez, motor, tiempo, mostrar, jugContrario, jugInicial

        if self.siJuez :
            self.puntos = 0
            if motor.startswith( "*" ) :
                tutor = MotoresExternos.buscaRival( self, motor )
            else :
                tutor = self.configuracion.buscaRival( motor )
            t_t = tiempo*100
            self.xtutor = self.procesador.creaTutor( tutor, t_t, 0 )

        self.liReiniciar = gm, siBlancas, siJuez, motor, tiempo, mostrar, jugContrario, jugInicial

        me = self.unMomento()

        self.apertura = GM.GM( gm, siBlancas )

        self.siJugamosConBlancas = siBlancas
        self.siRivalConBlancas = not siBlancas
        me.final()

        self.pantalla.ponToolBar( ( k_finpartida,k_reiniciar,k_otros ) )
        self.pantalla.activaJuego(True, False)
        self.ponMensajero( self.mueveHumano )
        self.ponPosicion( self.partida.ultPosicion )
        self.mostrarIndicador( True )
        self.quitaAyudas( )
        self.ponPiezasAbajo( siBlancas )
        dic = GM.dicGM()
        self.nombreGM = dic[gm.lower()]
        self.ponRotulo1( tr( "GM_GM" ) + ": <b>" +  self.nombreGM )
        self.ponRotulo2( "" )
        self.pgnRefresh( True )
        self.ponCapturasPorDefecto()

        self.estado = kJugando

        self.ponPosicionDGT()

        self.siguienteJugada()

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

        if clave == k_finpartida :
            self.finPartida()

        elif clave == k_reiniciar :
            self.reiniciar()

        elif clave == k_otros :
            self.otros( siSonidos = True)

        elif clave in self.procesador.liOpcionesInicio :
            self.procesador.procesarAccion( clave )

        else :
            Gestor.Gestor.rutinaAccionDef( self, clave )

    #--------------------------------------------------------------------------------------------------------------------------------
    def finalX( self ) :
        if self.estado == kFinJuego :
            return True
        return self.finPartida()

    #--------------------------------------------------------------------------------------------------------------------------------
    def finPartida( self ) :
        siJugadas = self.partida.numJugadas() > 0
        if siJugadas and self.estado != kFinJuego :
            self.resultado = kDesconocido
            self.partida.liJugadas[-1].siDesconocido = True
            self.guardarNoTerminados( )
            self.ponFinJuego()
        else :
            self.procesador.inicio()

        return False

    #--------------------------------------------------------------------------------------------------------------------------------
    def reiniciar( self ) :
        if QTUtil2.pregunta( self.pantalla, tr( "PREGUNTA_REINICIAMOS" ) ) :
            self.partida.reset()
            gm, siBlancas, siJuez, motor, tiempo, mostrar, jugContrario, jugInicial = self.liReiniciar
            self.inicio( gm, siBlancas, siJuez, motor, tiempo, mostrar, jugContrario, jugInicial )

    #--------------------------------------------------------------------------------------------------------------------------------
    def siguienteJugada( self ) :

        if self.estado == kFinJuego :
            return

        self.estado = kJugando

        self.siJuegaHumano = False
        self.ponVista()

        siBlancas = self.partida.ultPosicion.siBlancas

        if self.partida.numJugadas() > 0 and self.apertura.siTerminada() :
            self.ponResultado()
            return

        self.ponIndicador( siBlancas )
        self.refresh()

        siRival = siBlancas == self.siRivalConBlancas

        if siBlancas :
            self.jugInicial -= 1

        self.siAuto = self.jugInicial > 0

        if siRival or self.siAuto :
            self.desactivaTodas( )

            li = self.apertura.juegaMotor( )
            nli = len(li)
            resp = None
            if nli > 1 :
                if self.jugContrario and not self.siAuto :
                    liJugadas = self.apertura.dameJugadasTXT( self.partida.ultPosicion )
                    resp = PantallaGM.eligeJugada( self, liJugadas, False )
                else :
                    pos = random.randint(0,nli-1)
                    resp = li[pos][0], li[pos][1], li[pos][2]
            else :
                resp = li[0][0], li[0][1], li[0][2]
            desde, hasta, coronacion = resp
            self.apertura.haJugadoHumano( desde, hasta, coronacion )

            self.rmRival = XMotorRespuesta.RespuestaMotor("Apertura")
            self.rmRival.desde = desde
            self.rmRival.hasta = hasta
            self.rmRival.coronacion = coronacion

            self.mueveRival( self.rmRival )
            self.siguienteJugada()

        else :

            self.siJuegaHumano = True
            self.activaColor( siBlancas )

    #--------------------------------------------------------------------------------------------------------------------------------
    def mueveHumano( self, desde, hasta, coronacion = None ) :

        if self.siJuegaHumano :
            self.paraHumano()
        else :
            self.sigueHumano()
            return False

        movimiento = desde + hasta

        # Peón coronando
        if not coronacion and self.partida.ultPosicion.siPeonCoronando( desde, hasta ) :
            coronacion = self.tablero.peonCoronando(self.partida.ultPosicion.siBlancas)
            if coronacion is None :
                self.sigueHumano()
                return False
        if coronacion :
            movimiento += coronacion

        siBien, mens, jg = Jugada.dameJugada( self.partida.ultPosicion, desde, hasta, coronacion )

        if not siBien :
            self.sigueHumano()
            self.error = mens
            return False

        if not self.apertura.compruebaHumano( desde, hasta, coronacion ) :
            self.tablero.ponPosicion( self.partida.ultPosicion )
            self.tablero.activaColor( self.siJugamosConBlancas )
            liJugadas = self.apertura.dameJugadasTXT( self.partida.ultPosicion )
            resp = PantallaGM.eligeJugada( self, liJugadas, True )
            if resp is None :
                self.sigueHumano()
                return False

            if self.siJuez :
                me = self.unMomento()

                posicion = self.partida.ultPosicion

                rm = self.xtutor.analiza( posicion.fen() )

                rmUsu, pos = rm.rmMultiPV( movimiento )
                if rmUsu is None :
                    rmUsu = self.xtutor.valora( posicion, desde, hasta, coronacion )
                siBien, mens, jg = Jugada.dameJugada( posicion, desde, hasta, coronacion )
                movUsu = jg.pgnSP()

                desde, hasta, coronacion = resp
                rmGM, pos = rm.rmMultiPV( desde+hasta + (coronacion if coronacion else "") )
                if rmGM is None :
                    rmGM = self.xtutor.valora( posicion, desde, hasta, coronacion )
                siBien, mens, jg = Jugada.dameJugada( posicion, desde, hasta, coronacion )
                movGM = jg.pgnSP()

                dpts = rmUsu.puntosABS()-rmGM.puntosABS()
                self.puntos += dpts

                comentario  = "<b>%s</b> : %s = %s<br>"%(self.configuracion.jugador,movUsu, rmUsu.texto() )
                comentario += "<b>%s</b> : %s = %s<br>"%(self.nombreGM,movGM, rmGM.texto() )
                comentario += "<br><b>%s</b> = %+d<br>"%( tr( "DIFERENCIA_PUNTOS" ), dpts )
                comentario += "<b>%s</b> = %+d<br>"%( tr( "PUNTOS_ACUMULADOS" ), self.puntos )
                me.final()
                if self.mostrar :
                    QTUtil2.mensaje( self.pantalla, comentario, siResalta = False, siArribaDerecha = True )

            else : # Si no hay juez, ponemos los datos
                desde, hasta, coronacion = resp

            siBien, mens, jg = Jugada.dameJugada( self.partida.ultPosicion, desde, hasta, coronacion )
            if self.siJuez :
                jg.comentario = comentario.replace( "<b>", "" ).replace( "</b>", "" ).replace( "<br>", "\n" )

        self.apertura.haJugadoHumano( desde, hasta, coronacion )

        self.movimientosPiezas( jg.liMovs )

        self.partida.ultPosicion = jg.posicion
        self.masJugada( jg )
        self.error = ""
        self.siguienteJugada()
        return True

    #--------------------------------------------------------------------------------------------------------------------------------
    def masJugada( self, jg ) :
        # Preguntamos al motor si hay movimiento
        if self.siTerminada() :
            jg.siJaqueMate = jg.siJaque
            jg.siAhogado = not jg.siJaque

        self.partida.liJugadas.append( jg )
        if self.partida.pendienteApertura :
            self.listaAperturasStd.asignaApertura( self.partida )

        self.ponFlechaSC( jg.desde, jg.hasta )

        txt = self.apertura.rotuloPartidaActual( )
        if txt :
            self.ponRotulo2( txt )

        self.pgnRefresh(self.partida.ultPosicion.siBlancas)
        self.refresh()

        self.ponPosicionDGT()

    #--------------------------------------------------------------------------------------------------------------------------------
    def mueveRival( self, respMotor ) :
        desde = respMotor.desde
        hasta = respMotor.hasta

        coronacion = respMotor.coronacion

        siBien, mens, jg = Jugada.dameJugada( self.partida.ultPosicion, desde, hasta, coronacion )
        if siBien :
            self.partida.ultPosicion = jg.posicion
            self.error = ""

            self.masJugada( jg )
            self.beepExtendido()
            self.movimientosPiezas( jg.liMovs, True )

            return True
        else :
            self.error = mens
            return False

    #--------------------------------------------------------------------------------------------------------------------------------
    def ponResultado( self ) :
        self.estado = kFinJuego
        self.tablero.desactivaTodas( )

        mensaje = tr("PARTIDA_TERMINADA")
        mensaje += "<br><br>" + self.apertura.resultado(self.partida)
        if self.siJuez :
            mensaje += "<br><br><b>%s</b> = %+d<br>"%( tr( "PUNTOS_ACUMULADOS" ), self.puntos )

        QTUtil2.mensaje( self.pantalla, mensaje, siResalta = False )

