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

#==========================================================================================================================================

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

import ControlPosicion
import Jugada
import Tutor

import Gestor

import QT.QTUtil as QTUtil

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

    #--------------------------------------------------------------------------------------------------------------------------------
    def inicio( self, posEntreno, numEntrenos, titEntreno, liEntrenos, siTutorActivado=False ) :

        self.posEntreno = posEntreno
        self.numEntrenos = numEntrenos
        self.titEntreno = titEntreno
        self.liEntrenos = liEntrenos

        self.liHistorico = [ self.posEntreno ]

        self.ayudas = 99999

        self.fen = self.liEntrenos[self.posEntreno-1].strip()
        cp = ControlPosicion.ControlPosicion()
        cp.leeFen( self.fen )

        siBlancas = cp.siBlancas

        self.partida.reset( cp )

        self.tipoJuego = kJugEntPos

        self.siJuegaHumano = False
        self.estado = kJugando

        self.siJugamosConBlancas = siBlancas
        self.siRivalConBlancas = not siBlancas

        self.rmRival = None

        self.siTutorActivado = siTutorActivado
        self.pantalla.ponActivarTutor( self.siTutorActivado )

        self.ayudasPGN = 0

        self.pantalla.ponToolBar( ( k_finpartida,k_atras,k_reiniciar,k_otros,k_anterior,k_siguiente,k_entrenamiento ) )
        if self.numEntrenos < 2 :
            self.pantalla.habilitaToolbar( k_anterior, False )
            self.pantalla.habilitaToolbar( k_siguiente, False )

        self.pantalla.activaJuego(True, False)
        self.pantalla.quitaAyudas(False, False )
        #~ self.quitaAyudas(False) No vale ya que afecta al tutor
        self.ponMensajero( self.mueveHumano )
        self.ponPosicion( self.partida.ultPosicion )
        self.mostrarIndicador( True )
        self.ponPiezasAbajo( siBlancas )
        self.ponRotulo1( "<b>%s</b>"%tr(self.titEntreno) )
        self.ponRotulo2( "%d / %d"%(posEntreno,numEntrenos) )
        self.pgnRefresh( True )
        QTUtil.xrefreshGUI()

        self.xrival = self.procesador.creaRival( self.configuracion.tutor, 1, None )

        self.siAnalizadoTutor = False

        self.ponPosicionDGT()

        self.siguienteJugada()

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

        if clave == k_finpartida :
            self.finPartida()

        elif clave == k_atras :
            self.atras()

        elif clave == k_reiniciar :
            self.reiniciar()

        elif clave == k_otros :
            self.otros()

        elif clave in ( k_siguiente, k_anterior ) :
            self.ent_siguiente(clave)

        # elif clave == k_ent_otro :
            # self.ent_otro()

        elif clave == k_entrenamiento :
            self.procesador.entrenamientos.lanza()
        else :
            Gestor.Gestor.rutinaAccionDef( self, clave )

    #--------------------------------------------------------------------------------------------------------------------------------
    def reiniciar( self ) :
        self.inicio( self.posEntreno, self.numEntrenos, self.titEntreno, self.liEntrenos, self.siTutorActivado )

    #--------------------------------------------------------------------------------------------------------------------------------
    # def ent_otro( self ) :
        # if self.numEntrenos == 1 :
            # pos = 1
        # else :
            # while True :
                # pos = random.randint( 1,  self.numEntrenos )
                # if pos != self.posEntreno :
                    # break
        # self.inicio( pos, self.numEntrenos, self.titEntreno, self.liEntrenos, self.siTutorActivado )

    #--------------------------------------------------------------------------------------------------------------------------------
    def ent_siguiente( self, tipo ) :
        pos = self.posEntreno + ( +1 if tipo == k_siguiente else -1 )
        if pos > self.numEntrenos :
            pos = 1
        elif pos == 0 :
            pos = self.numEntrenos
        self.inicio( pos, self.numEntrenos, self.titEntreno, self.liEntrenos, self.siTutorActivado )

    #--------------------------------------------------------------------------------------------------------------------------------
    def finPartida( self ) :

        self.procesador.inicio()

    #--------------------------------------------------------------------------------------------------------------------------------
    def finalX( self ) :
        self.finPartida()
        return False

    #--------------------------------------------------------------------------------------------------------------------------------
    def atras( self ) :
        if self.partida.numJugadas() :
            self.partida.anulaUltimoMovimiento( self.siJugamosConBlancas )
            self.ponteAlFinal()
            self.siAnalizadoTutor = False
            self.siguienteJugada()

    #--------------------------------------------------------------------------------------------------------------------------------
    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 :
            jgUltima = self.partida.liJugadas[-1]
            if jgUltima :
                if jgUltima.siJaqueMate :
                    self.ponResultado( kGanaRival if self.siJugamosConBlancas == siBlancas else kGanamos )
                    return
                if jgUltima.siAhogado :
                    self.ponResultado( kTablas )
                    return
                if jgUltima.siTablasRepeticion :
                    self.ponResultado( kTablasRepeticion )
                    return
                if jgUltima.siTablas50 :
                    self.ponResultado( kTablas50 )
                    return
                if jgUltima.siTablasFaltaMaterial :
                    self.ponResultado( kTablasFaltaMaterial )
                    return

        self.ponIndicador( siBlancas )
        self.refresh()

        siRival = siBlancas == self.siRivalConBlancas

        if siRival :
            self.pensando(True)
            self.desactivaTodas( )

            self.rmRival = self.xrival.juega()

            self.pensando(False)
            if 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 self.siTeclaPanico :
            self.sigueHumano()
            return False

        if siBien :

            siMirarTutor = self.siTutorActivado

            if self.siTeclaPanico :
                self.sigueHumano()
                return False

            if siMirarTutor :
                if not self.siAnalizadoTutor :
                    self.analizaTutor()
                if self.mrmTutor.mejorMovQue(movimiento) :
                    if not jg.siJaqueMate :
                        tutor = Tutor.Tutor( self, self, jg, desde, hasta, False )

                        if tutor.elegir( True, self.configuracion.cTableroT ) :
                            self.reponPieza( desde )
                            desde = tutor.desde
                            hasta = tutor.hasta
                            coronacion = tutor.coronacion
                            siBien, mens, jgTutor = Jugada.dameJugada( self.partida.ultPosicion, desde, hasta, coronacion )
                            if siBien :
                                jg = jgTutor

                        del tutor
                self.mrmTutor = None

            if self.siTeclaPanico :
                self.sigueHumano()
                return False

            self.movimientosPiezas( jg.liMovs )

            self.partida.ultPosicion = jg.posicion
            self.masJugada( jg )
            self.error = ""
            self.siguienteJugada()
            return True
        else :
            self.sigueHumano()
            self.error = mens
            return False

    #--------------------------------------------------------------------------------------------------------------------------------
    def masJugada( self, jg ) :

        # Preguntamos al mono si hay movimiento
        if self.siTerminada() :
            jg.siJaqueMate = jg.siJaque
            jg.siAhogado = not jg.siJaque

        self.partida.liJugadas.append( jg )

        resp = self.partida.si3repetidas()
        if resp :
            jg.siTablasRepeticion = True
            rotulo = ""
            for j in resp :
                rotulo += "%d,"%(j/2+1,)
            rotulo = rotulo.strip(",")
            self.rotuloTablasRepeticion = rotulo

        if self.partida.ultPosicion.movPeonCap >= 50 :
            jg.siTablas50 = True

        if self.partida.ultPosicion.siFaltaMaterial() :
            jg.siTablasFaltaMaterial = True

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

        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
            if not self.siTutorActivado :
                self.siAnalizadoTutor = False
            else :
                self.analizaTutor() # Que analice antes de activar humano, para que no tenga que esperar
                self.siAnalizadoTutor = True

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

            self.error = ""

            return True
        else :
            self.error = mens
            return False

    #--------------------------------------------------------------------------------------------------------------------------------
    def ponResultado( self, quien ) :
        self.resultado = quien
        self.desactivaTodas( )
        self.siJuegaHumano = False

        if quien == kTablasRepeticion :
            self.resultado = kTablas

        elif quien == kTablas50 :
            self.resultado = kTablas

        elif quien == kTablasFaltaMaterial :
            self.resultado = kTablas

        self.desactivaTodas()

