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

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

import VarGen

import Jugada
import Tutor
import XMotorRespuesta

import Apertura

import Gestor

import QT.QTUtil2 as QTUtil2

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

    #--------------------------------------------------------------------------------------------------------------------------------
    def inicio( self, categoria, nivel, siBlancas, puntos, aplazamiento = None ) :

        self.tipoJuego = kJugNueva

        self.liReiniciar = categoria, nivel, siBlancas

        self.resultado = None
        self.siJuegaHumano = False
        self.estado = kJugando

        self.siJugamosConBlancas = siBlancas
        self.siRivalConBlancas = not siBlancas

        self.rmRival = None

        self.categoria = categoria
        self.nivelJugado = nivel
        self.puntos = puntos

        self.siTutorActivado = VarGen.dgtDispatch == None
        self.pantalla.ponActivarTutor( self.siTutorActivado )

        self.ayudas = categoria.ayudas
        self.ayudasPGN = self.ayudas # Se guarda para guardar el PGN

        self.siApertura = True
        # self.siApertura = False
        # prlk( "apertu-"*100 )
        self.apertura = Apertura.AperturaPol(nivel) # lee las aperturas

        self.xrival = self.procesador.creaRival( self.configuracion.rival, None, nivel )

        #-Aplazamiento 1/2--------------------------------------------------
        if aplazamiento :
            self.partida.recuperaDeTexto( aplazamiento["JUGADAS"] )

            self.siApertura = aplazamiento["SIAPERTURA"]
            self.partida.pendienteApertura = aplazamiento["PENDIENTEAPERTURA"]
            self.partida.apertura = None if aplazamiento["APERTURA"] is None else self.listaAperturasStd.dic[aplazamiento["APERTURA"]]
            self.apertura.recuperaEstado( aplazamiento["ESTADOAPERTURA"] )

            self.siTutorActivado = aplazamiento["SITUTOR"]
            self.pantalla.ponActivarTutor( self.siTutorActivado )
            self.ayudas = aplazamiento["AYUDAS"]
        #-------------------------------------------------------------------

        self.pantalla.ponToolBar( ( k_finpartida, k_rendirse,k_atras,k_reiniciar,k_aplazar,k_otros  ) )
        self.pantalla.activaJuego(True, False)
        self.ponMensajero( self.mueveHumano )
        self.ponPosicion( self.partida.ultPosicion )
        self.ponPiezasAbajo( siBlancas )
        self.ponAyudas( self.ayudas )
        self.mostrarIndicador( True )
        rotulo = "%s: <b>%s</b><br>%s %s %d"%(tr( "RIVAL" ), self.xrival.nombre, categoria.nombre(), tr( "NIVEL" ), nivel )
        if self.puntos :
            rotulo += " (%d %s)"%( self.puntos, tr( "PUNTOS" ) )
        self.ponRotulo1( rotulo )
        self.ponRotulo2( tr( "TUTOR" ) + ": <b>" + self.xtutor.nombre )
        self.pgnRefresh( True )
        self.ponCapturasPorDefecto()

        #-Aplazamiento 2/2--------------------------------------------------
        if aplazamiento :
            self.mueveJugada( "f" )

        #-------------------------------------------------------------------

        self.siAnalizadoTutor = False

        self.ponPosicionDGT()

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

        if clave == k_finpartida :
            self.finalizar()

        elif clave == k_rendirse :
            self.rendirse()

        elif clave == k_atras :
            self.atras()

        elif clave == k_reiniciar :
            self.reiniciar()

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

        elif clave == k_aplazar :
            self.aplazar()

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

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

    #--------------------------------------------------------------------------------------------------------------------------------
    def reiniciar( self ) :
        if self.partida.numJugadas() and QTUtil2.pregunta( self.pantalla, tr( "PREGUNTA_REINICIAMOS" ) ) :
            self.partida.reset()
            categoria, nivel, siBlancas = self.liReiniciar
            self.inicio( categoria, nivel, siBlancas, self.puntos )

    #--------------------------------------------------------------------------------------------------------------------------------
    def aplazar( self ) :
        if self.partida.numJugadas() and QTUtil2.pregunta( self.pantalla, tr( "PREGUNTA_APLAZAMOS" ) ) :

            aplazamiento = {}
            aplazamiento["TIPOJUEGO"] = self.tipoJuego
            aplazamiento["SIBLANCAS"] = self.siJugamosConBlancas
            aplazamiento["JUGADAS"] = self.partida.guardaEnTexto()
            aplazamiento["SITUTOR"] = self.siTutorActivado
            aplazamiento["AYUDAS"] = self.ayudas

            aplazamiento["SIAPERTURA"] = self.siApertura
            aplazamiento["PENDIENTEAPERTURA"] = self.partida.pendienteApertura
            aplazamiento["APERTURA"] = self.partida.apertura.a1h8 if self.partida.apertura else None
            aplazamiento["ESTADOAPERTURA"] = self.apertura.marcaEstado()

            aplazamiento["CATEGORIA"] = self.categoria.clave
            aplazamiento["NIVEL"] = self.nivelJugado
            aplazamiento["PUNTOS"] = self.puntos

            self.configuracion.graba( aplazamiento )
            self.pantalla.accept()

    #--------------------------------------------------------------------------------------------------------------------------------
    def finalX( self ) :
        return self.finalizar()

    #--------------------------------------------------------------------------------------------------------------------------------
    def finalizar( self ) :
        if self.estado == kFinJuego :
            return True
        siJugadas = self.partida.numJugadas() > 0
        if siJugadas :
            if not QTUtil2.pregunta( self.pantalla, tr( "FINALIZAS" ) ) :
                return False # no termina
            self.resultado = kDesconocido
            self.partida.liJugadas[-1].siDesconocido = True
            self.guardarNoTerminados( )
            self.ponFinJuego()
        else :
            self.procesador.inicio()

        return False

    #--------------------------------------------------------------------------------------------------------------------------------
    def rendirse( self ) :
        if self.estado == kFinJuego :
            return True
        siJugadas = self.partida.numJugadas() > 0
        if siJugadas :
            if not QTUtil2.pregunta( self.pantalla, tr( "TE_RINDES" ) ) :
                return False # no abandona
            self.resultado = kGanaRival
            self.partida.liJugadas[-1].siAbandono = True
            self.guardarGanados( False )
            self.ponFinJuego()
        else :
            self.procesador.inicio()

        return False

    #--------------------------------------------------------------------------------------------------------------------------------
    def atras( self ) :
        if self.ayudas and self.partida.numJugadas() :
            if QTUtil2.pregunta( self.pantalla, tr( "IR_ATRAS" ) ) :
                self.ayudas -= 1
                self.ponAyudas( self.ayudas )
                self.partida.anulaUltimoMovimiento( self.siJugamosConBlancas )
                self.siApertura = False
                self.listaAperturasStd.asignaApertura( self.partida )
                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

        if self.ayudas == 0 :
            if self.categoria.sinAyudasFinal :
                self.quitaAyudas()
                self.siTutorActivado = False

        siRival = siBlancas == self.siRivalConBlancas
        self.ponIndicador( siBlancas )

        self.refresh()

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

            siPensar = True

            if self.siApertura :

                siBien, desde, hasta, coronacion = self.apertura.juegaMotor( self.partida.fenActual() )

                if siBien :
                    self.rmRival = XMotorRespuesta.RespuestaMotor("Apertura")
                    self.rmRival.desde = desde
                    self.rmRival.hasta = hasta
                    self.rmRival.coronacion = coronacion
                    siPensar = False

            if siPensar :
                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.siApertura :
                if self.apertura.compruebaHumano( self.partida.fenActual(), desde, hasta ) :
                    siMirarTutor = False

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

            if siMirarTutor :
                if not self.siAnalizadoTutor :
                    self.analizaTutor()
                    self.siAnalizadoTutor = True

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

                        if self.siApertura :
                            liApPosibles = self.listaAperturasStd.listaAperturasPosibles( self.partida )
                        else :
                            liApPosibles = None

                        if tutor.elegir( self.ayudas > 0, self.configuracion.cTableroT, liApPosibles = liApPosibles ) :
                            if self.ayudas > 0 : # doble entrada a tutor.
                                self.reponPieza( desde )
                                self.ayudas -= 1
                                desde = tutor.desde
                                hasta = tutor.hasta
                                coronacion = tutor.coronacion
                                siBien, mens, jgTutor = Jugada.dameJugada( self.partida.ultPosicion, desde, hasta, coronacion )
                                if siBien :
                                    jg = jgTutor
                        elif self.configuracion.guardarVariantesTutor :
                            tutor.ponVariantes( jg, 1+self.partida.numJugadas()/2 )

                        del tutor

            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.error = mens
            self.sigueHumano()
            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 )
        if self.partida.pendienteApertura :
            self.listaAperturasStd.asignaApertura( self.partida )

        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.ponAyudas( self.ayudas )

        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 self.siApertura or 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.error = ""
            self.masJugada( jg )
            self.beepExtendido()
            self.movimientosPiezas( jg.liMovs, True )

            return True
        else :
            self.error = mens
            return False

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

        self.beepResultado( quien )

        nombreContrario = "%s (%s %d)"%( self.xrival.nombre, tr("NIVEL"), self.nivelJugado )

        mensaje = tr("PARTIDA_TERMINADA")

        if quien == kGanamos :
            mensaje = tr( "ENHORABUENA", nombreContrario )
            hecho = "B" if self.siJugamosConBlancas else "N"
            if self.configuracion.rival.categorias.ponResultado( self.categoria, self.nivelJugado, hecho ) :
                mensaje += "<br><br>%s : %d (%s)"%( tr("PASA_NIVEL"), self.categoria.nivelHecho+1, self.categoria.nombre() )
            self.configuracion.graba()

        elif quien == kGanaRival :
            mensaje = tr( "HA_GANADO", nombreContrario )

        elif quien == kTablas :
            mensaje = tr( "TABLAS_CONTRA", nombreContrario )

        elif quien == kTablasRepeticion :
            mensaje = tr( "TABLAS_3REPETICION", self.rotuloTablasRepeticion, nombreContrario )
            self.resultado = kTablas

        elif quien == kTablas50 :
            mensaje = tr( "TABLAS_50", nombreContrario )
            self.resultado = kTablas

        elif quien == kTablasFaltaMaterial :
            mensaje = tr( "TABLAS_FALTA_MATERIAL", nombreContrario )
            self.resultado = kTablas

        self.guardarGanados(quien==kGanamos)
        QTUtil2.mensaje( self.pantalla, mensaje )
        self.ponFinJuego( )

