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

#==========================================================================================================================================
import copy

from PySide import QtCore, QtGui

from Code.Traducir import tr
import Code.Configuracion as Configuracion
import Code.ControlPosicion as ControlPosicion
import Code.Tutoriales as Tutoriales

import QTUtil, QTUtil2
import TabTipos
import Colocacion
import Iconos
import Controles
import Columnas
import Grid
import Tablero

import FormLayout

#==========================================================================================================================================
def tiposDestino() :
    li = (
            ( tr( "TUT_ALCENTRO"), "c" ),
            ( tr( "TUT_MINIMO"), "m" ),
        )
    return li

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

    def __init__( self, owner, numFlecha, liFlechas, tamTablero, confTablero = None, siControlNombre = True ) :

        QtGui.QDialog.__init__(self,owner)

        self.setWindowTitle( tr("TUT_FLECHA") )
        self.setWindowFlags( QtCore.Qt.Dialog | QtCore.Qt.WindowTitleHint )

        self.siControlNombre = siControlNombre

        self.numFlecha = numFlecha
        self.liPFlechas = liFlechas
        if numFlecha >= 0 :
            regFlecha = liFlechas[numFlecha]
        else :
            regFlecha = Tutoriales.PFlecha()

        liAcciones = [  ( tr( "ME_GRABAR" ), Iconos.TB_Aceptar(), "grabar" ), None,
                        ( tr( "CANCELAR" ), Iconos.TB_Cancelar(), "reject" ), None,
                    ]
        tb = Controles.TB( self, liAcciones )

        # Tablero
        confTablero = Configuracion.ConfigTablero()
        confTablero.lee( owner.configuracion.cTableroN.graba() if confTablero is None else confTablero.graba() )
        confTablero.anchoPieza = tamTablero
        posicion = ControlPosicion.ControlPosicion()
        posicion.leeFen( "r1bqk2r/pp2bp1p/2p2np1/4Q3/2B1P3/2N5/PPP2PPP/R1B1K2R w KQkq - 1 10" )
        self.tablero = Tablero.TutTablero(self, confTablero)
        self.tablero.crea()
        self.tablero.ponPosicion( posicion )

        # Datos generales
        liGen = []

        if self.siControlNombre :
            # nombre de la flecha que se usará en los menús del tutorial
            config = FormLayout.Editbox( tr( "TIT_NOMBRE" ), ancho=80 )
            liGen.append( (config, regFlecha.nombre ) )

        # ( "forma", "t", "a" ), # a = abierta -> , c = cerrada la cabeza, p = poligono cuadrado,
        liFormas = (
                        ( tr( "TUT_FORMA_ABIERTA"), "a"),
                        ( tr( "TUT_FORMA_CERRADA"), "c"),
                        ( tr( "TUT_FORMA_POLIGONO1"), "1"),
                        ( tr( "TUT_FORMA_POLIGONO2"), "2"),
                        ( tr( "TUT_FORMA_POLIGONO3"), "3"),
                    )
        config = FormLayout.Combobox( tr( "TUT_FORMA" ), liFormas )
        liGen.append( ( config, regFlecha.forma ) )

        # ( "tipo", "n", Qt.SolidLine ), #1=SolidLine, 2=DashLine, 3=DotLine, 4=DashDotLine, 5=DashDotDotLine
        config = FormLayout.Combobox( tr( "TUT_TIPOTRAZO" ), QTUtil2.tiposDeLineas() )
        liGen.append( ( config, regFlecha.tipo ) )

        # liGen.append( (None,None) )

        # ( "color", "n", 0 ),
        config = FormLayout.Colorbox( tr( "TUT_COLORTRAZO" ), 80, 20 )
        liGen.append( ( config, regFlecha.color ) )

        # ( "colorinterior", "n", -1 ), # si es cerrada
        config = FormLayout.Colorbox( tr( "TUT_COLORINTERIOR" ), 80, 20, siChecked=True )
        liGen.append( ( config, regFlecha.colorinterior ) )

        # ( "colorinterior2", "n", -1 ), # para el gradiente
        # config = FormLayout.Colorbox( tr( "TUT_COLORINTERIOR2" ), 80, 20, siChecked=True )
        # liGen.append( ( config, regFlecha.colorinterior2 ) )

        # ( "opacidad", "n", 1.0 ),
        config = FormLayout.Dial( tr( "TUT_TRASPARENCIA" ), 0, 99 )
        liGen.append( ( config, 100-int(regFlecha.opacidad*100) ) )

        # liGen.append( (None,None) )

        # ( "redondeos", "l", False ),
        liGen.append( ( tr("TUT_REDONDEOS"), regFlecha.redondeos ) )

        # ( "grosor", "n", 1 ), # ancho del trazo
        config = FormLayout.Spinbox( tr( "TUT_GROSORTRAZO" ), 1, 20, 50 )
        liGen.append( ( config, regFlecha.grosor ) )

        # liGen.append( (None,None) )

        # ( "altocabeza", "n", 1 ), # altura de la cabeza
        config = FormLayout.Spinbox( tr( "TUT_ALTOCABEZA" ), 0, 100, 50 )
        liGen.append( ( config, regFlecha.altocabeza ) )

        # ( "ancho", "n", 10 ), # ancho de la base de la flecha si es un poligono
        config = FormLayout.Spinbox( tr( "TUT_ANCHOBASE" ), 1, 100, 50 )
        liGen.append( ( config, regFlecha.ancho ) )

        # ( "vuelo", "n", 5 ), # vuelo de la flecha respecto al ancho de la base
        config = FormLayout.Spinbox( tr( "TUT_VUELO" ), 1, 100, 50 )
        liGen.append( ( config, regFlecha.vuelo ) )

        # ( "descuelgue", "n", 2 ), # vuelo hacia arriba
        config = FormLayout.Spinbox( tr( "TUT_DESCUELGUE" ), -100, 100, 50 )
        liGen.append( ( config, regFlecha.descuelgue ) )

        # liGen.append( (None,None) )

        # ( "destino", "t", "c" ), # c = centro, m = minimo
        config = FormLayout.Combobox( tr( "TUT_DESTINO" ), tiposDestino() )
        liGen.append( ( config, regFlecha.destino ) )

        # liGen.append( (None,None) )

        # orden
        config = FormLayout.Combobox( tr( "TUT_ORDEN" ), QTUtil2.listaOrdenes() )
        liGen.append( ( config, regFlecha.posicion.orden ) )

        self.form = FormLayout.FormWidget( liGen, dispatch = self.cambios )

        # Layout
        layout = Colocacion.H().control(self.form).relleno(1).control(self.tablero )
        layout1 = Colocacion.V().control(tb).otro(layout)
        self.setLayout( layout1 )

        # Ejemplos
        liMovs = [ "d2d6", "a8h8", "h5b7" ]
        self.liEjemplos = []
        for a1h8 in liMovs :
            regFlecha.a1h8 = a1h8
            regFlecha.siMovible = True
            flecha = self.tablero.creaFlecha( regFlecha )
            self.liEjemplos.append(flecha)

    #--------------------------------------------------------------------------------------------------------------------------------
    def procesarTB( self ) :
        accion = self.sender().clave
        eval( "self.%s()"%accion )

    #--------------------------------------------------------------------------------------------------------------------------------
    def cambios( self ) :
        if hasattr( self, "form" ) :
            li = self.form.get()
            n = 1 if self.siControlNombre else 0
            for flecha in self.liEjemplos :
                regFlecha = flecha.bloqueDatos
                if self.siControlNombre :
                    regFlecha.nombre = li[0]
                regFlecha.forma = li[n]
                regFlecha.tipo = li[n+1]
                regFlecha.color = li[n+2]
                regFlecha.colorinterior = li[n+3]
                # regFlecha.colorinterior2 = li[4]
                regFlecha.opacidad = (100.0-float(li[n+4]))/100.0
                regFlecha.redondeos = li[n+5]
                regFlecha.grosor = li[n+6]
                regFlecha.altocabeza = li[n+7]
                regFlecha.ancho = li[n+8]
                regFlecha.vuelo = li[n+9]
                regFlecha.descuelgue = li[n+10]
                regFlecha.destino = li[n+11]
                regFlecha.posicion.orden = li[n+12]
                flecha.posicion2xy() # posible cambio en destino
                flecha.setOpacity( regFlecha.opacidad )
                flecha.setZValue( regFlecha.posicion.orden )
            self.tablero.escena.update()
            QTUtil.refreshGUI()

    #--------------------------------------------------------------------------------------------------------------------------------
    def grabar( self ) :
        regFlecha = self.liEjemplos[0].bloqueDatos
        if self.siControlNombre :
            nombre = regFlecha.nombre.strip()
            if nombre == "" :
                QTUtil2.mensError( self, tr("TUT_FM_FALTANOMBRE"))
                return

            for nf, rf in enumerate(self.liPFlechas) :
                if nf != self.numFlecha :
                    if rf.nombre.lower() == nombre.lower() :
                        QTUtil2.mensError( self, tr("TUT_FM_NOMBREREPETIDO"))
                        return

        self.regFlecha = regFlecha
        self.accept()

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

    def __init__( self, wowner, owner, funcTamTablero ) :

        QtGui.QWidget.__init__(self,wowner)

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

        self.funcTamTablero = funcTamTablero

        self.tutorial = owner.tutorial
        self.configuracion = owner.procesador.configuracion
        self.liPFlechas = self.tutorial.liPFlechas

        # Lista
        oColumnas = Columnas.ListaColumnas()
        oColumnas.nueva( "NUMERO", tr( "AB_NUM" ), 60, siCentrado=True )
        oColumnas.nueva( "NOMBRE", tr( "TIT_NOMBRE" ), 256 )

        self.grid = Grid.Grid( self, oColumnas, id = "F", siSelecFilas=True )

        liAcciones = [  ( tr( "NUEVO" ), Iconos.TB_Nuevo(), "mas" ), None,
                        ( tr( "BORRAR" ), Iconos.TB_Borrar(), "borrar" ), None,
                        ( tr( "MODIFICAR" ), Iconos.TB_Modificar(), "modificar" ), None,
                        ( tr( "COPIAR" ), Iconos.TB_Copiar(), "copiar" ), None,
                        ( tr( "ARRIBA" ), Iconos.TB_Arriba(), "arriba" ), None,
                        ( tr( "ABAJO" ), Iconos.TB_Abajo(), "abajo" ), None,
                    ]
        tb = Controles.TB( self, liAcciones )
        tb.setFont( flb )

        ly = Colocacion.V().control(tb).control(self.grid)
        gb = Controles.GB(self,tr("TUT_FLECHAS"),ly ).ponFuente( f )

        # Tablero
        confTablero = Configuracion.ConfigTablero()
        confTablero.lee( self.configuracion.cTableroN.graba() )
        confTablero.anchoPieza = 32
        posicion = ControlPosicion.ControlPosicion()
        posicion.leeFen( "r1bqk2r/pp2bp1p/2p2np1/4Q3/2B1P3/2N5/PPP2PPP/R1B1K2R w KQkq - 1 10" )
        self.tablero = Tablero.TutTablero(self, confTablero)
        self.tablero.crea()
        self.tablero.ponPosicion( posicion )

        # Layout
        layout = Colocacion.H().control(gb).relleno(1).control(self.tablero )
        self.setLayout( layout )

        # Ejemplos
        liMovs = [ "d2d6", "a8h8", "h5b7" ]
        self.liEjemplos = []
        regFlecha = TabTipos.Flecha()
        for a1h8 in liMovs :
            regFlecha.a1h8 = a1h8
            regFlecha.siMovible = True
            flecha = self.tablero.creaFlecha( regFlecha )
            self.liEjemplos.append(flecha)

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

    #--------------------------------------------------------------------------------------------------------------------------------
    def gridDato( self, grid, fila, oColumna ) :
        clave = oColumna.clave
        if clave == "NUMERO" :
            return str(fila+1)
        elif clave == "NOMBRE" :
            return self.liPFlechas[fila].nombre

        return len(self.liPFlechas)

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

    #--------------------------------------------------------------------------------------------------------------------------------
    def gridCambiadoRegistro( self, grid, fila, oColumna ) :
        if fila >= 0 :
            regFlecha = self.liPFlechas[fila]
            for ejemplo in self.liEjemplos :
                a1h8 = ejemplo.bloqueDatos.a1h8
                bd = copy.deepcopy( regFlecha )
                bd.a1h8 = a1h8
                bd.anchoCasilla = self.tablero.anchoCasilla
                ejemplo.bloqueDatos = bd
                ejemplo.reset()
            self.tablero.escena.update()

    #--------------------------------------------------------------------------------------------------------------------------------
    def procesarTB( self ) :
        accion = self.sender().clave
        eval( "self.%s()"%accion )

    #--------------------------------------------------------------------------------------------------------------------------------
    def mas( self ) :
        w = WET_Flecha(self, -1, self.liPFlechas, self.funcTamTablero())
        if w.exec_() :
            regFlecha = w.regFlecha
            regFlecha.id = self.tutorial.idNuevo()
            self.liPFlechas.append( regFlecha )
            self.grid.refresh()
            self.grid.gobottom()
            self.grid.setFocus()

    #--------------------------------------------------------------------------------------------------------------------------------
    def borrar( self ) :
        fila = self.grid.recno()
        if fila >= 0 :
            if QTUtil2.pregunta( self, tr( "TUT_BORRAMOS_FLECHA", self.liPFlechas[fila].nombre )) :
                del self.liPFlechas[fila]
                self.grid.refresh()
                self.grid.setFocus()

    #--------------------------------------------------------------------------------------------------------------------------------
    def modificar( self ) :
        fila = self.grid.recno()
        if fila >= 0 :
            w = WET_Flecha(self, fila, self.liPFlechas, self.funcTamTablero())
            if w.exec_() :
                self.liPFlechas[fila] = w.regFlecha
                self.grid.refresh()
                self.grid.setFocus()
                self.gridCambiadoRegistro( self.grid, fila, None )

    #--------------------------------------------------------------------------------------------------------------------------------
    def siEstaNombre( self, nombre ) :
        for rf in self.liPFlechas :
            if rf.nombre == nombre :
                return True
        return False

    #--------------------------------------------------------------------------------------------------------------------------------
    def copiar( self ) :
        fila = self.grid.recno()
        if fila >= 0 :
            regFlecha = copy.deepcopy( self.liPFlechas[fila] )
            n = 1
            nombre = "%s-%d"%(regFlecha.nombre, n )
            while self.siEstaNombre( nombre ) :
                n+=1
                nombre = "%s-%d"%(regFlecha.nombre, n )
            regFlecha.nombre = nombre
            regFlecha.id = self.tutorial.idNuevo()
            self.liPFlechas.append(regFlecha)
            self.grid.refresh()
            self.grid.setFocus()

    #--------------------------------------------------------------------------------------------------------------------------------
    def arriba( self ) :
        fila = self.grid.recno()
        if fila > 0 :
            self.liPFlechas[fila-1],self.liPFlechas[fila] = self.liPFlechas[fila],self.liPFlechas[fila-1]
            self.grid.goto(fila-1,0)
            self.grid.refresh()
            self.grid.setFocus()

    #--------------------------------------------------------------------------------------------------------------------------------
    def abajo( self ) :
        fila = self.grid.recno()
        if fila >= 0 and fila < (len(self.liPFlechas)-1) :
            self.liPFlechas[fila+1],self.liPFlechas[fila] = self.liPFlechas[fila],self.liPFlechas[fila+1]
            self.grid.goto(fila+1,0)
            self.grid.refresh()
            self.grid.setFocus()
