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

from PySide import QtCore

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

import Iconos
import Tablero
import QTVarios
import QTUtil2

import Colocacion
import Controles

import FormLayout

# ----------------------------------------------------------------------------------------------------
class PantallaTutor(QTVarios.WDialogo):

    def __init__(self, gestor, tutor, siRival, siAperturas, siBlancas, siPuntos, confTablero ) :

        titulo = tr( "RECONSIDERANDO" )
        icono = Iconos.Tutor()
        extparam = "tutor"
        QTVarios.WDialogo.__init__(self, gestor.pantalla, titulo, icono, extparam )

        self.tutor = tutor
        self.gestor0 = gestor.gestor
        self.respLibro = None
        self.siElegidaApertura = False

        self.vistaTutor = gestor.procesador.configuracion.vistaTutor

        #~ self.setStyleSheet("QDialog,QGroupBox { background: #f0f0f0; }")

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

        # Tableros
        def creaTablero( nombre, si = True, siLibre = True ) :
            if not si :
                return None, None, None
            tablero = Tablero.Tablero(self, confTablero)
            tablero.crea()
            tablero.ponerPiezasAbajo( siBlancas )
            lytb,tb = QTVarios.lyBotonesMovimiento( self, nombre, siLibre )
            return tablero, lytb, tb

        self.tableroTutor, lytbTutor, self.tbTutor = creaTablero( "tutor" )
        self.tableroUsuario, lytbUsuario, self.tbUsuario = creaTablero( "usuario" )
        self.tableroRival, lytbRival, self.tbRival = creaTablero( "rival", siRival )
        self.tableroApertura, lytbApertura, self.tbApertura = creaTablero( "apertura", siAperturas, siLibre = False )
        tutor.ponTablerosGUI( self.tableroTutor, self.tableroUsuario, self.tableroRival, self.tableroApertura )

        # Puntuaciones
        self.lbTutorPuntuacion = Controles.LB( ).alinCentrado().ponFuente(flb)
        self.lbUsuarioPuntuacion = Controles.LB( ).alinCentrado().ponFuente(flb)
        if siRival :
            self.lbRivalPuntuacion = Controles.LB( ).alinCentrado().ponFuente(flb)

        # Aperturas
        if siAperturas :
            liOpciones = self.tutor.opcionesAperturas()
            self.cbAperturas = Controles.CB( liOpciones, 0 )
            self.cbAperturas.setFont( flba )
            self.connect( self.cbAperturas, QtCore.SIGNAL("currentIndexChanged(int)"), self.tutor.cambiarApertura )

        # RM
        liRM = []
        for n, uno in enumerate(tutor.listaRM) :
            liRM.append( (uno[1],n) )

        self.cbRM, self.lbRM = QTUtil2.comboBoxLB( liRM, liRM[0][1], tr( "OTROS_MOVIMIENTOS" ) )
        self.connect( self.cbRM, QtCore.SIGNAL("currentIndexChanged (int)"), tutor.cambiadoRM )
        lyRM = Colocacion.H().control(self.lbRM).control(self.cbRM)

        lyTutor = Colocacion.V().relleno(1).control(self.lbTutorPuntuacion).relleno(1)
        gbTutor = Controles.GB( self, tr( "PROPUESTA_TUTOR" ), lyTutor ).ponFuente( f ).alinCentrado()
        if siPuntos :
            gbTutor.conectar( self.elegirTutor )

        lyUsuario = Colocacion.V().relleno(1).control(self.lbUsuarioPuntuacion).relleno(1)
        gbUsuario = Controles.GB( self, tr( "NUESTRA_JUGADA" ), lyUsuario ).ponFuente( f ).alinCentrado().conectar( self.elegirUsuario )
        btLibros = Controles.PB( self, tr( "LIBRO_CONSULTA" ), self.consultaLibro ).ponPlano( False )

        if siRival :
            lyRival = Colocacion.V().relleno(1).control(self.lbRivalPuntuacion).relleno(1)
            gbRival = Controles.GB( self, tr( "PREVISION_CONTRINCANTE" ), lyRival ).ponFuente( f ).alinCentrado()

        if siAperturas :
            lyAperturas = Colocacion.V().relleno(1).control( self.cbAperturas ).relleno(1)
            gbAperturas = Controles.GB( self, tr( "APERTURA" ), lyAperturas ).alinCentrado().ponFuente( f )
            if siPuntos :
                gbAperturas.conectar( self.elegirApertura )
            self.cbAperturas.setEnabled(True)
            self.tutor.cambiarApertura( 0 )

        dicVista = { kTutorH:((0,1),(0,2)), kTutorH2_1:((0,1),(4,0)), kTutorH1_2:((4,0),(4,1)), kTutorV:((4,0),(8,0)) }

        usu, riv = dicVista[self.vistaTutor]

        fu, cu = usu
        fr, cr = riv

        layout = Colocacion.G()
        layout.controlc( gbTutor, 0, 0 ).controlc( self.tableroTutor, 1, 0 ).otro( lytbTutor, 2, 0 ).otroc( lyRM, 3, 0 )
        layout.controlc( gbUsuario, fu, cu ).controlc( self.tableroUsuario, fu+1, cu ).otro( lytbUsuario, fu+2, cu ).controlc(btLibros, fu+3, cu)
        if siRival :
            layout.controlc( gbRival, fr, cr ).controlc( self.tableroRival, fr+1, cr ).otro(lytbRival, fr+2,cr )
        elif siAperturas :
            layout.controlc( gbAperturas, fr, cr ).controlc( self.tableroApertura, fr+1, cr ).otro(lytbApertura, fr+2, cr )

        layout.margen( 8 )

        self.setLayout( layout )

        self.recuperarVideo( siTam=False )

    def procesarTB( self ) :
        self.exeTB( self.sender().clave )

    def exeTB( self, accion ) :
        x = accion.index( "Mover" )
        quien = accion[:x]
        que = accion[x+5:]
        self.tutor.mueve( quien, que )

    #--------------------------------------------------------------------------------------------------------------------------------
    def tableroWheelEvent( self, tablero, siAdelante ) :
        for t in [ "Tutor", "Usuario", "Rival", "Apertura" ] :
            if eval( "self.tablero%s == tablero"% t ) :
                self.exeTB( t.lower() + "Mover" + ("Adelante" if siAdelante else "Atras" ) )
                return

    #--------------------------------------------------------------------------------------------------------------------------------
    def consultaLibro( self ) :
        resp = self.gestor0.libros( "T",  siVentanaPrincipal=False )
        if resp :
            self.respLibro = resp[0:2], resp[2:4], resp[4:]
            self.guardarVideo()
            self.accept()

    def elegirTutor( self ) :
        self.guardarVideo()
        self.accept()

    def elegirApertura( self ) :
        self.siElegidaApertura = True
        self.guardarVideo()
        self.accept()

    def elegirUsuario( self ) :
        self.guardarVideo()
        self.reject()

    def ponPuntuacionUsuario( self, txt ) :
        self.lbUsuarioPuntuacion.setText( txt )

    def ponPuntuacionTutor( self, txt ) :
        self.lbTutorPuntuacion.setText( txt )

    def ponPuntuacionRival( self, txt ) :
        self.lbRivalPuntuacion.setText( txt )

    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" )

#==========================================================================================================================================
def cambioTutor( parent, configuracion  ) :

    # Datos
    liGen = [(None,None)]

    ## Tutor
    liGen.append( ( tr( "MOTOR" ) + " :", configuracion.ayudaCambioTutor() ) )

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

    liGen.append( ( None, tr("SENSIBILIDAD") ) )
    liGen.append( (FormLayout.Spinbox( tr( "SENSIBILIDAD_PUNTOS" ), 0, 1000, 70 ), configuracion.tutorDifPts ) )
    liGen.append( (FormLayout.Spinbox( tr( "SENSIBILIDAD_PORCENTAJE" ), 0, 1000, 70 ), configuracion.tutorDifPorc ) )

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

    if resultado :
        accion, liResp = resultado

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

        difpts = liResp[2]
        difporc = liResp[3]

        return claveMotor, tiempo, difpts, difporc
    else :
        return None
