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

from PySide import QtCore, QtGui

from Code.Traducir import tr

import Code.Util as Util
import Code.VarGen as VarGen

import Colocacion
import Iconos

import Controles
import QTUtil, QTUtil2

import Grid
import Columnas

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

    def __init__( self, pantalla, titulo, icono, extparam ) :

        super(WDialogo, self).__init__(pantalla)

        self.setWindowTitle( titulo )
        self.setWindowIcon( icono )
        flags = QtCore.Qt.Dialog | QtCore.Qt.WindowTitleHint | QtCore.Qt.WindowMinimizeButtonHint | QtCore.Qt.WindowMaximizeButtonHint
        self.setWindowFlags( flags )

        self.ficheroVideo = VarGen.plantillaVideo%extparam
        self.liGrids = []

    #--------------------------------------------------------------------------------------------------------------------------------
    def closeEvent(self, event):
        self.guardarVideo()

    #--------------------------------------------------------------------------
    def registraGrid(self, grid):
        self.liGrids.append(grid)

    #--------------------------------------------------------------------------
    def guardarVideo(self):

        dic = {}

        pos = self.pos()
        dic["_POSICION_"] = "%d,%d"%(pos.x(),pos.y())

        tam = self.size()
        dic["_TAMAÑO_"] = "%d,%d"%(tam.width(),tam.height())

        for grid in self.liGrids :
            grid.guardarVideo( dic )
        Util.guardaDIC( dic, self.ficheroVideo )

        # li = dic.keys()
        # li.sort()
        # for k in li :
            # prlk( k, dic[k] )

    #--------------------------------------------------------------------------
    def recuperarVideo(self, siTam=True) :

        if Util.tamFichero( self.ficheroVideo ) > 0 :
            dic = Util.recuperaDIC( self.ficheroVideo )
            if dic :
                wE, hE = QTUtil.tamEscritorio()
                x,y = dic["_POSICION_"].split(",")
                x = int(x)
                y = int(y)
                if not( 0 <= x <= (wE-50) ) :
                    x = 0
                if not( 0 <= y <= (hE-50) ) :
                    y = 0
                self.move( x, y )
                if siTam :
                    w, h = dic["_TAMAÑO_"].split(",")
                    w = int(w)
                    h = int(h)
                    if w > wE :
                        w = wE
                    elif w < 20 :
                        w = 20
                    if h > hE :
                        h = hE
                    elif h < 20 :
                        h = 20
                    self.resize( w, h )
                for grid in self.liGrids :
                    grid.recuperarVideo( dic )
                    grid.ponAnchosColumnas()
                return True
        return False

# ------------------------------------------------------------------------------------------------------------
class BlancasNegras(QtGui.QDialog):

    def __init__(self, parent ):
        super( BlancasNegras, self ).__init__(parent)
        self.setWindowFlags( QtCore.Qt.Dialog | QtCore.Qt.WindowTitleHint )

        self.setWindowTitle( tr( "ELIGE_COLOR" ))
        self.setWindowIcon( Iconos.P_16c() )

        btBlancas = Controles.PB( self, "", rutina = self.accept, plano = False ).ponIcono( Iconos.P_64c(), tamIcon = 64 )
        btNegras = Controles.PB( self, "", rutina = self.negras, plano = False ).ponIcono( Iconos.p_64c(), tamIcon = 64 )

        self.resultado = True

        ly = Colocacion.H().control( btBlancas ).control( btNegras )
        ly.margen( 10 )
        self.setLayout(ly)

    def negras( self ) :
        self.resultado = False
        self.accept()

def blancasNegras( owner ) :
    w = BlancasNegras( owner )
    if w.exec_() :
        return w.resultado
    return None
# ------------------------------------------------------------------------------------------------------------

# ------------------------------------------------------------------------------------------------------------
class Tiempo(QtGui.QDialog):

    def __init__(self, parent ):
        super( Tiempo, self ).__init__(parent)
        self.setWindowFlags( QtCore.Qt.Dialog | QtCore.Qt.WindowTitleHint )

        self.setWindowTitle( tr( "ETI_TIEMPO" ) )
        self.setWindowIcon( Iconos.MoverTiempo() )

        tb = QTUtil2.creaTBAceptarCancelar( self )

        # Tiempo
        self.edMinutos, self.lbMinutos = QTUtil2.spinBoxLB( 10, 0, 99, maxTam=50, etiqueta=tr( "TIEMPO_MINUTOS_TOTAL" ) )
        self.edSegundos, self.lbSegundos = QTUtil2.spinBoxLB( 0, 0, 99, maxTam=50, etiqueta=tr( "TIEMPO_SEGUNDOS_JUGADA" ) )

        ## Tiempo
        lyT = Colocacion.G()
        lyT.controld( self.lbMinutos, 0, 0 ).control( self.edMinutos, 0, 1 )
        lyT.controld( self.lbSegundos, 1, 0 ).control( self.edSegundos, 1, 1 ).margen(20)

        ly = Colocacion.V().control( tb ).espacio(20).otro( lyT )
        self.setLayout(ly)

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

    #--------------------------------------------------------------------------------------------------------------------------------
    def resultado( self ):
        minutos = self.edMinutos.value()
        segundos = self.edSegundos.value()

        return minutos, segundos

def tiempo( owner ) :
    w = Tiempo( owner )
    if w.exec_() :
        return w.resultado()
    return None
# ------------------------------------------------------------------------------------------------------------

#==========================================================================================================================================
class WEligeMotorElo( WDialogo ):
    # Desafios - porque no : habrá una oportunidad de haciendo trampas se llega a ganar a stockfish por ejemplo.
    # Sin embargo si se quiere participar en el elo y llegar alto, habrá que hacer muchas veces trampas para llegar al mismo resultado
    # Quien tenga interés en el elo, no tendrá problema en perder algo de tiempo.

    def __init__( self, gestor, elo ) :

        titulo = "%s (%d)"%(tr("ELO_ROTULO"), elo)
        icono = Iconos.Elo()
        super(WEligeMotorElo, self).__init__(gestor.pantalla, titulo, icono, "elo" )

        self.gestor = gestor
        self.liMotores = self.gestor.listaMotores(elo)

        self.colorNoJugable = QTUtil.qtColorRGB( 241, 226, 226 )
        self.colorMenor = QTUtil.qtColorRGB( 245, 245, 245 )
        self.colorMayor = None
        self.elo = elo

        # Toolbar
        liAcciones = [  ( tr( "TB_PGNELEGIR" ), Iconos.TB_Aceptar(), "elegir" ), None,
                        ( tr( "CANCELAR" ), Iconos.TB_Cancelar(), "cancelar" ), None,
                    ]

        tb = Controles.TB( self, liAcciones )

        # Lista
        oColumnas = Columnas.ListaColumnas()
        oColumnas.nueva( "NUMERO", tr( "AB_NUM" ), 35, siCentrado = True )
        oColumnas.nueva( "MOTOR", tr( "MOTOR" ), 200 )
        oColumnas.nueva( "GANA", tr("ELO_ABREVGANA"), 80, siCentrado = True )
        oColumnas.nueva( "TABLAS", tr("TABLAS"), 80, siCentrado = True )
        oColumnas.nueva( "PIERDE", tr("ELO_ABREVPIERDE"), 80, siCentrado = True )

        self.grid = Grid.Grid( self, oColumnas, siSelecFilas = True, siCabeceraMovible = False, altoFila=24 )
        self.registraGrid( self.grid )

        f = Controles.TipoLetra( puntos=9, peso=75 )
        self.grid.setFont( f )

        self.grid.gotop()
        # nAncho =
        # self.grid.setMinimumWidth( nAncho )
        # self.grid.setMaximumWidth( nAncho )

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

        if not self.recuperarVideo() :
            self.resize( self.grid.anchoColumnas() + 24, 430 )

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

    #--------------------------------------------------------------------------------------------------------------------------------
    def elegir( self ) :
        f = self.grid.recno()
        mt = self.liMotores[f]
        if mt.siJugable :
            self.resultado = mt
            self.guardarVideo()
            self.accept()
        else :
            QTUtil.beep()

    #--------------------------------------------------------------------------------------------------------------------------------
    def gridDobleClick( self, grid, fila, oColumna ) :
        self.elegir()

    #--------------------------------------------------------------------------------------------------------------------------------
    def gridNumDatos( self, grid ) :
        return len(self.liMotores)

    #--------------------------------------------------------------------------------------------------------------------------------
    def gridWheelEvent( self, quien, siAdelante ) :
        n = len(self.liMotores)
        f, c = self.grid.posActualN()
        f += -1 if siAdelante else +1
        if f < n and f >= 0 :
            self.grid.goto( f, c )
    #--------------------------------------------------------------------------------------------------------------------------------
    def gridColorFondo( self, grid, fila, oColumna ) :
        mt = self.liMotores[fila]
        if mt.siJugable :
            return self.colorMenor if mt.elo < self.elo else self.colorMayor
        else :
            return self.colorNoJugable
    #--------------------------------------------------------------------------------------------------------------------------------
    def gridDato( self, grid, fila, oColumna ) :
        mt = self.liMotores[fila]
        clave = oColumna.clave
        if clave == "NUMERO" :
            valor = "%2d"%mt.numero
        elif clave == "MOTOR" :
            valor = "  " + mt.rotulo()
        else :
            if not mt.siJugable :
                return "x"
            if clave == "GANA" :
                pts = mt.pgana
            elif clave == "TABLAS" :
                pts = mt.ptablas
            elif clave == "PIERDE" :
                pts = mt.ppierde

            valor = "%d"%pts
            if pts > 0 :
                valor = "+" + valor

        return valor

def eligeMotorElo( gestor, elo ) :
    w = WEligeMotorElo( gestor, elo )
    if w.exec_() :
        return w.resultado
    else :
        return None

#==========================================================================================================================================
def lyBotonesMovimiento( owner, clave, siLibre = True, siMas = False, siGrabar = False, siGrabarTodos = False, rutina = None, tamIcon=16 ) :

    liAcciones = []
    def x( tit ) :
        liAcciones.append( ( tr(tit), eval("Iconos.%s()"%tit), clave + tit ) )

    liAcciones.append( None )
    x( "MoverInicio" )
    liAcciones.append( None )
    x( "MoverAtras" )
    liAcciones.append( None )
    x( "MoverAdelante" )
    liAcciones.append( None )
    x( "MoverFinal" )
    liAcciones.append( None )
    if siLibre :
        x( "MoverLibre" )
        liAcciones.append( None )
    x( "MoverTiempo" )
    liAcciones.append( None )
    if siGrabar :
        x( "MoverGrabar" )
        liAcciones.append( None )
    if siGrabarTodos :
        liAcciones.append( ( tr("MoverGrabar")+"++", Iconos.MoverGrabarTodos(), clave + "MoverGrabarTodos" ) )
        liAcciones.append( None )
    if siMas :
        x( "MoverMas" )

    tb = Controles.TB( owner, liAcciones, False, tamIcon = tamIcon, rutina = rutina )
    ly = Colocacion.H().relleno(1).control(tb).relleno(1)
    return ly, tb

#==========================================================================================================================================
class Numero(QtGui.QLabel):
    def __init__(self ):
        QtGui.QLabel.__init__(self)
        self.setStyleSheet("* { border: 1px solid black; border-radius:3px; }")

    def pon(self, numero):
        unidades = numero%10
        self.setPixmap( eval( "Iconos.pmN%d()"%unidades ) )

