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

import os
import subprocess

from PySide import QtCore, QtGui

from Code.Traducir import tr

import Code.Util as Util
import Code.Books as Books

import QTUtil2
import Colocacion
import Iconos
import Controles

import FormLayout

#==========================================================================================================================================
class WBooksCrear( QtGui.QDialog ):

    def __init__( self, wParent ) :

        QtGui.QDialog.__init__(self, wParent)

        self.wParent = wParent

        self.fichero = ""

        self.setWindowTitle( tr( "LIBROS_CREAR" ) )
        self.setWindowIcon( Iconos.TB_Libros() )
        self.setWindowFlags( QtCore.Qt.Dialog | QtCore.Qt.WindowTitleHint )

        f = Controles.TipoLetra( puntos=10, peso=75 )

        lbFichero = Controles.LB( tr( "LIBROS_FICHERO" ) + ":").ponFuente( f )
        self.btFichero = Controles.PB( self, "", self.buscaFichero, False ).anchoMinimo( 450 ).ponFuente( f )
        lbMaxPly = Controles.LB( tr( "LIBROS_MAXPLY" ) + ":").ponFuente( f )
        self.sbMaxPly = Controles.SB( 0, 0, 999 ).tamMaximo( 50 )
        lbMinGame = Controles.LB( tr( "LIBROS_MINGAME" ) + ":").ponFuente( f )
        self.sbMinGame = Controles.SB( 3, 1, 999 ).tamMaximo( 50 )
        lbMinScore = Controles.LB( tr( "LIBROS_MINSCORE" ) + ":").ponFuente( f )
        self.sbMinScore = Controles.SB( 0, 0, 999 ).tamMaximo( 50 )
        self.chbOnlyWhite = Controles.CHB( tr("LIBROS_ONLYWHITE"), False).ponFuente( f )
        self.chbOnlyBlack = Controles.CHB( tr("LIBROS_ONLYBLACK"), False).ponFuente( f )
        self.chbUniform = Controles.CHB( tr("LIBROS_UNIFORM"), False).ponFuente( f )

        lyf = Colocacion.H().control(lbFichero).control(self.btFichero)
        ly = Colocacion.G().margen(15)
        ly.otroc( lyf, 0, 0, 1, 2 )
        ly.controld( lbMaxPly, 1, 0 ).control( self.sbMaxPly, 1, 1 )
        ly.controld( lbMinGame, 2, 0 ).control( self.sbMinGame, 2, 1 )
        ly.controld( lbMinScore, 3, 0 ).control( self.sbMinScore, 3, 1 )
        ly.controlc( self.chbOnlyWhite, 4, 0, 1, 2 )
        ly.controlc( self.chbOnlyBlack, 5, 0, 1, 2 )
        ly.controlc( self.chbUniform, 6, 0, 1, 2 )

        # Toolbar
        liAcciones = [  ( tr( "ACEPTAR" ), Iconos.TB_Aceptar(), "aceptar" ), None,
                        ( tr( "CANCELAR" ), Iconos.TB_Cancelar(), "cancelar" ), None
                    ]
        tb = Controles.TB( self, liAcciones )

        # Layout
        layout = Colocacion.V().control(tb).otro(ly).margen( 3 )
        self.setLayout( layout )

    #--------------------------------------------------------------------------------------------------------------------------------
    def buscaFichero( self ) :
        path = QTUtil2.salvaFichero( self, tr( "LIBROS_FICHERO" ), self.wParent.gestor.configuracion.dirSalvados, tr("FICHERO")+" %s (*.%s)"%("bin","bin") )
        if path is not None :
            self.fichero = path
            self.btFichero.ponTexto( self.fichero )

    #--------------------------------------------------------------------------------------------------------------------------------
    def procesarTB( self ) :
        accion = self.sender().clave
        if accion == "aceptar" :
            self.aceptar()
        elif accion == "cancelar" :
            self.reject()

    #--------------------------------------------------------------------------------------------------------------------------------
    def aceptar( self ) :
        if not self.fichero :
            return

        me = QTUtil2.mensEspera.inicio( self, tr( "UN_MOMENTO" ) )

        # Creamos el pgn
        fichTemporal = "deleteme.bak"
        fw = open( fichTemporal, "wb" )
        dbf = self.wParent.dbf
        antSelect = dbf.select
        nueSelect = antSelect + ",JUGADAS"
        dbf.ponSelect( nueSelect )
        dbf.leer()
        dbf.gotop()
        liOrdenClaves = self.wParent.liOrdenClaves
        for i in range(dbf.reccount()) :
            dbf.goto(i)
            dic = dbf.dicValores()
            result = dic["RESULT"]
            if result :
                result = result.replace( " ", "" )
                if result in ( "1-0", "0-1", "1/2-1/2" ) :
                    for clave in liOrdenClaves :
                        valor = dic[clave]
                        if valor is not None :
                            fw.write( '[%s "%s"]\n'%(clave,valor) )

                    jg = dic["JUGADAS"].strip().replace( "e.p.", "" ).replace( "#+", "#" )
                    if not jg.endswith( result ) :
                        jg += " " + result
                    fw.write( jg + "\n\n" )

        fw.close()
        dbf.ponSelect( antSelect )
        dbf.leer()

        # Creamos la línea de órdenes

        li = [ os.path.abspath('engines/polyglot/polyglot.exe'), 'make-book', "-pgn", fichTemporal, "-bin", self.fichero ]
        Util.borraFichero( self.fichero )

        maxPly = self.sbMaxPly.valor()
        minGame = self.sbMinGame.valor()
        minScore = self.sbMinScore.valor()
        onlyWhite = self.chbOnlyWhite.valor()
        onlyBlack = self.chbOnlyBlack.valor()
        uniform = self.chbUniform.valor()
        if maxPly :
            li.append( "-max-ply" )
            li.append( "%d"%maxPly )
        if minGame and minGame != 3 :
            li.append( "-min-game" )
            li.append( "%d"%minGame )
        if minScore :
            li.append( "-min-score" )
            li.append( "%d"%minScore )
        if onlyBlack :
            li.append( "-only-black" )
        if onlyWhite :
            li.append( "-only-white" )
        if uniform :
            li.append( "-uniform" )

        # Ejecutamos
        process = subprocess.Popen( li, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

        # Mostramos el resultado
        txt = process.stdout.read()
        if os.path.isfile( self.fichero ) :
            txt += "\n" + tr( "LIBROS_CREADO", self.fichero )
        me.final()
        QTUtil2.mensaje( self, txt )

        Util.borraFichero( fichTemporal )

        self.accept()

#==========================================================================================================================================
def polyglotCrear( owner ) :
    w = WBooksCrear( owner )
    w.exec_()

#==========================================================================================================================================
def polyglotUnir( owner ) :
    lista = [(None,None)]

    dict1 = { "FICHERO": "", "EXTENSION":"bin", "SISAVE":False }
    lista.append( ( tr("FICHERO") + " 1 :", dict1 ) )
    dict2 = { "FICHERO": "", "EXTENSION":"bin", "SISAVE":False }
    lista.append( ( tr("FICHERO") + " 2 :", dict2 ) )
    dictr = { "FICHERO": "", "EXTENSION":"bin", "SISAVE":True }
    lista.append( ( tr("LIBROS_FICHERO") +" :", dictr ) )

    while True :
        resultado = FormLayout.fedit( lista, title= tr( "LIBROS_UNIR" ), parent = owner, anchoMinimo = 460, icon = Iconos.TB_Libros(), siDefecto = False )
        if resultado :
            resultado = resultado[1]
            error = None
            f1 = resultado[0]
            f2 = resultado[1]
            fr = resultado[2]

            if (not f1) or (not f2) or (not fr) :
                error = tr( "LIBROS_ERROR_FALTAN" )
            elif f1 == f2 :
                error = tr("FICHERO") + " 1 = " + tr("FICHERO") + " 2"
            elif f1 == fr :
                error = tr("FICHERO") + " 1 = " + tr("LIBROS_FICHERO")
            elif f2 == fr :
                error = tr("FICHERO") + " 2 = " + tr("LIBROS_FICHERO")

            if error :
                dict1["FICHERO"] = f1
                dict2["FICHERO"] = f2
                dictr["FICHERO"] = fr
                QTUtil2.mensError( owner, error )
                continue
        else :
            return

        li = [ os.path.abspath('engines/polyglot/polyglot.exe'), 'merge-book', "-in1", f1, "-in2", f2, "-out", fr ]
        try :
            os.remove( fr )
        except :
            pass

        # Ejecutamos
        me = QTUtil2.mensEspera.inicio( owner, tr( "UN_MOMENTO" ) )

        process = subprocess.Popen( li, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

        # Mostramos el resultado
        txt = process.stdout.read()
        if os.path.isfile( fr ) :
            txt += "\n" + tr( "LIBROS_CREADO", fr )
        me.final()
        QTUtil2.mensaje( owner, txt )

        return

#==========================================================================================================================================
class WBooks( QtGui.QDialog ):

    def __init__(self, procesador )  :

        wParent = procesador.pantalla
        self.configuracion = procesador.configuracion
        self.procesador = procesador
        self.siCambios = False

        QtGui.QDialog.__init__(self,wParent)

        self.setWindowTitle( tr("LIBROS_ENTRENAR") )
        self.setWindowIcon( Iconos.TB_Libros() )
        self.setWindowFlags( QtCore.Qt.Dialog | QtCore.Qt.WindowTitleHint | QtCore.Qt.WindowMinimizeButtonHint )

        self.setMinimumWidth( 450 )

        flb = Controles.TipoLetra( puntos=10 )

        # Variables antiguas
        dic = self.recuperaDIC()
        if dic is None :
            dic = {}
        dic_siBlancas = dic.get( "SIBLANCAS", True )
        dic_nomLibro = dic.get( "NOMLIBRO", "" )
        dic_RR = dic.get( "RR", "au" )
        dic_RJ = dic.get( "RJ", False )

        # Toolbar
        liAcciones = [  ( tr( "ACEPTAR" ), Iconos.TB_Aceptar(), "aceptar" ), None,
                        ( tr( "CANCELAR" ), Iconos.TB_Cancelar(), "cancelar" ), None,
                    ]
        tb = Controles.TB( self, liAcciones )

        # Color
        self.rbBlancas = QtGui.QRadioButton( tr( "PGN_WHITE" ) )
        self.rbBlancas.setChecked( dic_siBlancas )
        self.rbNegras = QtGui.QRadioButton( tr( "PGN_BLACK" ) )
        self.rbNegras.setChecked( not dic_siBlancas )

        hbox = Colocacion.H().relleno(1).control(self.rbBlancas).espacio(10).control(self.rbNegras).relleno(1)
        gbColor = Controles.GB( self, tr( "JUGAMOS_CON" ), hbox ).ponFuente( flb )

        # Libros
        fvar = self.configuracion.ficheroBooks
        self.listaLibros = Books.ListaLibros()
        self.listaLibros.recuperaVar(fvar)

        ## Comprobamos que todos estén accesibles
        self.listaLibros.comprueba()
        li = [ (x.nombre, x) for x in self.listaLibros.lista ]
        libInicial = None
        if dic_nomLibro :
            for nom, libro in li :
                if nom == dic_nomLibro :
                    libInicial = libro
                    break
        if libInicial is None :
            libInicial = li[0][1] if li else None
        self.cb = QTUtil2.comboBoxLB( li, libInicial )

        btNuevo = Controles.PB( self, "", self.nuevo, plano = False ).ponIcono( Iconos.TB_Nuevo(), tamIcon = 16 )
        btBorrar = Controles.PB( self, "", self.borrar, plano = False ).ponIcono( Iconos.TB_Borrar(), tamIcon = 16 )

        hbox = Colocacion.H().relleno(1).control(self.cb).control(btNuevo).control(btBorrar).relleno(1)
        gbLibro = Controles.GB( self, tr( "LIBRO" ), hbox ).ponFuente( flb )

        # Respuesta rival
        li = (
                (tr("LIBROS_RR_USUARIO"), "su" ),
                (tr("LIBROS_RR_ALEATORIO"), "au" ),
                (tr("LIBROS_RR_PROPORCIONAL"), "ap" ),
                (tr("LIBROS_RR_MAYOR"), "mp" ),
                )
        self.cbRR = QTUtil2.comboBoxLB( li, dic_RR )
        hbox = Colocacion.H().relleno(1).control(self.cbRR).relleno(1)
        gbRR = Controles.GB( self, tr("LIBROS_RR" ), hbox ).ponFuente( flb )

        # Respuesta jugador
        self.chRJ = Controles.CHB( tr( "LIBROS_RR_MAYOR" ), dic_RJ )
        hbox = Colocacion.H().relleno(1).control(self.chRJ).relleno(1)
        gbRJ = Controles.GB( self, tr("LIBROS_RJ" ), hbox ).ponFuente( flb )

        vlayout = Colocacion.V()
        vlayout.control(gbColor).espacio(5)
        vlayout.control( gbLibro ).espacio(5)
        vlayout.control( gbRR ).espacio(5)
        vlayout.control( gbRJ )
        vlayout.margen( 20 )

        layout = Colocacion.V().control( tb ).otro( vlayout ).margen( 3 )

        self.setLayout( layout )

    def procesarTB( self ) :
        accion = self.sender().clave
        if accion == "aceptar" :
            self.libro = self.cb.resultado()
            self.siBlancas = self.rbBlancas.isChecked()
            self.jugContrario = self.cbRR.resultado()
            self.jugJugador = self.chRJ.valor()
            self.guardaDIC()
            if self.siCambios :
                fvar = self.configuracion.ficheroBooks
                self.listaLibros.guardaVar( fvar )
            self.accept()
        elif accion == "cancelar" :
            self.reject()

    def nuevo( self ) :
        fbin = QTUtil2.leeFichero( self, self.listaLibros.path, "bin", titulo = tr("LIBROS_POLYGLOT") )
        if fbin :
            self.listaLibros.path = os.path.dirname( fbin )
            nombre = os.path.basename(fbin)[:-4]
            b = Books.Libro("P", nombre, fbin, False )
            self.listaLibros.nuevo( b )
            self.siCambios = True
            self.rehacerCB(b)

    def borrar( self ) :
        libro = self.cb.resultado()
        if libro :
            if QTUtil2.pregunta( self, tr( "LIBROS_BORRAR", libro.nombre ) ) :
                self.listaLibros.borra( libro )
                self.siCambios = True
                self.rehacerCB(None)

    def rehacerCB( self, inicial ) :
        li = [ (x.nombre, x) for x in self.listaLibros.lista ]
        if inicial is None :
            inicial = li[0][1] if li else None
        self.cb.rehacer( li, inicial )

    def recuperaDIC( self ) :
        return Util.recuperaVar(self.configuracion.ficheroTrainBooks)

    def guardaDIC( self ) :
        dic = {}
        dic[ "SIBLANCAS" ] = self.rbBlancas.isChecked()
        libro = self.cb.resultado()
        dic[ "NOMLIBRO" ] = None if libro is None else libro.nombre
        dic[ "RR" ] = self.cbRR.resultado()
        dic[ "RJ" ] = self.chRJ.valor()
        Util.guardaVar( self.configuracion.ficheroTrainBooks, dic )

#==========================================================================================================================================
def eligeJugadaBooks( liJugadas, siBlancas ) :
    menu = Controles.LMenu()
    f = Controles.TipoLetra( nombre="Courier New", puntos=10 )
    menu.ponFuente( f )

    titulo = tr( "BLANCAS" ) if siBlancas else tr( "PGN_BLACK" )
    icono = Iconos.Carpeta()

    menu.opcion( None, titulo, icono )
    menu.separador()

    icono = Iconos.PuntoNaranja() if siBlancas else Iconos.PuntoNegro()

    for desde, hasta, coronacion, pgn, peso in liJugadas :

        menu.opcion( (desde,hasta,coronacion), pgn, icono )
        menu.separador()

    while True :
        resp = menu.lanza()
        if resp :
            return resp

#==========================================================================================================================================
def saltaJugadaBooks( gestor, liJugadas, jg ) :
    siBlancas = jg.posicionBase.siBlancas
    menu = Controles.LMenu()
    f = Controles.TipoLetra( nombre="Courier New", puntos=10 )
    menu.ponFuente( f )

    icono = Iconos.PuntoNaranja() if siBlancas else Iconos.PuntoNegro()
    iconoActual = Iconos.Mover()

    for desde, hasta, coronacion, pgn, peso in liJugadas :

        ico = iconoActual if desde == jg.desde and hasta == jg.hasta else icono
        menu.opcion( (desde,hasta,coronacion), pgn, ico )
        menu.separador()

    menu.opcion( (None, None, None), tr("LIBROS_EDITAR"), Iconos.PuntoVerde() )

    return menu.lanza()
