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

from operator import attrgetter

from Code.Traducir import tr
import Util

#==========================================================================================================================================
class AperturaStd :
    def __init__( self, clave ) :
        self.nombre = clave
        self.trNombre = tr(clave)
        self.nivel = 0
        self.padre = None
        self.hijos = []
        self.a1h8 = ""
        self.pgn = ""
        self.eco = ""
        self.siBasic = False

    def trPGN( self ) :
        p = ""
        pzs = "KQRBNPkqrbnp"
        pgn = self.pgn
        for n, c in enumerate(pgn) :
            if c in pzs and not pgn[n+1].isdigit() :
                c = tr( "PGN_" + c.upper() )
            p += c
        return p

    def __str__( self ) :
        return self.nombre + " " + self.pgn
#--------------------------------------------------------------------------------------------------------------

#--------------------------------------------------------------------------------------------------------------
class ListaAperturasStd :
    #--------------------------------------------------------------------------------------------------------------
    def __init__( self, configuracion, siBasic, siEntrenar ) :
        self.dic = {}
        self.hijos = []
        ficheroPers = configuracion.ficheroPersAperturas
        self.lee(ficheroPers, siEntrenar)
        self.lia1h8 = self.dic.keys()

        if siBasic :
            for bl in self.dic.itervalues() :
                bl.trOrdena = ( "A" if bl.siBasic else "B" ) + bl.trNombre.upper()
            self.hijos = self.ordena( self.hijos, 0 )

    #--------------------------------------------------------------------------------------------------------------
    def ordena( self, hijos, n ) :
        if hijos :
            hijos = sorted( hijos, key=attrgetter( "trOrdena" ) )
            for hijo in hijos :
                hijo.hijos = self.ordena( hijo.hijos, n+4 )
        return hijos
    #--------------------------------------------------------------------------------------------------------------
    def leeEstandar( self ) :
        q = open( "Openings/aperturasStd.pki", "rb" )
        txt = q.read()
        q.close()
        return txt
    #--------------------------------------------------------------------------------------------------------------
    def leePersonal(self, ficheroPers, siEntrenar ) :
        lista = Util.recuperaVar( ficheroPers )
        txt = ""
        if lista :
            for reg in lista :
                estandar = reg["ESTANDAR"]
                if siEntrenar or estandar :
                    txt += "\n[%(NOMBRE)s]\nECO=%(ECO)s\nA1H8=%(A1H8)s\nPGN=%(PGN)s\nBASIC=True"% reg
        return txt

    #--------------------------------------------------------------------------------------------------------------
    def lee( self, ficheroPers, siEntrenar ) :
        txt = self.leeEstandar()
        txt += self.leePersonal( ficheroPers, siEntrenar)

        li = txt.split("\n")

        bloque = None
        d = {}
        for linea in li :
            linea = linea.strip()
            if linea :
                if linea.startswith( "[" ) :
                    if bloque :
                        d[bloque.a1h8] = bloque
                    bloque = AperturaStd(linea.strip()[1:-1].strip())
                else :
                    c,v = linea.split("=")
                    if c == "A1H8" :
                        bloque.a1h8 = v
                    elif c == "PGN" :
                        bloque.pgn = v
                    elif c == "BASIC" :
                        bloque.siBasic = v == "True"
                    elif c == "ECO" :
                        bloque.eco = v
        d[bloque.a1h8] = bloque

        self.dic = d

        li = d.keys()
        li.sort()
        for k in li :
            bloque = d[k]
            a1h8 = bloque.a1h8
            n = a1h8.rfind(" ")
            while n > 0 :
                a1h8 = a1h8[:n]
                if a1h8 in d :
                    bloquePadre = d[a1h8]
                    nivel = bloquePadre.nivel + 1
                    if nivel > 4 :
                        bloquePadre = bloquePadre.padre
                        nivel = bloquePadre.nivel + 1
                    hijos = bloquePadre.hijos
                    if hijos is None :
                        bloquePadre.hijos = hijos = []
                    hijos.append( bloque )
                    bloque.padre = bloquePadre
                    bloque.nivel = nivel
                    break
                n = a1h8.rfind(" ")
            if n <= 0 :
                self.hijos.append( bloque )

    #--------------------------------------------------------------------------------------------------------------
    def asignaApertura( self, partida ) :
        partida.pendienteApertura = True
        a1h8 = ""
        for nj, jg in enumerate(partida.liJugadas) :
            if jg.siApertura :
                jg.siApertura = False
            a1h8 += jg.movimiento()
            if a1h8 in self.dic :
                partida.apertura = self.dic[a1h8]
                for nP in range(nj+1) :
                    partida.liJugadas[nP].siApertura = True
                noHayMas = True
                for k in self.dic:
                    if k.startswith(a1h8) and k != a1h8:
                        noHayMas = False
                        break
                if noHayMas :
                    partida.pendienteApertura = False # la ponemos como definitiva
                    return
            a1h8 += " "
        # Hay alguna posible ?
        a1h8 = a1h8.strip()
        for k in self.dic:
            if k.startswith( a1h8 ) :
                return # volvemos con la apertura pendiente aún
        partida.pendienteApertura = False # No hay ninguna aplicable

    #--------------------------------------------------------------------------------------------------------------
    def listaAperturasPosibles( self, partida ) :
        a1h8 = ""
        for jugada in partida.liJugadas :
            a1h8 += " " + jugada.movimiento()
        a1h8 = a1h8[1:]
        li = []

        # Las ordenamos para que estén antes las principales que las variantes
        lik = self.dic.keys()
        lik.sort()

        siBasic = len(partida.liJugadas) == 0

        for k in lik :
            if k.startswith(a1h8) and len(k) > len(a1h8) :
                # Comprobamos que no sea una variante de las añadidas, no nos interesan para mostrar opciones al usuario
                siMas = True
                for ap in li :
                    if k.startswith( ap.a1h8 ) :
                        siMas = False
                        break
                if siMas :
                    ap = self.dic[k]
                    ap.liMovs = a1h8[len(k):].strip().split(" ")
                    if siBasic and not ap.siBasic :
                        continue
                    li.append( ap )

        return li if li else None

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

