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

#==========================================================================================================================================
import time

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

import Util
import Jugada
import PGN

import Gestor

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

    #--------------------------------------------------------------------------------------------------------------------------------
    def inicio( self, fen, lineaPGN ) :

        me = self.procesador.unMomento()

        self.liMoscasActivas = self.procesador.gestorBase.liMoscasActivas

        self.fen = fen
        self.lineaPGN = lineaPGN

        self.siAceptado = False

        uno = PGN.UnPGN()
        uno.leeTexto( '[FEN "%s"]\n%s'%(fen,lineaPGN) )

        self.partida = uno.partida
        self.pgn.partida = self.partida

        self.tipoJuego = kJugSolo

        self.siJuegaHumano = True

        self.estado = kJugando

        self.siRevision = False

        self.siVolteoAutomatico = False
        self.pantalla.ponToolBar( ( k_aceptar,k_cancelar,k_atras,k_reiniciar,k_otros ) )

        self.siJugamosConBlancas = self.procesador.gestorBase.tablero.siBlancasAbajo
        self.pantalla.activaJuego(True, False)
        self.quitaAyudas(True, False)
        self.pantalla.ponRotulo1( None )
        self.pantalla.ponRotulo2( None )
        self.mostrarIndicador( True )
        self.ponPiezasAbajo( self.siJugamosConBlancas )
        self.ponMensajero( self.mueveHumano )
        self.pgnRefresh( True )
        self.ponCapturasPorDefecto()

        self.refresh()

        if self.partida.numJugadas() :
            self.mueveJugada( "p" )
            jg = self.partida.liJugadas[0]
            self.ponFlechaSC( jg.desde, jg.hasta )
            self.desactivaTodas()
        else :
            self.ponPosicion( self.partida.ultPosicion )

        me.final()

        siBlancas = self.partida.ultPosicion.siBlancas
        self.siJugamosConBlancas = siBlancas
        self.siJuegaHumano = True

        if not self.partida.numJugadas() :
            self.siguienteJugada()

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

        if clave == k_aceptar :
            self.siAceptado = True
            # self.resultado =
            self.pantalla.accept()

        elif clave == k_cancelar :
            self.pantalla.reject()

        elif clave == k_atras :
            self.atras()

        elif clave == k_reiniciar :
            self.reiniciar()

        elif clave == k_otros :
            self.otros()

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

    #--------------------------------------------------------------------------------------------------------------------------------
    def valor( self ) :
        if self.siAceptado :
            pgn = self.partida.pgnBase().replace( "\n", " " ).strip()
            a1h8 = self.partida.pv()
            return pgn, a1h8
        else :
            return None

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

    #--------------------------------------------------------------------------------------------------------------------------------
    def atras( self ) :
        if self.partida.numJugadas() :
            self.partida.anulaSoloUltimoMovimiento( )
            if not self.fen :
                self.listaAperturasStd.asignaApertura( self.partida )
            self.ponteAlFinal()
            self.siguienteJugada()

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

        if self.estado == kFinJuego :
            return

        self.estado = kJugando

        self.ponVista()

        siBlancas = self.partida.ultPosicion.siBlancas
        self.siJugamosConBlancas = siBlancas
        self.siJuegaHumano = True
        if self.siVolteoAutomatico :
            time.sleep( 1 )
            if siBlancas != self.tablero.siBlancasAbajo :
                self.tablero.rotaTablero()

        if self.partida.numJugadas() > 0 :
            jgUltima = self.partida.liJugadas[-1]
            if jgUltima :
                if jgUltima.siJaqueMate :
                    self.ponResultado( kGanaRival, jgUltima.posicion.siBlancas )
                    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.activaColor( siBlancas )
        self.refresh()

    #--------------------------------------------------------------------------------------------------------------------------------
    def mueveHumano( self, desde, hasta, coronacion = None ) : # se incluye coronacion para poder llamarlo desde libros

        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 :
                return False
        if coronacion :
            movimiento += coronacion

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

        if siBien :

            self.movimientosPiezas( jg.liMovs )

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

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

        self.siCambios = True

        # 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.pgnRefresh(self.partida.ultPosicion.siBlancas)
        self.refresh()

    #--------------------------------------------------------------------------------------------------------------------------------
    def ponResultado( self, quien, siBlancas = None ) :
        self.desactivaTodas( )

        self.resultadoQuien = quien
        self.resultadoSiBlancas = siBlancas

        self.resultado = quien

        if quien == kTablasRepeticion :
            self.resultado = kTablas

        elif quien == kTablas50 :
            self.resultado = kTablas

        elif quien == kTablasFaltaMaterial :
            self.resultado = kTablas

    #-----------------------------------------------------------------------------------
    def actualPGN( self ) :
        """
        Llamado para grabar el pgn
        """
        resp = ""
        st = set()
        hoy = Util.hoy()
        liPGN = []
        liPGN.append( ["Event",tr("El ajedrez de Lucas")] )
        liPGN.append( ["Date","%d.%02d.%02d"%(hoy.year, hoy.month, hoy.day)] )
        jugador = "unknown"
        liPGN.append( ["White", jugador] )
        liPGN.append( ["Black", jugador] )

        for eti, valor in liPGN :
            resp += '[%s "%s"]\n'%(eti,valor)
            st.add( eti )

        if "Result" not in st :
            if self.resultado == kDesconocido :
                result = "*"

            elif self.resultado == kTablas :
                result = "1/2-1/2"

            else :
                result = '1-0' if self.resultadoSiBlancas else '0-1'

            resp += '[Result "%s"]\n'%result
        else :
            result = st["Result"]

        if self.fen :
            cp = ControlPosicion.ControlPosicion()
            if self.fen != cp.fenInicial :
                resp += '[FEN "%s"]\n'%self.fen

        ap = self.partida.apertura
        if ap :
            if "ECO" not in st :
                resp += '[ECO "%s"]\n'%ap.eco
            if "Opening" not in st :
                resp += '[Opening "%s"]\n'%tr(ap.nombre)

        resp += self.partida.pgnBase() + " " + result

        return resp

    #-----------------------------------------------------------------------------------
    def reiniciar( self ) :
        self.inicio( self.fen, self.lineaPGN )

