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

import os
import operator
import shutil

from PySide import QtGui

from Traducir import *
from Code.Constantes import *

import Usu
import MotoresExternos

import Util

import VarGen

import QT.TabTipos as TabTipos

#-----------------------------------------------------------------------------------------------------
class Grupo :
    def __init__( self, nombre, desde, hasta, minPuntos, liRivales ) :
        self.nombre = nombre
        self.desde = desde
        self.hasta = hasta
        self.minPuntos = minPuntos
        self.liRivales = liRivales

    def puntuacion( self, siCompetitivo ) :
        pts = 0
        for cm in self.liRivales :
            pts += cm.puntuacion(siCompetitivo)
        return pts

    def limpia( self ) :
        for cm in self.liRivales :
            cm.limpia()

#-----------------------------------------------------------------------------------------------------
class Grupos :
    def __init__( self, conf ) :
        self.liGrupos = []
        li = []
        for clave,cm in conf.dicRivales.iteritems() :
            li.append( (cm.elo, clave, cm) )

        self.liRivales = sorted(li, key=operator.itemgetter(0))
        self.configuracion = conf

    def nuevo( self, nombre, desde, hasta, minPuntos ) :
        liRivalesUno = []
        for elo, clave, cm in self.liRivales :
            if elo >= desde and elo <= hasta  :
                liRivalesUno.append( cm )
        self.liGrupos.append( Grupo( nombre, desde, hasta, minPuntos, liRivalesUno ) )

    def puntuacion( self ) :
        puntos = 0
        siCompetitivo = self.configuracion.siModoCompetitivo()
        for g in self.liGrupos :
            if siCompetitivo and (puntos < g.minPuntos) :
                break
            else :
                puntos += g.puntuacion(siCompetitivo)
        return puntos

    def limpia( self ) :
        for g in self.liGrupos :
            g.limpia()

#-----------------------------------------------------------------------------------------------------
class Categoria :
    def __init__( self, clave, color, ayudas, sinAyudasFinal, valorPuntos ) :
        self.clave = clave
        self.color = color
        self.ayudas = ayudas
        self.sinAyudasFinal = sinAyudasFinal
        self.nivelHecho = 0
        self.hecho = ""
        self.valorPuntos = valorPuntos

    def nombre( self ) :
        return tr( self.clave )

    def siHechoBlancas( self ) :
        return "B" in self.hecho

    def graba( self ) :
        return self.clave + "," + str(self.nivelHecho) + "," + self.hecho

    def lee( self, txt ) :
        li = txt.split( "," )
        self.nivelHecho = int(li[1])
        self.hecho = li[2]

    def puntuacion( self, tope ) :
        p = 0
        tope = min(tope,self.nivelHecho+1)
        for nv in range( 1, tope ) :
            p += nv
        p *= 2
        if self.hecho :
            p += (self.nivelHecho+1)*len(self.hecho)

        return p * self.valorPuntos

    def maxPuntos( self ) :
        return (self.nivelHecho+1)*self.valorPuntos

    def limpia( self ) :
        self.nivelHecho = 0
        self.hecho = ""

#-----------------------------------------------------------------------------------------------------
class Categorias :
    def __init__( self ) :
        li = []
        li.append( Categoria( "PRINCIPIANTE", "Amarillo", 7, False, 5 ) )
        li.append( Categoria( "AFICIONADO", "Naranja", 5, False, 10 ) )
        li.append( Categoria( "CANDIDATOMAESTRO", "Verde", 3, False, 20 ) )
        li.append( Categoria( "MAESTRO", "Azul", 2, False, 40 ) )
        li.append( Categoria( "CANDIDATOGRANMAESTRO", "Magenta", 1, True, 80 ) )
        li.append( Categoria( "GRANMAESTRO", "Rojo", 0, True, 160 ) )
        self.lista = li

    def numero( self, num ) :
        return self.lista[num]

    def segunClave( self, clave ) :
        for una in self.lista :
            if una.clave == clave :
                return una
        return None

    def compruebaNivelesHechos( self ) :
        maxn = 10000
        for num, cat in enumerate(self.lista) :
            if len(cat.hecho) == 2 :
                if cat.nivelHecho < maxn :
                    cat.nivelHecho += 1
                    cat.hecho = ""
            maxn = cat.nivelHecho-1

    def ponResultado( self, categoria, nivel, hecho ) :
        if hecho not in categoria.hecho :
            categoria.hecho += hecho
            self.compruebaNivelesHechos( )
            return categoria.nivelHecho == nivel
        return False

    def graba( self ) :
        txt = ""
        for cat in self.lista :
            txt += cat.graba() + "|"
        return txt.rstrip( "|" )

    def lee( self, txt ) :
        for una in txt.split( "|" ) :
            clave = una.split( ",")[0]
            for cat in self.lista :
                if cat.clave == clave :
                    cat.lee( una )

    def puntuacion( self, siCompetitivo ) :
        p = 0
        maxNivel = 999999
        for cat in self.lista :
            n = cat.puntuacion(maxNivel)
            if n :
                p += n
            elif siCompetitivo :
                break
            maxNivel = cat.nivelHecho if siCompetitivo else 99999
        return p

    def limpia( self ) :
        for cat in self.lista :
            cat.limpia()

    def maxNivelCategoria( self, categoria ) :
        maxNivel = categoria.nivelHecho+1
        for num, cat in enumerate(self.lista) :
            if categoria.clave == cat.clave :
                if maxNivel > cat.nivelHecho :
                    maxNivel = cat.nivelHecho+1
                    hecho = categoria.hecho
                    puntos = maxNivel*cat.valorPuntos
                else :
                    hecho = ""
                    puntos = 0
                return maxNivel, hecho, puntos
            maxNivel = cat.nivelHecho

#-----------------------------------------------------------------------------------------------------
class ConfigMotor :
    def __init__( self, clave, autor, version, url, carpeta = None ) :
        self.clave = clave
        self.autor = autor
        self.version = version
        self.url = url
        self.puntos = 0
        self.path = ""
        self.siUCI = True
        self.liUCI = []
        self.multiPV = 0
        self.categorias = Categorias()
        self.siTutor = True
        self.siDebug = False
        if carpeta :
            self.carpeta = carpeta
        else :
            self.carpeta = clave

        self.nombre = Util.primeraMayuscula(self.carpeta)+ " " + self.version
        self.siExterno = False

    def debug( self, txt ) :
        self.siDebug = True
        self.nomDebug = self.nombre + "-" + txt

    def ordenUCI( self, comando, valor ) :
        self.liUCI.append( (comando, valor) )

    def winboard( self ) :
        self.siUCI = False

    def ponMultiPV( self, maximo ) :
        self.multiPV = maximo

    def graba( self ) :
        return self.clave + "#" + self.categorias.graba()

    def lee( self, txt ) :
        clave, txtCat = txt.split( "#" )
        self.categorias.lee( txtCat )

    def ejecutable( self ) :
        return "engines/%s/%s.exe"%( self.carpeta, self.path )

    def puntuacion( self, siCompetitivo ) :
        return self.categorias.puntuacion(siCompetitivo)

    def rotuloPuntos( self, siCompetitivo ) :
        puntos = self.puntuacion(siCompetitivo)
        eti = self.nombre
        if puntos :
            eti += " [%d %s]"%(puntos, tr( "ABREV_PUNTOS" ) )
        return eti

    def maxNivelCategoria( self, categoria ) :
        return self.categorias.maxNivelCategoria( categoria )

    def claveReal( self ) :
        return self.clave

    def limpia( self ) :
        self.categorias.limpia()

#-----------------------------------------------------------------------------------------------------
class ConfigTablero :
    def __init__( self, anchoPieza=32 ) :
        self.anchoPieza = anchoPieza
        self.porDefecto()

    def flechaDefecto( self ) :
        bf = TabTipos.Flecha()
        bf.grosor=1
        bf.altocabeza=20
        bf.tipo=1
        bf.destino="m"
        bf.anchoCasilla=36
        bf.color=4293848576
        bf.colorinterior=4292532736
        bf.opacidad=0.8
        bf.redondeos=True
        bf.forma="3"
        bf.ancho=4
        bf.vuelo=5
        bf.descuelgue=6
        bf.posicion.orden = kZvalue_pieza-1
        return bf

    def porDefecto( self ) :
        self.tipoPieza = "c"
        self.colorBlancas = 4294243572
        self.colorNegras = 4288588449
        self.colorExterior = 4278206043
        self.colorTexto = 4294243572 # version 6.0

        self.fTransicion = self.flechaDefecto()

    def graba( self ) :
        return str(self.colorExterior) + "#" \
                + str(self.anchoPieza) + "#" \
                + self.tipoPieza + "#" \
                + str(self.colorBlancas) + "#"\
                + str(self.colorNegras) + "#"\
                + Util.dic2txt(self.fTransicion) + "#"\
                + str(self.colorTexto) # version 6.0

    def lee( self, txt ) :
        self.porDefecto()
        li = txt.split( "#" )
        if len(li) >= 5 :
            self.colorExterior = int(li[0])
            self.anchoPieza = int(li[1])
            self.tipoPieza = li[2]
            self.colorBlancas = int(li[3])
            self.colorNegras = int(li[4])
            self.colorTexto = self.colorBlancas # version 6.0
            if len(li) >= 6 :
                txt = li[5]
                if txt.isdigit() :
                    self.fTransicion.color = int(txt)
                else :
                    self.fTransicion = Util.txt2dic(txt)
                if len(li) >= 7 : # version 6.0
                    self.colorTexto = int(li[6])

#-----------------------------------------------------------------------------------------------------
class Configuracion :

    def __init__( self, user ) :

        self.ponCarpetas( user )

        self.siMain = user == ""

        self.id = Usu.creaID()
        self.jugador = ""
        self.dirSalvados = ""
        self.dirPGN = ""
        self.dirJS = ""
        self.traductor = ""
        self.estilo="Cleanlooks"
        self.vistaTutor = kTutorH

        self.efectosVisuales = True
        self.guardarVariantesTutor = True

        self.siAtajosRaton = False

        self.siActivarCapturas = False

        self.modoNoCompetitivo = False

        self.elo = 0
        self.eloNC = 1600

        self.siDGT = False

        self.salvarGanados = False
        self.salvarPerdidos = False
        self.salvarAbandonados = False
        self.salvarFichero = ""

        self.salvarCSV = ""

        self.liTrasteros = []

        self.liFavoritos = []

        self.liPersonalidades = []

        self.leeRivales()

        self.rivalInicial = "tarrasch"
        self.rival = self.buscaRival( self.rivalInicial )

        self.tutorInicial = "stockfish"
        self.tutor = self.buscaRival( self.tutorInicial )
        self.tutorDifPts = 0
        self.tutorDifPorc = 0

        self.porDefecto()

        self.grupos = Grupos( self )

        self.grupos.nuevo( "TarraschToy", 0, 1999, 0 )
        self.grupos.nuevo( "Bikjump", 2000, 2300, 600 )
        self.grupos.nuevo( "Chispa", 2301, 2599, 1800 )
        self.grupos.nuevo( "Alaric", 2600, 2799, 3600 )
        self.grupos.nuevo( "Rybka", 2800, 3200, 6000 )

    #-----------------------------------------------------------------------------------
    def ponCarpetas( self, user ) :

        self.carpetaBase = "UsrData"
        self.carpetaUsers = "UsrData/users"

        if user :
            Util.creaCarpeta( self.carpetaUsers )
            self.carpeta = "%s/users/%s"%(self.carpetaBase,user)
            Util.creaCarpeta( self.carpeta )
        else :
            Util.creaCarpeta( self.carpetaBase )
            self.carpeta = self.carpetaBase

        self.fichero = self.carpeta + "/lk54.pik"

        Util.creaCarpeta( self.carpeta + "/confvid" )
        VarGen.plantillaVideo = self.carpeta + "/confvid/%s.video"

        self.userTRA = "%s/user.tra"%self.carpeta
        self.ficheroSounds = "%s/sounds.pkd"%self.carpeta
        self.fichEstadElo = "%s/estad.pkli"%self.carpeta
        self.ficheroBooks = "%s/books.lkv"%self.carpeta
        self.ficheroTrainBooks = "%s/booksTrain.lkv"%self.carpeta
        self.ficheroMate = "%s/mate.ddb"%self.carpeta
        self.ficheroMemoria = "%s/memo.pk"%self.carpeta
        self.ficheroMExternos = "%s/listaMotores.pkt"%self.carpeta
        self.ficheroRemoto = "%s/remoto.pke"%self.carpeta
        self.ficheroCliente = "%s/cliente.pke"%self.carpeta
        self.ficheroRemNueva = "%s/remnueva.pke"%self.carpeta
        self.ficheroEntMaquina = "%s/entmaquina.pke"%self.carpeta
        self.ficheroGM = "%s/gm.pke"%self.carpeta
        self.ficheroPuntuacion = "%s/punt.pke"%self.carpeta
        self.ficheroDirSound = "%s/direc.pkv"%self.carpeta
        self.ficheroMoscas = "%s/moscas.pkv"%self.carpeta
        self.ficheroEntAperturas = "%s/entaperturas.pkd"%self.carpeta
        self.ficheroEntAperturasPar = "%s/entaperturaspar.pkd"%self.carpeta
        self.ficheroPersAperturas = "%s/persaperturas.pkd"%self.carpeta
        self.ficheroAnalisis = "%s/paranalisis.pkd"%self.carpeta
        self.ficheroNivel = "%s/nivel.pkd"%self.carpeta
        self.ficheroTemas = "%s/themes.pkd"%self.carpeta

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

    def leeRivales( self ) :
        self.dicRivales = {}
        def mas( cm ) :
            self.dicRivales[cm.clave] = cm

        cm = ConfigMotor( "tarrasch", "Bill Forster", "ToyEngine Beta V0.905", "http://www.triplehappy.com/" )
        cm.path = "TarraschToyEngine"
        cm.ordenUCI( "Ponder", "false" )
        cm.elo = 1538
        # cm.ponMultiPV( 4 )
        mas(cm)

        cm = ConfigMotor( "bikjump", "Aart J.C. Bik", "2.01 (32-bit)", "http://www.aartbik.com/" )
        cm.path = "bikjump"
        cm.elo = 2184
        mas(cm)

        cm = ConfigMotor( "clarabit", "Salvador Pallares Bejarano", "1.00", "http://sapabe.googlepages.com" )
        cm.path = "clarabit_100_x32_win"
        cm.elo = 2218
        cm.ordenUCI( "OwnBook", "false" )
        cm.ordenUCI( "Ponder", "false" )
        mas(cm)

        cm = ConfigMotor( "lime", "Richard Allbert", "v 66", "http://www.geocities.com/taciturn_lemon" )
        cm.path = "Lime_v66"
        cm.elo = 2265
        cm.ordenUCI( "Ponder", "false" )
        mas(cm)

        cm = ConfigMotor( "chispa", "Federico Corigliano", "4.0.3", "http://chispachess.blogspot.com/" )
        cm.path = "chispa403-blend"
        cm.elo = 2368
        cm.ordenUCI( "Ponder", "false" )
        cm.ordenUCI( "Hash", "32" )
        mas(cm)

        cm = ConfigMotor( "pawny", "Mincho Georgiev", "0.3", "http://pawny.netii.net/" )
        cm.path = "windows/pawny_0.3_x86"
        cm.elo = 2533
        cm.ordenUCI( "OwnBook", "false" )
        mas(cm)

        cm = ConfigMotor( "gaia", "Jean-Francois Romang, David Rabel", "3.5", "http://gaiachess.free.fr" )
        cm.path = "gaia32"
        cm.elo = 2503
        cm.ordenUCI( "Ponder", "false" )
        mas(cm)

        cm = ConfigMotor( "umko", "Borko Boskovic", "0.7", "http://umko.sourceforge.net/" )
        cm.path = "w32/umko_x32"
        cm.elo = 2588
        mas(cm)

        cm = ConfigMotor( "garbochess", "Gary Linscott", "2.20", "http://forwardcoding.com/projects/chess/chess.html" )
        cm.path = "GarboChess2-32"
        cm.elo = 2625
        cm.ordenUCI( "Hash", "32" )
        mas(cm)

        cm = ConfigMotor( "ufim", "Niyas Khasanov", "8.02", "http://wbec-ridderkerk.nl/html/details1/Ufim.html" )
        cm.path = "ufim802"
        cm.elo = 2645
        cm.ordenUCI( "Ponder", "false" )
        cm.ordenUCI( "Hash", "32" )
        mas(cm)

        cm = ConfigMotor( "alaric", "Peter Fendrich", "707", "http://alaric.fendrich.se/index.html" )
        cm.path = "alaric707"
        cm.elo = 2766
        cm.ordenUCI( "BookFile", "" )
        cm.ordenUCI( "Ponder", "false" )
        cm.ordenUCI( "Hash", "32" )
        mas(cm)

        cm = ConfigMotor( "cyrano", "Harald Johnsen", "06B17", "http://sites.estvideo.net/tipunch/cyrano/" )
        cm.path = "cyrano"
        cm.elo = 2749
        cm.ordenUCI( "Ponder", "false" )
        cm.ordenUCI( "Hash", "32" )
        mas(cm)

        cm = ConfigMotor( "daydreamer", "Aaron Becker", "1.75 JA", "http://github.com/AaronBecker/daydreamer/downloads" )
        cm.path = "windows/32 bit/daydreamer-175-32-ja"
        cm.elo = 2781
        cm.ordenUCI( "Hash", "32" )
        # cm.ponMultiPV( 256 )
        mas(cm)

        cm = ConfigMotor( "glaurung", "Tord RomsTad", "2.2 JA", "http://www.glaurungchess.com/" )
        cm.path = "windows/glaurung-w32"
        cm.ordenUCI( "Ponder", "false" )
        cm.elo = 2870
        cm.ponMultiPV( 500 )
        mas(cm)

        cm = ConfigMotor( "toga", "Thomas Gaksch, Fabien Letouzey, Chris Formula", "II 1.4.1SE JA", "http://homepages.tesco.net/henry.ablett/jims.html" )
        cm.path = "toga_1cpu"
        cm.elo = 2930
        cm.ordenUCI( "Hash", "32" )
        cm.ponMultiPV( 10 )
        mas(cm)

        cm = ConfigMotor( "komodo", "Don Dailey, Larry Kaufman", "3 32bit", "http://komodochess.com/" )
        cm.path = "komodo3-32"
        cm.ordenUCI( "Ponder", "false" )
        cm.ordenUCI( "Hash", "32" )
        cm.elo = 3113
        cm.ponMultiPV( 99 )
        mas(cm)

        cm = ConfigMotor( "rybka", "Vasik Rajlich", "2.3.2a 32-bit", "http://rybkachess.com/" )
        cm.path = "Rybka v2.3.2a.w32"
        cm.elo = 3015
        cm.ordenUCI( "Hash", "32" )
        cm.ordenUCI( "Ponder", "false" )
        cm.ordenUCI( "Max CPUs", "1" )
        cm.ponMultiPV( 100 )
        mas(cm)

        cm = ConfigMotor( "critter", "Richard Vida", "1.2 32bits", "http://www.vlasak.biz/critter/" )
        cm.path = "Critter_1.2_32bit"
        cm.elo = 3155
        cm.ordenUCI( "Hash", "32" )
        cm.ordenUCI( "Threads", "1" )
        cm.ponMultiPV( 100 )
        mas(cm)

        cm = ConfigMotor( "stockfish", "Tord Romstad, Marco Costalba, Joona Kiiski", "2.1.1 JA", "http://www.stockfishchess.com" )
        cm.path = "windows/stockfish-211-32-ja"
        cm.elo = 3137
        cm.ordenUCI( "Ponder", "false" )
        cm.ordenUCI( "Hash", "32" )
        cm.ponMultiPV( 500 )
        mas(cm)

    #-----------------------------------------------------------------------------------
    def puntuacion( self ) :
        return self.grupos.puntuacion()

    #-----------------------------------------------------------------------------------
    def maxNivelCategoria( self, categoria ) :
        if self.siModoNoCompetitivo() :
            return categoria.nivelHecho+1, categoria.hecho, categoria.valorPuntos*(categoria.nivelHecho+1)
        return self.rival.maxNivelCategoria( categoria )

    #-----------------------------------------------------------------------------------
    def limpia( self, nombre ) :

        self.elo = 0
        self.grupos.limpia()
        self.id = Usu.creaID()
        self.jugador = nombre
        self.dirSalvados = ""
        self.dirPGN = ""
        self.dirJS = ""
        self.liTrasteros = []

        self.salvarGanados = False
        self.salvarPerdidos = False
        self.salvarAbandonados = False
        self.salvarFichero = ""

        self.siActivarCapturas = False
        self.siAtajosRaton = False

        self.salvarCSV = ""

        self.rival = self.buscaRival( self.rivalInicial )

    #-----------------------------------------------------------------------------------
    def buscaRival( self, clave, defecto = None ) :
        if clave in self.dicRivales :
            return self.dicRivales[clave]
        if defecto is None :
            defecto = self.rivalInicial
        return self.buscaRival(defecto)
    #-----------------------------------------------------------------------------------
    def buscaTutor( self, clave, defecto = None ) :
        if clave in self.dicRivales and self.dicRivales[clave].siTutor:
            return self.dicRivales[clave]

        listaMotoresExt = MotoresExternos.ListaMotoresExternos(self.ficheroMExternos)
        listaMotoresExt.leer()
        for motor in listaMotoresExt.liMotores :
            if clave == motor.alias :
                return MotoresExternos.ConfigMotor(motor)

        if defecto is None :
            defecto = self.tutorInicial
        return self.buscaRival(defecto)
    #-----------------------------------------------------------------------------------
    def buscaMotor( self, clave, defecto = None ) :
        if clave in self.dicRivales:
            return self.dicRivales[clave]

        listaMotoresExt = MotoresExternos.ListaMotoresExternos(self.ficheroMExternos)
        listaMotoresExt.leer()
        for motor in listaMotoresExt.liMotores :
            if clave == motor.alias :
                return MotoresExternos.ConfigMotor(motor)

        return self.buscaRival(defecto)
    #-----------------------------------------------------------------------------------
    def ayudaCambioTutor( self ) :
        li = [ ]
        listaMotoresExt = MotoresExternos.ListaMotoresExternos(self.ficheroMExternos)
        listaMotoresExt.leer()
        for motor in listaMotoresExt.liMotores :
            li.append( ( motor.alias, motor.alias + " *" ) )
        for clave,cm in self.dicRivales.iteritems() :
            if cm.siTutor :
                li.append( (clave, cm.nombre) )
        li = sorted(li, key=operator.itemgetter(1))
        li.insert( 0, self.tutor.clave )
        return li

    #-----------------------------------------------------------------------------------
    def comboMotores( self ) :
        li = [ ]
        for clave,cm in self.dicRivales.iteritems() :
            li.append( (cm.nombre, clave) )
        return li

    #-----------------------------------------------------------------------------------
    def comboMotoresCompleto( self ) :
        listaMotoresExt = MotoresExternos.ListaMotoresExternos(self.ficheroMExternos)
        listaMotoresExt.leer()
        liMotoresExt = []
        for motor in listaMotoresExt.liMotores :
            liMotoresExt.append( ( motor.alias + "*", "*"+motor.alias ) )

        li = self.comboMotores()
        li.extend( liMotoresExt )
        li = sorted(li, key=operator.itemgetter(0))
        return li

    #-----------------------------------------------------------------------------------
    def comboMotoresMultiPV20( self, minimo = 20 ) : #%#
        listaMotoresExt = MotoresExternos.ListaMotoresExternos(self.ficheroMExternos)
        listaMotoresExt.leer()
        liMotores = []
        for motor in listaMotoresExt.liMotores :
            if motor.multiPV >= minimo :
                liMotores.append( ( motor.alias + "*", "*"+motor.alias ) )

        for clave,cm in self.dicRivales.iteritems() :
            if cm.multiPV >= minimo :
                liMotores.append( (cm.nombre, clave) )

        li = sorted(liMotores, key=operator.itemgetter(0))
        return li

    #-----------------------------------------------------------------------------------
    def ayudaCambioCompleto( self, cmotor ) :
        li = [ ]
        listaMotoresExt = MotoresExternos.ListaMotoresExternos(self.ficheroMExternos)
        listaMotoresExt.leer()
        for motor in listaMotoresExt.liMotores :
            li.append( ( "*"+motor.alias, motor.alias + " *" ) )
        for clave,cm in self.dicRivales.iteritems() :
            li.append( (clave, cm.nombre) )
        li = sorted(li, key=operator.itemgetter(1))
        li.insert( 0, cmotor )
        return li

    #-----------------------------------------------------------------------------------
    def estilos( self ) :

        li = [ (x,x) for x in QtGui.QStyleFactory.keys() ]
        li.insert( 0, self.estilo )
        return li

    #-----------------------------------------------------------------------------------
    def porDefecto( self ) :

        self.tiempoTutor = 1000

        self.cTableroN = ConfigTablero( 48 )
        self.cTableroT = ConfigTablero( 24 )

        self.siSuenaBeep = False
        self.siSuenaJugada = False
        self.siSuenaResultados = False

        self.siAplazada = False

    #-----------------------------------------------------------------------------------
    def graba( self, aplazamiento = None ) :

        dic = {}
        dic["ID"] = self.id
        dic["JUGADOR"] = self.jugador
        dic["ESTILO"] = self.estilo
        dic["TIEMPOTUTOR"] = self.tiempoTutor
        dic["TABLERON"] = self.cTableroN.graba()
        dic["TABLEROT"] = self.cTableroT.graba()

        dic["SIBEEP"] = self.siSuenaBeep
        dic["SISUENAJUGADA"] = self.siSuenaJugada
        dic["SISUENARESULTADOS"] = self.siSuenaResultados
        dic["GUARDAR_VARIANTES"] = self.guardarVariantesTutor

        dic["DIRSALVADOS"] = self.dirSalvados
        dic["DIRPGN"] = self.dirPGN
        dic["DIRJS"] = self.dirJS
        dic["TRADUCTOR"] = self.traductor
        dic["SALVAR_FICHERO"] = self.salvarFichero
        dic["SALVAR_GANADOS"] = self.salvarGanados
        dic["SALVAR_PERDIDOS"] = self.salvarPerdidos
        dic["SALVAR_ABANDONADOS"] = self.salvarAbandonados
        dic["SALVAR_CSV"] = self.salvarCSV
        dic["VISTA_TUTOR"] = self.vistaTutor
        dic["EFECTOS_VISUALES"] = self.efectosVisuales
        dic["ATAJOS_RATON"] = self.siAtajosRaton
        dic["ACTIVAR_CAPTURAS"] = self.siActivarCapturas
        dic["RIVAL"] = self.rival.clave
        dic["TUTOR"] = self.tutor.clave
        dic["TUTOR_DIFPTS"] = self.tutorDifPts
        dic["TUTOR_DIFPORC"] = self.tutorDifPorc

        dic["SIDGT"] = self.siDGT

        dic["ELO"] = self.elo
        dic["MODONOCOMPETITIVO"] = self.modoNoCompetitivo
        dic["ELONC"] = self.eloNC
        dic["TRASTEROS"] = self.liTrasteros
        dic["FAVORITOS"] = self.liFavoritos
        dic["PERSONALIDADES"] = self.liPersonalidades

        for clave,rival in self.dicRivales.iteritems() :
            dic["RIVAL_%s"%clave] = rival.graba()
        if aplazamiento :
            dic["APLAZAMIENTO"] = Util.dic2txt(aplazamiento)
        Util.guardaDIC( dic, self.fichero )

        self.releeTRA( True )

    #-----------------------------------------------------------------------------------
    def lee( self ) :

        self.siAplazada = False

        if not os.path.isfile( self.fichero ) :
            self.compruebaCambioVersion( )

        else :
            dic = Util.recuperaDIC( self.fichero )
            if dic :
                self.id = dic["ID"]
                self.jugador = dic["JUGADOR"]
                self.estilo = dic.get("ESTILO", "Cleanlooks")
                self.tiempoTutor = dic["TIEMPOTUTOR"]
                self.cTableroN.lee(dic["TABLERON"])
                self.cTableroT.lee(dic["TABLEROT"])

                self.siSuenaBeep = dic["SIBEEP"]
                self.siSuenaJugada = dic.get( "SISUENAJUGADA", False )
                self.siSuenaResultados = dic.get( "SISUENARESULTADOS", False )

                self.efectosVisuales = dic.get("EFECTOS_VISUALES", True )
                self.siAtajosRaton = dic.get("ATAJOS_RATON", False )
                self.siActivarCapturas = dic.get("ACTIVAR_CAPTURAS", False )
                self.guardarVariantesTutor = dic.get("GUARDAR_VARIANTES", True )

                self.dirSalvados = dic["DIRSALVADOS"]
                self.dirPGN = dic.get("DIRPGN", "" )
                self.dirJS = dic.get("DIRJS", "" )
                self.traductor = str(dic["TRADUCTOR"]).lower()
                self.salvarFichero = dic["SALVAR_FICHERO"]
                self.salvarGanados = dic["SALVAR_GANADOS"]
                self.salvarPerdidos = dic["SALVAR_PERDIDOS"]
                self.salvarAbandonados = dic.get("SALVAR_ABANDONADOS", False )
                self.salvarCSV = dic.get("SALVAR_CSV", "" )
                self.vistaTutor = dic.get("VISTA_TUTOR", kTutorH )
                self.rival = self.buscaRival( dic["RIVAL"], self.rivalInicial )
                self.tutor = self.buscaTutor( dic["TUTOR"], self.tutorInicial )

                self.tutorDifPts = dic.get("TUTOR_DIFPTS", 0 )
                self.tutorDifPorc = dic.get("TUTOR_DIFPORC", 0 )
                self.elo = dic.get( "ELO", 0 )
                self.siDGT = dic.get( "SIDGT", False )
                self.modoNoCompetitivo = dic.get( "MODONOCOMPETITIVO", False )
                self.eloNC = dic.get( "ELONC", 1600 )
                self.liTrasteros = dic.get( "TRASTEROS", [] )
                self.liFavoritos = dic.get( "FAVORITOS", [] )
                self.liPersonalidades = dic.get( "PERSONALIDADES", [] )

                for k in dic.keys() :
                    if k.startswith( "RIVAL_" ) :
                        claveK = k[6:]
                        for clave, rival in self.dicRivales.iteritems() :
                            if rival.clave == claveK :
                                rival.lee( dic[k] )
                if "APLAZAMIENTO" in dic :
                    self.siAplazada = True
                    try :
                        self.aplazamiento = Util.txt2dic( dic["APLAZAMIENTO"] )
                    except :
                        self.aplazamiento = None
                        self.siAplazada = False
                    self.graba()

        self.dicTrad = { 'english':"en", 'espaņol':"es", 'francais':"fr", 'deutsch':"de", 'portuguese':"pt", 'russian':"ru" }

        for k,v in self.dicTrad.iteritems() :
            if os.path.isfile( v +'.pon' ) :
                self.traductor = k
                self.graba()
                os.remove( v +'.pon' )

        self.releeTRA( True )

    #-----------------------------------------------------------------------------------
    def releeTRA( self, siUser ) :

        if self.traductor :
            leeTraduccion( self.traductor )
        leeTradAperturas( self.traductor )
        leeTradNAGS( self.traductor )

        if siUser :
            try :
                leeUno( self.userTRA, False )
            except :
                pass

    #-----------------------------------------------------------------------------------
    def eloActivo( self ) :
        return self.eloNC if self.modoNoCompetitivo else self.elo

    #-----------------------------------------------------------------------------------
    def ponEloActivo( self, elo ) :
        if self.modoNoCompetitivo :
            self.eloNC = elo
        else :
            self.elo = elo

    #-----------------------------------------------------------------------------------
    def siModoNoCompetitivo( self ) :
        return self.modoNoCompetitivo
    #-----------------------------------------------------------------------------------
    def siModoCompetitivo( self ) :
        return not self.modoNoCompetitivo

    #-----------------------------------------------------------------------------------
    def lng( self ) :
        return self.dicTrad.get(self.traductor, "en" )

    #-----------------------------------------------------------------------------------
    def compruebaCambioVersion( self ) :
        v1 = "lk.pik"
        v2 = "lk2.pik"
        v30 = "lk30.pik"
        v35 = "lk35.pik"
        v40 = self.carpeta + "/lk40.pik"
        if os.path.isfile( v1 ) :
            dic = Util.recuperaDIC( v1 )
            Util.renombraNum( v1 )
            if dic :
                dic["MAXNIVEL0"] = dic["MAXNIVEL"]
                dic["MAXNIVELHECHO0"] = dic["MAXNIVELHECHO"]
                del dic["MAXNIVEL"]
                del dic["MAXNIVELHECHO"]
                dic["MAXNIVEL1"] = "0" if dic["MAXNIVEL0"] == "1" else "1"
                dic["MAXNIVELHECHO1"] = ""
                dic["MAXNIVEL2"] = "0"
                dic["MAXNIVELHECHO2"] = ""
                dic["MAXNIVEL3"] = "0"
                dic["MAXNIVELHECHO3"] = ""
                dic["MAXNIVEL4"] = "0"
                dic["MAXNIVELHECHO4"] = ""
                dic["MAXNIVEL5"] = "0"
                dic["MAXNIVELHECHO5"] = ""
                Util.guardaDIC( dic, v2 )

        if os.path.isfile( v2 ) :
            dic = Util.recuperaDIC( v2 )
            Util.renombraNum( v2 )
            if dic :

                dic["JUGADOR"] = dic["USUARIO"]
                self.cTableroN.colorExterior = int(dic["FONDOTABLERO"])
                self.cTableroT.colorExterior = int(dic["FONDOTABLEROTUTOR"])
                self.cTableroN.anchoPieza = int(dic["TAMTABLERO"])
                self.cTableroT.anchoPieza = int(dic["TAMTABLEROTUTOR"])
                self.dirSalvados = dic["DIRSALVADOS"]
                self.dirPGN = dic["DIRSALVADOS"]
                self.siSuenaBeep = dic["SIBEEP"] == "S"
                self.traductor = dic["TRADUCTOR"].lower()
                dic["TIEMPOTUTOR"] = self.tiempoTutor
                dic["TABLERON"] = self.cTableroN.graba()
                dic["TABLEROT"] = self.cTableroT.graba()
                dic["SIBEEP"] = self.siSuenaBeep
                dic["DIRSALVADOS"] = self.dirSalvados
                dic["DIRPGN"] = self.dirPGN
                dic["TRADUCTOR"] = self.traductor
                dic["SALVAR_FICHERO"] = self.salvarFichero
                dic["SALVAR_GANADOS"] = self.salvarGanados
                dic["SALVAR_PERDIDOS"] = self.salvarPerdidos
                dic["RIVAL"] = self.rivalInicial
                dic["TUTOR"] = self.tutorInicial

                rv = self.buscaRival( self.rivalInicial )
                for num,cat in enumerate( rv.categorias.lista ) :
                    cat.nivelHecho = int(dic[ "MAXNIVEL%d"%num ])
                    cat.hecho = dic[ "MAXNIVELHECHO%d"%num ]
                dic["RIVAL_%s"%self.rivalInicial] = rv.graba()

                Util.guardaDIC( dic, v30 )

        def cambiaRival( dic, antiguo, nuevo ) :
            claveN = "RIVAL_" + nuevo
            claveA = "RIVAL_" + antiguo
            if claveA in dic :
                cm = self.buscaRival( nuevo )
                cm.lee( dic[claveA] )
                del dic[claveA]
                dic[claveN] = cm.graba()
        def borraRival( dic, antiguo ) :
            claveA = "RIVAL_" + antiguo
            if claveA in dic :
                del dic[claveA]

        if os.path.isfile( v30 ) :
            dic = Util.recuperaDIC( v30 )
            Util.renombraNum( v30 )
            if dic :
                cambiaRival( dic, "gfruit", "gaia" )
                cambiaRival( dic, "pawny", "bikjump" )
                cambiaRival( dic, "greko", "umko" )
                cambiaRival( dic, "bison", "critter" )
                borraRival( dic, "demon" )
                dic["ID"] = Usu.creaID()
                dic["SALVAR_FICHERO"] = ""
                dic["SALVAR_GANADOS"] = False
                dic["SALVAR_PERDIDOS"] = False
                Util.guardaDIC( dic, v35 )

        if os.path.isfile( v35 ) :

            def cambiaDir( fich ) :
                if os.path.isfile( fich ) :
                    shutil.move( fich, self.carpeta )
            cambiaDir( "listaMotores.pkt" )
            cambiaDir( "entmaquina.pke" )
            cambiaDir( "memo.pk" )
            cambiaDir( "gm.pke" )
            cambiaDir( "cliente.pke" )
            cambiaDir( "remnueva.pke" )
            cambiaDir( "remoto.pke" )

            dic = Util.recuperaDIC( v35 )
            Util.renombraNum( v35 )
            Util.guardaDIC( dic, v40 )

        if os.path.isfile( v40 ) :
            dic = Util.recuperaDIC( v40 )

            for k in dic :
                if k.startswith("RIVAL_") :
                    txt = dic[k]
                    li = txt.split(",")
                    for n in range(len(li)) :
                        c = li[n]
                        if c.isdigit() and c != "0":
                            i = int(c)-1
                            li[n] = str(i)
                    dic[k] = ",".join(li)
                    if k.upper() == "RIVAL_TARRASCH" :
                        # tarrasch#PRINCIPIANTE,9,|AFICIONADO,8,|CANDIDATOMAESTRO,7,|MAESTRO,6,|CANDIDATOGRANMAESTRO,5,|GRANMAESTRO,4,
                        li = dic[k].split( "|" )
                        for n, t in enumerate(li) :
                            li1 = t.split(",")
                            pt = int(li1[1])
                            maximo = 9-n
                            if pt > maximo :
                                li1[1] = str(maximo)
                                li1[2] = "" # hecho
                                li[n] = ",".join(li1)
                        dic[k] = "|".join(li)

            Util.renombraNum( v40 )
            Util.guardaDIC( dic, self.fichero )
            self.lee()
            self.graba()

    #-----------------------------------------------------------------------------------
    def listaTraducciones( self ) :
        li = filter( lambda x : x.lower().endswith( ".tra" ) and (x.lower()!="lkbase.tra"), os.listdir( "Translations" ) )
        return map( lambda x : x[:-4].lower(), li )

    #-----------------------------------------------------------------------------------
    def listaMotores( self ) :
        li = []
        for k, v in self.dicRivales.iteritems() :
            li.append( ( v.nombre, v.autor, v.url ) )
        li = sorted(li, key=operator.itemgetter(0))
        return li

#-----------------------------------------------------------------------------------
#-----------------------------------------------------------------------------------
#-----------------------------------------------------------------------------------
#~ if __name__ == "__main__":
    #~ os.chdir( ".." )
    #~ conf = Configuracion()
    #~ prilk( conf.listaMotores() )

    #~ for g in conf.grupos.liGrupos :
        #~ prlk( g.nombre )
        #~ for cm in g.liRivales :
            #~ prlk( "     ", cm.elo, "-", cm.nombre, "-", cm.autor, "-", cm.url )
