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

from PySide import QtCore, QtGui

from Code.Traducir import tr
import Code.Util as Util

import QTUtil, QTUtil2
import Colocacion
import Iconos
import Controles
import Columnas
import Grid
import QTVarios

import Tablero

import FormLayout

#==========================================================================================================================================
def paramAnalisis( parent, configuracion, siModoAmpliado  ) :

    fichero = configuracion.ficheroAnalisis
    dic = Util.recuperaVar( fichero )
    if dic :
        motor = dic["MOTOR"]
        tiempo = dic["TIEMPO"]
    else :
        motor = configuracion.tutor.clave
        tiempo = configuracion.tiempoTutor

    # Datos
    liGen = [(None,None)]

    ## Tutor
    li = configuracion.ayudaCambioTutor()
    li[0] = motor
    liGen.append( ( tr( "MOTOR" ) + " :", li ) )

    ## Décimas de segundo a pensar el tutor
    liGen.append( ( tr( "SEGUNDOS_ANALISIS" ) + " :", tiempo/1000.0 ) )

    ## Si borramos análisis previo
    if siModoAmpliado :
        liJ = [ (tr( "PGN_WHITE" ),"BLANCAS"), (tr( "PGN_BLACK" ),"NEGRAS"), (tr( "BLANCAS_Y_NEGRAS" ), "AMBOS")  ]
        config = FormLayout.Combobox( tr( "ANALIZAR_COLOR" ), liJ )
        liGen.append( ( config, "AMBOS" ) )

        config = FormLayout.Editbox( tr( "JUGADAS" ), rx = "[0-9,\-,\,]*" )
        liGen.append( (config, "" ) )
        liGen.append( ( tr( "REHACERPREVIOS_ANALISIS" ) + " :", False ) )

    # Editamos
    resultado = FormLayout.fedit( liGen, title= tr( "CONFIG_ANALISIS" ), parent = parent, anchoMinimo = 460, icon = Iconos.TB_Opciones(), siDefecto = False )

    if resultado :
        accion, liResp = resultado

        motor = liResp[0]
        tiempo = int(liResp[1]*1000)

        dic = { "MOTOR":motor, "TIEMPO":tiempo }
        Util.guardaVar( fichero, dic )

        if siModoAmpliado :
            color = liResp[2]
            blancas = color != "NEGRAS"
            negras = color != "BLANCAS"
            jugadas = liResp[3]
            siBorrarPrevio = liResp[4]
            return motor, tiempo, blancas, negras, jugadas, siBorrarPrevio
        else :
            return motor, tiempo
    else :
        return None

class LB_PGN( Controles.LB ) :
    def mousePressEvent( self, event ) :
        li = self.pgn.split(" ")
        n = li[0].find( "." )
        if n <= 0 :
            return
        j1 = int(li[0][:n])
        siNegras = li[0].endswith( "..." )
        if siNegras :
            del li[0]

        menu = Controles.LMenu()
        f = Controles.TipoLetra( nombre="Courier New", puntos=10 )
        menu.ponFuente( f )
        dic = { False : Iconos.PuntoNaranja(), True : Iconos.PuntoNegro() }

        for n, x in enumerate(li) :
            icono = dic[siNegras]
            while x[0] in "0123456789." :
                x = x[1:]

            puntos = ".... " if siNegras else "."

            titulo = "%2d%s%s"%(j1,puntos,x)
            menu.opcion( n, titulo, icono )
            siNegras = not siNegras
            if not siNegras :
                j1 += 1

        resp = menu.lanza()
        if resp is not None :
            self.rutina(resp)

    def ponRutina( self, rutina ) :
        self.rutina = rutina

    def ponTexto( self, texto ) :
        Controles.LB.ponTexto( self, texto )
        self.pgn = texto
        self.setToolTip(texto)

#==========================================================================================================================================
class WMuestra(QtGui.QWidget):

    #--------------------------------------------------------------------------------------------------------------------------------
    def __init__(self, um, parent, confTablero, siBlancas, siLibre, numero, listaRM, posUsuario, siGrabar ) :
        super(WMuestra, self).__init__(parent)

        self.um = um
        self.parent = parent

        self.colorNegativo = QTUtil.qtColorRGB( 255, 0, 0 )
        self.colorImpares = QTUtil.qtColorRGB( 231, 244, 254 )

        f = Controles.TipoLetra( puntos=12, peso = 75 )
        fpgn = Controles.TipoLetra( peso = 75 )

        self.lbPuntuacion = Controles.LB( ).alinCentrado().ponFuente( f )

        self.tablero = Tablero.Tablero(self, confTablero)
        self.tablero.crea()
        self.tablero.ponerPiezasAbajo( siBlancas )

        self.lbMotor = Controles.LB( ).alinCentrado()
        self.lbTiempo = Controles.LB( ).alinCentrado()

        self.numero = int(numero[:-1])

        lytb,self.tb = QTVarios.lyBotonesMovimiento( self.parent, str(numero), siLibre = siLibre, siMas = True, siGrabar=siGrabar, siGrabarTodos=siGrabar )

        self.listaRM = listaRM

        oColumnas = Columnas.ListaColumnas()
        oColumnas.nueva( "JUGADAS", "%d %s"%(len(self.listaRM),tr( "JUGADAS" )), 120, siCentrado = True )
        self.wrm = Grid.Grid( self, oColumnas, siLineas = False)
        nAncho = self.wrm.anchoColumnas() + 20
        self.wrm.setFixedWidth( nAncho )
        self.wrm.goto(self.um.posElegida,0)

        self.lbPGN = LB_PGN( ).ponFuente( fpgn ).anchoFijo( nAncho + self.tablero.ancho )#.ponWrap()
        self.lbPGN.ponRutina( self.saltaPGN )

        lyTabl = Colocacion.H().relleno(1).control(self.tablero).relleno(1)

        lyV0 = Colocacion.V()
        lyV0.control(self.lbPuntuacion)
        lyV0.otro(lyTabl)
        lyV0.otro(lytb)
        lyV0.control(self.lbMotor)
        lyV0.control(self.lbTiempo)

        lyH0 = Colocacion.H().otro(lyV0).control(self.wrm)

        # Layout
        layout = Colocacion.V().otro(lyH0).control(self.lbPGN)

        self.setLayout( layout )

        self.wrm.setFocus()

    #-----------------------------------------------------------------------------------------------------------------------------
    def saltaPGN( self, jugada ) :

        self.parent.oBase.saltaPGN( self.numero, jugada )

    #-----------------------------------------------------------------------------------------------------------------------------
    def ponDatosRM( self, puntuacion, nomMotor, etiT, pgn ) :
        self.lbPuntuacion.ponTexto( puntuacion )
        self.lbMotor.ponTexto( nomMotor )
        self.lbTiempo.ponTexto( etiT )
        self.lbPGN.ponTexto( pgn )

    #--------------------------------------------------------------------------------------------------------------------------------
    def gridNumDatos( self, grid ) :
        return len(self.listaRM)
    #--------------------------------------------------------------------------------------------------------------------------------
    def gridBotonIzquierdo( self, grid, fila, columna ) :
        self.um.cambiadoRM( fila )
        self.wrm.setFocus()
    #--------------------------------------------------------------------------------------------------------------------------------
    def gridCambiadoRegistro( self, grid, fila, columna ) :
        self.um.cambiadoRM( fila )
        self.wrm.setFocus()
    #--------------------------------------------------------------------------------------------------------------------------------
    def gridBotonDerecho( self, grid, fila, columna, modificadores ) :
        self.um.cambiadoRM( fila )
    #--------------------------------------------------------------------------------------------------------------------------------
    def gridBold( self, grid, fila, columna ) :
        return self.listaRM[fila][3]
    #--------------------------------------------------------------------------------------------------------------------------------
    def gridDato( self, grid, fila, oColumna ) :
        return self.listaRM[fila][1]
    #--------------------------------------------------------------------------------------------------------------------------------
    def gridColorTexto( self, grid, fila, oColumna ) :
        rm = self.listaRM[fila][0]
        return None if rm.puntosABS() >= 0 else self.colorNegativo
    #--------------------------------------------------------------------------------------------------------------------------------
    def gridColorFondo( self, grid, fila, oColumna ) :
        if fila%2 == 1 :
            return self.colorImpares
        else :
            return None

#==========================================================================================================================================
class WAnalisis(QTVarios.WDialogo):

    def __init__(self, oBase, ventana, confTablero, siBlancas, siLibre, siGrabar ) :

        titulo = tr( "ANALISIS" )
        icono = Iconos.Tutor()
        extparam = "analysis"
        QTVarios.WDialogo.__init__(self, ventana, titulo, icono, extparam )

        self.oBase = oBase

        # Variables comunes a todos los tableros
        self.confTablero = confTablero
        self.siBlancas = siBlancas
        self.siLibre = siLibre
        self.siGrabar = siGrabar

        # Layout
        self.ly = Colocacion.G().margen(10)

        self.setLayout( self.ly )

        self.recuperarVideo(siTam=False)

        self.setSizePolicy( QtGui.QSizePolicy.Maximum, QtGui.QSizePolicy.Maximum )

    #-----------------------------------------------------------------------------------------------------------------------------
    def creaMuestra( self, um, fila, columna, numero, listaRM, posUsuario ) :
        wm = WMuestra( um, self, self.confTablero, self.siBlancas, self.siLibre, numero, listaRM, posUsuario, self.siGrabar )
        self.ly.controlc( wm, fila, columna )
        self.setLayout( self.ly )
        wm.show()
        return wm

    #-----------------------------------------------------------------------------------------------------------------------------
    def procesarTB( self ) :
        self.oBase.procesarTB( self.sender().clave )

    #-----------------------------------------------------------------------------------------------------------------------------
    def iniciaReloj( self, funcion ) :
        if not hasattr( self, "timer" ) :
            self.timer = QtCore.QTimer(self)
            self.connect(self.timer, QtCore.SIGNAL("timeout()"), funcion )
        self.timer.start(1000)

    #-----------------------------------------------------------------------------------------------------------------------------
    def paraReloj( self ) :
        if hasattr( self, "timer" )  :
            self.timer.stop()
            delattr( self, "timer" )

#==========================================================================================================================================
class WAnalisisVariantes(QtGui.QDialog):
    def __init__(self, oBase, ventana, segundosPensando, confTablero, siBlancas, cPuntos, maxRecursion ) :
        super(WAnalisisVariantes, self).__init__(ventana)

        self.oBase = oBase

        # Creamos los controles
        self.setWindowTitle( tr( "VARIACIONES" ) )

        self.setWindowFlags( QtCore.Qt.Dialog | QtCore.Qt.WindowMinimizeButtonHint)
        self.setWindowIcon( Iconos.Tutor() )

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

        lbPuntuacionAnterior = Controles.LB( cPuntos ).alinCentrado().ponFuente( flb )
        self.lbPuntuacionNueva = Controles.LB( ).alinCentrado().ponFuente( flb )

        self.tablero = Tablero.Tablero(self, confTablero)
        self.tablero.crea()
        self.tablero.ponerPiezasAbajo( siBlancas )

        self.tableroT = Tablero.Tablero(self, confTablero)
        self.tableroT.crea()
        self.tableroT.ponerPiezasAbajo( siBlancas )

        btTerminar = Controles.PB( self, tr( "TB_TERMINAR" ), self.close ).ponPlano( False )
        btReset = Controles.PB( self, tr( "OTRO_CAMBIO" ), oBase.reset ).ponIcono( Iconos.MoverLibre() ).ponPlano( False )
        lytbTutor,self.tb = QTVarios.lyBotonesMovimiento( self, "", siLibre = maxRecursion > 0 )
        self.maxRecursion = maxRecursion-1

        self.segundos, lbSegundos = QTUtil2.spinBoxLB( segundosPensando, 1, 999, maxTam=40, etiqueta = tr( "SEGUNDOS" ) )

        # Creamos los layouts

        lyVariacion = Colocacion.V().control(lbPuntuacionAnterior).control(self.tablero)
        gbVariacion = Controles.GB( self, tr( "PROPUESTA_CAMBIO" ), lyVariacion ).ponFuente( f ).alinCentrado()

        lyTutor = Colocacion.V().control(self.lbPuntuacionNueva).control(self.tableroT)
        gbTutor = Controles.GB( self, tr( "PREVISION_TUTOR" ), lyTutor ).ponFuente( f ).alinCentrado()

        lyBT = Colocacion.H().control( btTerminar ).control( btReset ).relleno(1).control( lbSegundos ).control( self.segundos )

        layout = Colocacion.G().control( gbVariacion, 0, 0 ).control( gbTutor, 0, 1 )
        layout.otro( lyBT, 1, 0 ).otro( lytbTutor, 1, 1 )

        self.setLayout( layout )

        self.move( ventana.x()+20, ventana.y()+20 )

    def dameSegundos( self ) :
        return int(self.segundos.value())

    def ponPuntuacion( self, pts ) :
        self.lbPuntuacionNueva.ponTexto( pts )

    def procesarTB( self ) :
        self.oBase.procesarTB( self.sender().clave, self.maxRecursion )

    def iniciaReloj( self, funcion ) :
        if not hasattr( self, "timer" ) :
            self.timer = QtCore.QTimer(self)
            self.connect(self.timer, QtCore.SIGNAL("timeout()"), funcion )
        self.timer.start(1000)

    def paraReloj( self ) :
        if hasattr( self, "timer" )  :
            self.timer.stop()
            delattr( self, "timer" )

