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

#==========================================================================================================================================
import os
import operator

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

import Memoria

import GestorEntPos
import GestorEntMaq
import GestorPGN
import GestorGM
import GestorRemoto
import GestorSolo
import Gestor60
import GestorElo
import GestorMate
import GestorBooks
import GestorAperturas

import QT.QTUtil2 as QTUtil2
import QT.Controles as Controles
import QT.Iconos as Iconos
import QT.PantallaGM as PantallaGM
import QT.PantallaBooks as PantallaBooks
import QT.PantallaTT as PantallaTT
import QT.EntMaquina as EntMaquina
import QT.DatosNueva as DatosNueva
import QT.QTVarios as QTVarios
import QT.PantallaAperturas as PantallaAperturas
import QT.PantallaNivel as PantallaNivel

#==========================================================================================================================================
class Entrenamientos(  ) :

    #--------------------------------------------------------------------------------------------------------------------------------
    def __init__( self, procesador ) :
        self.procesador = procesador
        self.menu = None
        self.dicMenu = None

    #--------------------------------------------------------------------------------------------------------------------------------
    def creaMenu( self ) :
        dicMenu = {}

        def xopcion( menu, clave, texto, icono, siDeshabilitado = False ) :
            menu.opcion( clave, texto, icono, siDeshabilitado )
            dicMenu[clave] = (clave, texto, icono, siDeshabilitado )

        # Posiciones de entrenamiento --------------------------------------------------------------------------
        def listaFicherosFNS( dir ) :
            li = []
            for fd in os.listdir(dir) :
                fich = dir + "/" + fd
                if os.path.isfile( fich ) :
                    if fd.lower().endswith( ".fns" ):
                        txt = tr(fd[:-4])
                        li.append( ("f", fich, txt, "a"+txt.lower() ) )
                elif os.path.isdir( fich ) :
                    txt = tr(fd)
                    li.append( ( "d", listaFicherosFNS(dir+"/"+fd), txt, "b"+txt.lower() ) )
            li = sorted(li, key=operator.itemgetter(3))
            return li

        icono = Iconos.PuntoNaranja()
        carpeta = Iconos.Carpeta()
        def creaMenu( owner, titulo, liOpciones ) :
            menu1 = owner.submenu(titulo, carpeta)
            for tipo, valor, valortr, nada in liOpciones :
                if tipo == "f" :
                    xopcion( menu1, valor, valortr, icono )
                elif tipo == "d" :
                    creaMenu( menu1, valortr, valor )
                menu1.separador()
            owner.separador()
            return menu1
        menu = Controles.LMenu(puntos=10)
        creaMenu( menu, tr( "POSICIONES_ENTRENAMIENTO" ), listaFicherosFNS( "Trainings" ) )
        menu.separador()

        # GM ---------------------------------------------------------------------------------------------------
        xopcion( menu, "gm", tr("JUEGA_GRANMAESTRO" ), Iconos.GranMaestro() )
        menu.separador()

        # Libre ------------------------------------------------------------------------------------------------
        xopcion( menu, "entmaquina", tr("JUEGA_LIBRE" ), Iconos.Motor() )
        menu.separador()

        # Elo --------------------------------------------------------------------------------------------------
        modo = "" if self.procesador.configuracion.siModoCompetitivo() else " - "+tr( "MODONOCOMPETITIVO" )
        xopcion( menu, "elo", tr("ELO_MENU") + " ( %d )%s"%(self.procesador.configuracion.eloActivo(),modo), Iconos.Elo() )
        menu.separador()

        # Mate --------------------------------------------------------------------------------------------------
        menu1 = menu.submenu( tr( "MATE_MENU" ), Iconos.Mate() )
        for mate in range( 1, 5 ) :
            xopcion( menu1, "mate%d"%mate, tr("MATE_EN",str(mate)), Iconos.PuntoAzul() )
            menu1.separador()
        menu.separador()

        # Tutoriales -------------------------------------------------------------------------------------------
        # menu.opcion( "tutoriales", tr("TUTORIALES"), Iconos.Tutoriales() )
        # menu.separador()

        # Books ------------------------------------------------------------------------------------------------
        xopcion( menu, "polyglot", tr("LIBROS_ENTRENAR"), Iconos.TB_Libros() )
        menu.separador()

        # Aperturas --------------------------------------------------------------------------------------------
        xopcion( menu, "aperturas", tr("APERTURAS_ENTRENAR"), Iconos.Apertura() )
        menu.separador()

        # Nivel ------------------------------------------------------------------------------------------------
        xopcion( menu, "nivel", tr("NIVEL_AJEDREZ"), Iconos.Nivel() )
        menu.separador()

        # Utilidades -------------------------------------------------------------------------------------------
        menu1 = menu.submenu( tr( "UTILIDADES" ), Iconos.Utilidades() )

        xopcion( menu1, "pgn_visor", tr("PGN_VISOR" ), Iconos.PGN() )
        menu1.separador()
        menu2 = menu1.submenu( tr( "REMOTO" ), Iconos.Remoto() )
        xopcion( menu2, "remoto_servidor", tr("REMOTO_SERVIDOR" ), Iconos.RemotoServidor())
        menu2.separador()
        xopcion( menu2, "remoto_cliente", tr("REMOTO_CLIENTE" ), Iconos.RemotoCliente() )
        menu1.separador()
        xopcion( menu1, "juega_solo", tr("JUEGA_SOLO" ), Iconos.JuegaSolo() )

        menu.separador()

        # Principiantes ----------------------------------------------------------------------------------------
        menu1 = menu.submenu( tr( "ZONAPRINCIPIANTES" ), Iconos.ZonaPrincipiantes() )
        menu2 = menu1.submenu( tr("RIVALES_MUY_PRINCIPIANTES" ), Iconos.RivalesMP() )

        x = self.iniPrincipiantes = -8

        mp1 = Iconos.MP1()
        mp2 = Iconos.MP2()
        mp3 = Iconos.MP3()
        mp4 = Iconos.MP4()
        mp5 = Iconos.MP5()
        mp6 = Iconos.MP6()
        mp7 = Iconos.MP7()

        menu3 = menu2.submenu( tr("MODO_NORMAL" ), Iconos.PuntoAzul() )
        xopcion( menu3, x, tr("RIVAL_1" ), mp1 )
        xopcion( menu3, x-1, tr("RIVAL_2" ), mp2 )
        xopcion( menu3, x-2, tr("RIVAL_3" ), mp3 )
        xopcion( menu3, x-3, tr("RIVAL_4" ), mp4 )
        xopcion( menu3, x-4, tr("RIVAL_5" ), mp5 )
        xopcion( menu3, x-5, tr("RIVAL_6" ), mp6 )
        xopcion( menu3, x-6, tr("RIVAL_7" ), mp7 )

        menu2.separador()

        menu3 = menu2.submenu( tr("MODO_TIEMPO" ),  Iconos.MoverTiempo() )
        icono = Iconos.PuntoVerde()
        li =  ( tr("5MINUTOS"), tr("3MINUTOS"), tr("1MINUTO"), tr( "?MINUTOS" ) )
        for mensaje in li :
            x -= 7

            menu4 = menu3.submenu( mensaje,  icono )
            xopcion( menu4, x,   tr("RIVAL_1" ), mp1 )
            xopcion( menu4, x-1, tr("RIVAL_2" ), mp2 )
            xopcion( menu4, x-2, tr("RIVAL_3" ), mp3 )
            xopcion( menu4, x-3, tr("RIVAL_4" ), mp4 )
            xopcion( menu4, x-4, tr("RIVAL_5" ), mp5 )
            xopcion( menu4, x-5, tr("RIVAL_6" ), mp6 )
            xopcion( menu4, x-6, tr("RIVAL_7" ), mp7 )

            menu3.separador()

        menu1.separador()

        menu2 = menu1.submenu( tr( "MEMORIA" ), Iconos.Memoria() )
        rival = self.procesador.configuracion.rival

        mem = Memoria.Memoria(self.procesador)

        for x in range(6) :
            cat = rival.categorias.numero(x)
            txt = cat.nombre()

            nm = mem.nivel( x )
            if nm > -1 :
                txt += " %s %d"%(tr( "NIVEL" ), nm+1)

            icono = eval( "Iconos.%s()"%cat.color )

            xopcion( menu2, -100-x, txt, eval( "Iconos.%s()"%cat.color ), siDeshabilitado = not mem.siActiva(x) )

        menu1.separador()

        menu2 = menu1.submenu( tr( "J60" ), Iconos.J60() )
        xopcion( menu2, "j60_rival", tr("RIVAL" ), Iconos.PuntoNaranja() )
        xopcion( menu2, "j60_jugador",  tr("JUGADOR" ), Iconos.PuntoAzul() )

        return menu, dicMenu

    #--------------------------------------------------------------------------------------------------------------------------------
    def menuFavoritos( self, liFavoritos ) :

        menu = Controles.LMenu(puntos=10)

        for clave, texto, icono, siDeshabilitado in liFavoritos :
            menu.opcion( clave, texto, icono, siDeshabilitado )
            menu.separador()

        menu.opcion( "menu_global", tr( "TB_ENTRENAMIENTO" ), Iconos.TB_Entrenamiento() )

        return menu

    #--------------------------------------------------------------------------------------------------------------------------------
    def comprueba( self ) :
        if self.menu is None :
            self.menu, self.dicMenu = self.creaMenu()

    #--------------------------------------------------------------------------------------------------------------------------------
    def lanza( self, siFavoritos = True ) :

        self.comprueba()

        liFavoritos = None
        if siFavoritos :
            liFav = self.procesador.configuracion.liFavoritos
            if liFav :
                li = []
                for elem in liFav :
                    if elem in self.dicMenu :
                        li.append( self.dicMenu[elem] )
                liFavoritos = li

        if liFavoritos :
            menu = self.menuFavoritos(liFavoritos)
        else :
            menu = self.menu

        resp = menu.lanza()

        if resp :
            siStr = type(resp) == type("")
            if siStr :
                if resp == "menu_global" :
                    self.lanza( False )

                elif resp == "gm" :
                    self.entrenaGM()

                elif resp == "entmaquina" :
                    dic = EntMaquina.entrenamientoMaquina( self.procesador.pantalla, self.procesador.configuracion, tr("JUEGA_LIBRE" ) )
                    if dic :
                        self.entrenaMaquina( dic )

                elif resp == "elo" :
                    self.menu = None # ya que puede cambiar y la etiqueta es diferente
                    self.jugarElo()

                elif resp.startswith( "mate" ) :
                    self.jugarMate(int(resp[-1]))

                elif resp == "tutoriales" :
                    self.tutoriales()

                elif resp == "polyglot" :
                    self.entrenaBooks()

                elif resp == "pgn_visor" :
                    self.visorPGN()

                elif resp in ["remoto_cliente","remoto_servidor"] :
                    if self.procesador.configuracion.jugador.strip() :
                        self.jugamosRemoto( resp == "remoto_servidor" )
                    else :
                        QTUtil2.mensError( self.procesador.pantalla, tr( "FALTA_JUGADOR" ) )

                elif resp == "juega_solo" :
                    self.jugarSolo()

                elif resp in ["j60_rival", "j60_jugador"] :
                    self.jugar60( resp == "j60_jugador" )

                elif resp == "aperturas" :
                    self.aperturas()

                elif resp == "nivel" :
                    self.nivelAjedrez()

                else :
                    entreno = resp
                    if "/" in resp :
                        titentreno = ""
                        for x in resp[:-4].split("/")[1:] :
                            titentreno += tr(x) + "/"
                        titentreno = titentreno[:-1]
                    f = open( entreno, "rb" )
                    todo = f.read().strip()
                    f.close()
                    liEntrenamientos = todo.split("\n")
                    nPosiciones = len(liEntrenamientos)
                    if nPosiciones == 0 :
                        return
                    elif nPosiciones == 1 :
                        pos = 1
                    else :
                        pos = DatosNueva.numEntrenamiento( self.procesador.pantalla, titentreno, nPosiciones )
                        if pos is None :
                            return
                    self.entrenaPos( pos, nPosiciones, titentreno, liEntrenamientos )

            else :
                if resp <= -100 :
                    self.menu = None # ya que puede cambiar y la etiqueta es diferente
                    mem = Memoria.Memoria(self.procesador)
                    mem.lanza( abs(resp)-100 )

                elif resp <= self.iniPrincipiantes :
                    lis = ( ( kMP_1, False ),
                            ( kMP_2, False ),
                            ( kMP_3, False ),
                            ( kMP_4, False ),
                            ( kMP_5, False ),
                            ( kMP_6, True ),
                            ( kMP_7, True ) )
                    pos = abs(resp) + self.iniPrincipiantes
                    siTiempo = pos >= 7
                    segundos = 0
                    if siTiempo :
                        posminutos = int(pos/7)-1
                        pos = pos%7
                        minutos = [5,3,1,0][posminutos]
                        if minutos == 0 :
                            resp = QTVarios.tiempo( self.procesador.pantalla )
                            if resp is None:
                                return
                            minutos, segundos = resp
                    else :
                        minutos = 0
                    quien, siApertura = lis[pos]
                    if not siTiempo :
                        minutos = 0
                    self.entrenaRivalesMP( quien, siApertura, minutos, segundos )

    #-----------------------------------------------------------------------------------
    def entrenaPos( self, posicion, nPosiciones, titentreno, liEntrenamientos ) :
        self.procesador.tipoJuego = kJugEntPos
        self.procesador.estado = kJugando
        self.procesador.gestor = GestorEntPos.GestorEntPos( self.procesador )
        self.procesador.gestor.inicio( posicion, nPosiciones, titentreno, liEntrenamientos )

    #--------------------------------------------------------------------------------------------------------------------------------
    def entrenaMaquina( self, dic, aplazamiento=None ) :
        self.procesador.tipoJuego = kJugEntMaq
        self.procesador.estado = kJugando
        self.procesador.gestor = GestorEntMaq.GestorEntMaq( self.procesador )
        self.procesador.gestor.inicio( dic, aplazamiento )

    #--------------------------------------------------------------------------------------------------------------------------------
    def entrenaRivalesMP( self, rival, siApertura, nMinutos, nSegundos ) :

        resp = QTVarios.blancasNegras( self.procesador.pantalla )
        if resp is None :
            return

        siBlancas = resp

        dic = {}
        dic["SIBLANCAS"] = siBlancas
        dic["FEN"] = ""
        dic["AYUDAS"] = 0
        dic["APERTURA"] = None
        dic["SIAPERTURA"] = siApertura

        dr = dic["RIVAL"] = {}
        dr["MOTOR"] = rival
        dr["TIEMPO"] = 0
        dr["PROFUNDIDAD"] = 0

        dr = dic["TUTOR"] = {}

        dr["MOTOR"] = self.procesador.configuracion.tutor.claveReal()
        dr["TIEMPO"] = self.procesador.configuracion.tiempoTutor/100
        dr["PROFUNDIDAD"] = 0

        dic["SITIEMPO"] = nMinutos > 0
        if dic["SITIEMPO"] :
            dic["MINUTOS"] = nMinutos
            dic["SEGUNDOS"] = nSegundos

        dic["ATRAS"] = True

        self.entrenaMaquina( dic )

    #--------------------------------------------------------------------------------------------------------------------------------
    def entrenaGM( self ) :
        w = PantallaGM.WGM( self.procesador )
        if w.exec_() :
            self.procesador.tipoJuego = kJugGM
            self.procesador.estado = kJugando
            self.procesador.gestor = GestorGM.GestorGM( self.procesador )
            self.procesador.gestor.inicio( w.gm, w.siBlancas, w.siJuez, w.motor, w.tiempo, w.mostrar, w.jugContrario, w.jugInicial )

    #--------------------------------------------------------------------------------------------------------------------------------
    def entrenaBooks( self ) :
        w = PantallaBooks.WBooks( self.procesador )
        if w.exec_() and w.libro :
            self.procesador.tipoJuego = kJugBooks
            self.procesador.estado = kJugando
            self.procesador.gestor = GestorBooks.GestorBooks( self.procesador )
            self.procesador.gestor.inicio( w.libro, w.siBlancas, w.jugContrario, w.jugJugador )

    #--------------------------------------------------------------------------------------------------------------------------------
    def visorPGN( self ) :
        self.procesador.tipoJuego = kJugPGN
        self.procesador.estado = kJugando
        self.procesador.gestor = GestorPGN.GestorPGN( self.procesador )
        self.procesador.gestor.inicio( )

    #--------------------------------------------------------------------------------------------------------------------------------
    def jugamosRemoto( self, siServidor ) :
        self.procesador.tipoJuego = kJugRemoto
        self.procesador.estado = kJugando
        self.procesador.gestor = GestorRemoto.GestorRemoto( self.procesador )
        self.procesador.gestor.conexion( siServidor )

    #--------------------------------------------------------------------------------------------------------------------------------
    def jugarSolo( self ) :
        self.procesador.gestor = GestorSolo.GestorSolo( self.procesador )
        self.procesador.gestor.inicio( )

    #--------------------------------------------------------------------------------------------------------------------------------
    def jugar60( self, siJugador ) :
        self.procesador.gestor = Gestor60.Gestor60( self.procesador )
        self.procesador.gestor.inicio( siJugador )

    #--------------------------------------------------------------------------------------------------------------------------------
    def jugarMate( self, tipo ) :
        self.procesador.gestor = GestorMate.GestorMate( self.procesador )
        self.procesador.gestor.inicio( tipo )

    #--------------------------------------------------------------------------------------------------------------------------------
    def jugarElo( self ) :
        self.procesador.gestor = GestorElo.GestorElo( self.procesador )
        resp = QTVarios.eligeMotorElo( self.procesador.gestor, self.procesador.configuracion.eloActivo() )
        if resp :
            self.procesador.gestor.inicio( resp )

    #--------------------------------------------------------------------------------------------------------------------------------
    def tutoriales( self ) :
        w = PantallaTT.WTutoriales( self.procesador )
        w.exec_()

    #--------------------------------------------------------------------------------------------------------------------------------
    def aperturas( self ) :
        w = PantallaAperturas.EntrenamientoAperturas( self.procesador )
        if w.exec_() :
            listaAperturasStd, ficheroDatos, lista, fila, jugamos, repeticiones = w.resultado
            self.procesador.gestor = GestorAperturas.GestorAperturas( self.procesador )
            self.procesador.gestor.inicio( listaAperturasStd, ficheroDatos, lista, fila, jugamos, repeticiones, 0 )

    #--------------------------------------------------------------------------------------------------------------------------------
    def nivelAjedrez( self ) :
        PantallaNivel.pantallaNivel( self.procesador )

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