#from __future__ import unicode_literals
# -*- coding: utf-8 -*-
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from lib.Actions import *
import lib.regles as regles
from dm import *

#dans une DmTableAttaques, les 10 premieres colonnes sont reservees aux donnees de base
#le reste des colonnes sert aux donnees complementaires issues des regles
colonnesBase= ["numAttaque","Type","Nom","Portee","Forme","Rayon"]
largeurColonnesBase = {"numAttaque": 0, "Type": 70, "Nom": 100, "Portee": 60, "Forme": 80,"Rayon": 60}
        
class DmTableAttaques(DmTableWidget):
    """interface d'edition des attaques du combattant"""
    def __init__(self, parent=None):
        super (DmTableAttaques, self).__init__()
        self.combattant = None
        self.construire()

    def construire(self):
        """cree les colonnes de la table"""
        #colonnes de base: celles qui ne dependent pas des regles utilisees
        for i in range(0, 10):
            self.insertColumn(i)
            #on cache les colonnes qui ne seront pas utilisees
            self.setColumnHidden(i, (i >= len(colonnesBase)))
            if i < len(colonnesBase):
                #la largeur est geree par une variable globale
                self.setHorizontalHeaderItem(i, QTableWidgetItem(colonnesBase[i]))

                if colonnesBase[i] in largeurColonnesBase:
                    largeur = largeurColonnesBase[colonnesBase[i]]
                else:
                    largeur = 60
                if largeur > 0:    
                    self.setColumnWidth(i, largeur)
                else:    
                    self.setColumnHidden(i, True)


##        self.cellWidget(index, self.posColonne("Type")).setEnabled(False)
                    
        #on ajoute maintenant les colonnes issues des regles            
        ordre = regles.ordreAttributsAttaques()
        for elt in ordre:
            numCol = 10 + ordre.index(elt)
            self.insertColumn(numCol)
            self.setHorizontalHeaderItem(numCol, QTableWidgetItem(QString.fromUtf8(elt)))
            self.setColumnWidth(numCol, 45)
            self.setColumnHidden(numCol, False)

        self.connect(self, SIGNAL("cellChanged(int, int)"), self.celluleModifiee)

    def siCombattant(fonction):
        """decorateur: si combattant"""
        
        def _siCombattant(self, *args):
            def fVide(*args):
                pass
            retour = fVide
            if self.combattant:
                retour = fonction
            retour(self)                            
        return _siCombattant  

    def charger(self, combattant):
        self.combattant = combattant
        self.maj()
        self.nouvelle()

    @siCombattant
    def maj(self):
        """met a jour le contenu de la table des donnees"""
        self.vider()
        self.majEnCours = True
        
        index = 0
        for attaque in self.combattant.attaques:
            self.insertRow(int(index))
            #liste deroulante des types d'attaque
            
            
##            #num de l'attaque
##            self.setItem(int(index), 0, QTableWidgetItem(QString.fromUtf8(str(index))))
        
            donneesAttaque = {"NumAttaque": index, "Nom": attaque.nom, "Portee": attaque.portee}
            self.majLigne(index, donneesAttaque)  #[Qt.NoItemFlags, Qt.ItemIsSelectable]

            #met a jour l'index en cours de la liste deroulante des types d'attaque
            widget = self.listeTypesAttaques()
            widget.allerA(attaque.typeAtt())
            self.setCellWidget(int(index), self.posColonne("Type"), widget)
##            self.setCellWidget(int(index), self.posColonne("Type"), self.listeTypesAttaques())
##            self.cellWidget(index, self.posColonne("Type")).allerA(attaque.typ)
            self.afficherDonneesAttaqueZone(index, (attaque.typ == "zone"))            

            ### parametres supplementaires (issus des regles)
            self.majLigne(index, attaque.attributs)
##            for elt in attaque.attributs:
##                col = 10 + regles.ordreAttributsAttaques().index(elt)
##                self.setItem(index, col , QTableWidgetItem(QString.fromUtf8(str(attaque.attributs[elt]))))
          
            index += 1

        self.majEnCours = False

    def posColonne(self, nom):
        """renvoie la position de la colonne demandee"""
        retour = None
        if nom in colonnesBase:
            retour = colonnesBase.index(nom)
        elif nom in regles.ordreAttributsAttaques():
            retour = 10 + regles.ordreAttributsAttaques().index(nom)
        return retour
    
    @siCombattant
    def celluleModifiee(self, ligne, colonne):
        """une cellule de la table a ete modifiee par l'utilisateur"""
        if not self.majEnCours:
            numAttaque = int(self.val(ligne, 0))
            attaque = self.combattant.attaques[numAttaque]
            
            if colonne < len(colonnesBase):
                if colonne == self.posColonne("Nom"):
                    #maj du nom de l'attaque
                    nom = self.texte(ligne, colonne)
                    if not len(nom) > 0:
                        nom = "Att. {}".format(numAttaque)
                    attaque.nom = nom
                
                elif colonne == self.posColonne("Type"):
                    #maj du type de l'attaque
                    typ = str(self.cellWidget(ligne, colonne).valeurActuelle().toString())
                    attaque.typ = typ
                    self.afficherDonneesAttaqueZone(ligne, (typ == "zone"))
                    
                elif colonne == self.posColonne("Forme"):
                    #maj de la forme de l'attaque
                    forme = str(self.cellWidget(ligne, colonne).valeurActuelle().toString())
                    attaque.formeZone = forme
                    
                elif colonne == self.posColonne("Portee"):
                    #maj de la portee de l'attaque
                    #doit etre de type numerique
                    try:
                        portee = int(self.data(ligne, colonne))
                        if portee < 1000:
                            attaque.portee = portee
                        else:
                            self.majEnt(ligne, colonne, attaque.portee)
                    except:
                        #sinon, on restaure l'ancienne valeur
                        self.majEnt(ligne, colonne, attaque.portee)

                elif colonne == self.posColonne("Rayon"):
                    #doit etre de type numerique
                    try:
                        rayon = int(self.data(ligne, colonne))
                        if rayon < 100:
                            self.combattant.attaques[numAttaque].rayon = rayon
                        else:
                            self.majEnt(ligne, colonne, attaque.rayon)         
                    except:
                        self.majEnt(ligne, colonne, attaque.rayon) 
    
            elif colonne >= 10:
                #colonnes issues des regles
                index = colonne - 10
                attribut = regles.ordreAttributsAttaques()[index]
                valeurAttribut = regles.listeControleAttaques()[attribut].controler(str(self.data(ligne, colonne).toString()))
                if valeurAttribut != None:
                    attaque.attributs[attribut] = valeurAttribut
                else:
                    self.majData(ligne, colonne, attaque.attributs[attribut])

    @siCombattant
    def nouvelle(self):
        """ajoute une ligne a la table et une attaque au pion"""
        self.combattant.attaques.append(Cac())
        self.maj()

    @siCombattant
    def supprimer(self):
        """supprime l'attaque selectionnee de la liste des attaques du pion"""
        select = self.ligneSelectionnee()
        if select:
            numAttaque = int(self.data(sel,0))
            reponse = QMessageBox.question(self, 'Message',
                           "Etes vous sûr de vouloir supprimer cette attaque?", QMessageBox.Yes | 
                           QMessageBox.No, QMessageBox.No)
            if reponse == QMessageBox.Yes:   
                del self.combattant.attaques[numAttaque]
                self.maj()

    def majTypeAttaque(self):
        """une des liste de type a ete modifiee, on met a jour toute la colonne (en attendant mieux :( )"""
        colonne = self.posColonne("Type")
        for i in range(0, self.rowCount()):
            if str(self.cellWidget(i, colonne).itemData(\
                   self.cellWidget(i, colonne).currentIndex())) != \
                   self.combattant.attaques[int(self.item(i, 0).text().toUtf8())].typ:
                self.celluleModifiee(i, colonne)

    def majFormeZone(self):
        """une des liste de type a ete modifiee, on met a jour toute la colonne (en attendant mieux :( )"""
        colonne = self.posColonne("Forme")
        for i in range(0, self.rowCount()):
            if self.cellWidget(i, colonne).__class__.__name__ == "QComboBox":
                if str(self.cellWidget(i, colonne).itemData(\
                       self.cellWidget(i, colonne).currentIndex())) != \
                       self.combattant.attaques[int(self.item(i, 0).text().toUtf8())].formeZone:
                    self.celluleModifiee(i, colonne)
                
    def listeTypesAttaques(self):
        """retourne la DmComboBox qui apparait dans la colonne Type d'attaque"""
        liste = DmComboBox()
        liste.addItem(QIcon("img\\curseurEpee.png"), QString.fromUtf8("C.à.C"), "cac")
        liste.addItem(QIcon("img\\arc.png"), QString.fromUtf8("Dist."), "dist")
        liste.addItem(QIcon("img\\baguette.png"), QString.fromUtf8("Zone"), "zone")
        self.connect(liste, SIGNAL("currentIndexChanged(int)"), self.majTypeAttaque)
        return liste
    
    def listeFormesZone(self):
        """retourne la QComboBox qui apparait dans la colonne forme de zone"""
        liste = QComboBox()
        liste.addItem(QIcon("img\\formeLigne.png"), QString.fromUtf8("Ligne"), "ligne")
        liste.addItem(QIcon("img\\formeEllipsePlein.png"), QString.fromUtf8("Disque"), "disque")
        liste.addItem(QIcon("img\\cone.png"), QString.fromUtf8("Cone"), "cone")
        self.connect(liste, SIGNAL("currentIndexChanged(int)"), self.majFormeZone)
        return liste

    @siCombattant
    def afficherDonneesAttaqueZone(self, ligne, afficher):
        """rend modifiables ou non les donnees de base liees aux attaques de zone et modifie l'affichage en consequence"""
        self.majEnCours = True
        
        if afficher:
            numAttaque = int(self.data(ligne, 0))
            attaque = self.combattant.attaques[numAttaque]
            
            if self.cellWidget(ligne, self.posColonne("Forme")) == None:
                self.setCellWidget(ligne, self.posColonne("Forme"), self.listeFormesZone())
                
            if attaque.formeZone in ["ligne", "disque", "cone"]:
                self.cellWidget(ligne, self.posColonne("Forme")).allerA(attaque.formeZone)

            item = QTableWidgetItem()
            item.setData(0, attaque.rayon)
            item.setBackgroundColor(QColor("white"))
            self.setItem(ligne, self.posColonne("Rayon"), item)
            
        else:
            if self.cellWidget(ligne, self.posColonne("Forme")) != None:
                self.removeCellWidget(ligne, self.posColonne("Forme"))
                
            item = QTableWidgetItem(QString.fromUtf8(""))
            item.setFlags(Qt.NoItemFlags)
            item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
            item.setBackgroundColor(QColor(200,200,200))
            self.setItem(ligne, self.posColonne("Forme"), item)
            
            item = QTableWidgetItem(QString.fromUtf8(""))
            item.setFlags(Qt.NoItemFlags)
            item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
            item.setBackgroundColor(QColor(200,200,200))
            self.setItem(ligne, self.posColonne("Rayon"), item)

        self.majEnCours = False