#from __future__ import unicode_literals
# -*- coding: utf-8 -*-
from __future__ import division
import sys

from PyQt4.QtCore import *
from PyQt4.QtGui import *
from Combattant import Combattant
from ui.ecran_editionCombattant import Ui_edc_fenetre
from EcranEditionObjet import EcranEditionObjet
from frameAttaque import FrameAttaque
from outilsSvg import *
from VueEditionForme import VueEditionForme
import regles
import Actions
from Objet import Objet
import ui.dm as dm
import rsc

class EcranEditionCombattant(QDialog):
    """interface de creation/edition de terrains"""
    def __init__(self, combattant=None, pageInitiale = 0, formeCases = "H", parent=None):
        """initialisation de la fenetre"""
        super (EcranEditionCombattant, self).__init__()
        self.pixGraphique = None
        self._compteurAttaque = 0
        self.createWidgets()
        if combattant == None:
            self.combattant = Combattant()
        else:
            self.combattant = combattant
            
        self.modeCreation = True
        self.ouverture()
        self.ui.edc_menu.setCurrentCell(pageInitiale, 0)
        self.ui.edc_pages.setCurrentIndex(pageInitiale)
        if formeCases == "C":
            self.ui.edc_casesCarrees.setChecked(True)
            self.majFormeCases()
            

    def nouvelIdCombattant(self):
        """renvoie un identifiant pour un nouveau terrain"""
        dicoSvg = afficheSvg("lib\\biblio\\Combattant")
        nouvelId = 1
        while str(nouvelId) in dicoSvg.keys():
            nouvelId += 1
        return str(nouvelId)

    def formeCases(self):
        retour = ""
        if self.ui.edc_casesHexa.isChecked():
            retour = "H"
        else:
            retour = "C"
        return retour

    def createWidgets(self):
        """construction de l'interface"""
        #construction de l'interface
        self.ui = Ui_edc_fenetre()
        self.ui.setupUi(self)
        
        self.connect(self.ui.edc_nom, SIGNAL("textEdited(QString)"), self.majActivationEnregistrer)
        self.connect(self.ui.edc_nom, SIGNAL("textEdited(QString)"), self.majEtiquetteVueForme)

        self.connect(self.ui.edc_enregistrer, SIGNAL("clicked()"), self.enregistrer)
        self.connect(self.ui.edc_annuler, SIGNAL("clicked()"), self.annuler)

        self.connect(self.ui.edc_casesHexa, SIGNAL("clicked()"), self.majFormeCases)
        self.connect(self.ui.edc_casesCarrees, SIGNAL("clicked()"), self.majFormeCases)
        self.connect(self.ui.edc_couleur, SIGNAL("clicked()"), self.selectionCouleur)
        self.connect(self.ui.edc_image, SIGNAL("clicked()"), self.selectionImage)

        self.connect(self.ui.edc_logo, SIGNAL("clicked()"), self.selectionnerLogo)
        self.vueForme = VueEditionForme(self)

        self.construireListeAttributs()

        self.construireInventaire()
        self.connect(self.ui.edc_filtreTypeObjet, SIGNAL("currentChanged(int)"), self.filtrerInventaire)
        self.ui.edc_filtreTypeObjet.stackUnder(self.ui.edc_listeInventaire)

    def layoutAtt(self):
        """retourne le layout des attaques"""
        return self.ui.edc_deroulementAttaques_layout

    def layoutCarac(self):
        """retourne le layout des attributs"""
        return self.ui.edc_deroulementAttributs_layout        

    def vueGraphique(self):
        return self.ui.edc_vueForme

    def ouverture(self):
        """premier affichage: on met a jour les champs"""
       
        #page_nom
        self.ui.edc_nom.majTexte(self.combattant.nom)
        if self.combattant.logo:
            self.ui.edc_logo.chargerImage(self.combattant.logo)
        else:
            self.ui.edc_logo.majTexte("Choisissez \nun fichier\nimage")

        self.vueForme.creer(self.formeCases())
        self.vueForme.autoriserModifForme(self.modeCreation)
        self.vueForme.majCouleur(self.combattant.couleur)
        self.vueForme.chargerFormeDef(self.combattant.formeDef[self.formeCases()])
        self.vueForme.chargerImageDef(self.combattant.img)
        self.vueForme.chargerEtiquetteDef(self.combattant.etiquette)

        #page deplacements
        self.ui.edc_taille.setValue(self.combattant.hauteur)
        self.ui.edc_depMarche.setValue(self.combattant.depMarche)
        self.ui.edc_depNage.setValue(self.combattant.depNage)
        self.ui.edc_depEscalade.setValue(self.combattant.depEscalade)
        self.ui.edc_depVol.setValue(self.combattant.depVol)
        self.ui.edc_saut.setValue(self.combattant.saut)      

        #page attributs
        self.majListeAttributs()        

        #page attaques: chargement des attaques du combattant, puis panneau 'nouvelle attaque'
        self.layoutAtt().setAlignment(Qt.AlignTop)
        for attaque in self.combattant.attaques:
            self.attaqueNouvelle(attaque)
        self.attaqueNouvelle()

        #page inventaire
        self.ui.edc_listeInventaire.charger(self.combattant.inventaire)
        self.majTotauxInventaire()

        #page_notes
        for detail in self.combattant.details:
            widget = self.ui.edc_pages.findChild(dm.DmLineEdit, "edc_detail_{}".format(detail))
            if widget:
                widget.majTexte(self.combattant.details[detail])
        self.ui.edc_notes.setText(QString.fromUtf8(self.combattant.notes))

        #autre
        self.majActivationEnregistrer()
        

    ### page apparence
    def majFormeCases(self):
        if self.vueForme.formeCases() != self.formeCases():
            #on enregistre la def de forme, d'image et d'etiquette en cours
            self.combattant.formeDef[self.vueForme.formeCases()] = self.vueForme.formeDef()
            self.combattant.img = self.vueForme.imageDef()
            self.combattant.etiquette = self.vueForme.etiquetteDef()

            #on recree la scene avec la nouvelle forme de cases
            self.vueForme.vider()
            self.vueForme.creer(self.formeCases())

            #on charge les def correspondantes a la nouvelle forme
            self.vueForme.chargerFormeDef(self.combattant.formeDef[self.formeCases()])
            self.vueForme.chargerImageDef(self.combattant.img)
            self.vueForme.chargerEtiquetteDef(self.combattant.etiquette)

    def majEtiquetteVueForme(self):
        self.combattant.etiquette.txt = self.ui.edc_nom.texte()
        self.vueForme.chargerEtiquetteDef(self.combattant.etiquette)

    def selectionnerLogo(self):
        img = rsc.selectionImage("cb")
        if img:
            self.ui.edc_logo.chargerImage(img)
            self.vueForme.nouvelleImageDef(self.ui.edc_logo.image())

    def selectionImage(self):
        """selectionne le fichier image dans la boite de dialogue dediee"""
        img = rsc.selectionImage("cb")
        if img:
            self.vueForme.nouvelleImageDef(img)
        
    def selectionCouleur(self):
        """selectionne la couleur dans la boite de dialogue dediee"""
        couleur = QColorDialog(self).getColor(QColor("white"), self)
        if couleur.isValid():
            self.combattant.couleur = couleur
            self.vueForme.majCouleur(couleur)

    #### page attributs
    def construireListeAttributs(self):
        """construit les champs d'attributs"""
        """cree les champs dedies a la saisie des attributs dans la grille dediee"""
        self.layoutCarac().setSpacing(4)
        self.layoutCarac().setMargin(0)
        self.layoutAtt().setAlignment(Qt.AlignLeft)
        
        for nomAttribut in regles.ordreAttributsFichePerso():
            if len(nomAttribut) > 0:
                lay = QHBoxLayout()
                lay.setMargin(0)
                lay.setSpacing(2)

                etiquette = dm.DmLabel()
                etiquette.majTexte(regles.attribut(nomAttribut).nom)        
                etiquette.setObjectName("{}_etiquette".format(nomAttribut))
                etiquette.setAlignment(Qt.AlignLeft|Qt.AlignVCenter)
                etiquette.setMinimumSize(QSize(110, 24))
                etiquette.setMaximumSize(QSize(110, 24))
                lay.addWidget(etiquette)
                
                champ = dm.DmLineEdit()
                champ.setMinimumSize(QSize(80, 24))
                champ.setMaximumSize(QSize(80, 24))
                champ.setAlignment(Qt.AlignCenter)
                champ.majTexte(regles.listeAttributs()[nomAttribut])
                champ.setObjectName("{}_champ".format(nomAttribut))
                champ.setStyleSheet("background-color: rgb({},{},{});".format(248,248,248))
    ##            self.connect(champ, SIGNAL("textChanged()"), self.controlerAttribut)
                lay.addWidget(champ)

                self.layoutCarac().addLayout(lay)
            else:
                lay = QHBoxLayout()
                etiquetteVide = dm.DmLabel()
                etiquetteVide.setMinimumHeight(9)
                etiquetteVide.setMaximumHeight(9)
                lay.addWidget(etiquetteVide)
                lay.addWidget(etiquetteVide)
                self.layoutCarac().addLayout(lay)

    def majListeAttributs(self):
        """met a jour la liste des attributs de la Combattant"""
        for i in range(0, self.layoutCarac().count()):
            layout = self.layoutCarac().itemAt(i).layout()
            widget = layout.itemAt(1).widget()
            if widget != 0:
                if str(widget.objectName()[-6:]) == "_champ":
                    attr = str(widget.objectName()[:-6])
                    widget.majTexte(self.combattant.listeAttributs[attr])            

    def listeAttributs(self):
        """renvoie la liste des attributs tels qu'ils
           sont saisis dans la liste des attributs"""
        attributs = regles.listeAttributs()
        for i in range(0, self.layoutCarac().count()):
            layout = self.layoutCarac().itemAt(i).layout()
            widget = layout.itemAt(1).widget()
            if widget != 0 and widget != None:
                if str(widget.objectName()[-6:]) == "_champ":
                    attr = str(widget.objectName()[:-6])
                    attributs[attr] = widget.texte()
        return attributs   

    #### page attaques
    def attaqueNouvelle(self, attaque = None):
        """ajoute une nouvelle ligne a la liste des attaques"""
        #on ajoute de suite un panneau 'nouvelle attaque en dessous'
        self._compteurAttaque += 1
        panneau = FrameAttaque(self._compteurAttaque)
        if attaque:
            panneau.chargerAttaque(attaque)
        panneau.setObjectName(QString("att_frame_{}".format(self._compteurAttaque)))
        self.connect(panneau, SIGNAL("attaqueNouvelle()"), self.attaqueNouvelle)
        self.connect(panneau, SIGNAL("attaqueSupprimer(int)"), self.attaqueSupprimer)
        self.layoutAtt().addWidget(panneau)        

    def attaqueSupprimer(self, index):
        """supprime la ligne selectionnee de la liste des attaques"""
        panneau = self.findChild(QFrame, "att_frame_{}".format(index))
        self.layoutAtt().removeWidget(panneau)

    ### page inventaire
    def construireInventaire(self):
        """construction de la page inventaire"""
        self.ui.edc_listeInventaire.construire()
        self.connect(self.ui.edc_listeInventaire, SIGNAL("objetClique(int)"), self.editerObjet)

    def editerObjet(self, indexObjet):
        if indexObjet < len(self.ui.edc_listeInventaire.inventaire()):
            objet = self.ui.edc_listeInventaire.inventaire()[indexObjet]
        else:
            objet = None
        typeObjet = self.ui.edc_filtreTypeObjet.currentIndex() - 1
        
            
        self.fenetreEO = EcranEditionObjet(objet, typeObjet)
        self.fenetreEO.show()
        self.fenetreEO.exec_()
        resultat = self.fenetreEO.resultat()

        if resultat:
            if objet:
                self.ui.edc_listeInventaire.majObjet(objet, resultat)
            else:
                self.ui.edc_listeInventaire.ajouterObjet(resultat)
        else:
            if objet:
                self.ui.edc_listeInventaire.supprimerObjet(objet)
        
        self.fenetreEO = None
        self.majTotauxInventaire()

    def majTotauxInventaire(self):
        inv = self.ui.edc_listeInventaire.inventaire()
        poidsTotal = 0.00
        for obj in inv:
            poidsTotal += obj.poidsTotal()
        self.ui.edc_inventaire_poids.majTexte("{} kg".format(poidsTotal))

    def filtrerInventaire(self, index):
        filtre = index - 1
        self.ui.edc_listeInventaire.filtrer(filtre)

    #### barre d'outils
    def majActivationEnregistrer(self):
        """verifie la validite des saisies"""
        self.ui.edc_enregistrer.setEnabled(len(self.ui.edc_nom.texte()) > 0) 
    
    def enregistrer(self):
        """enregistre le terrain cree/edite"""
        #identifiant
        if not self.combattant.id:
            self.combattant.id = self.nouvelIdCombattant()

        #page nom
        self.combattant.nom = self.ui.edc_nom.texte()
        self.combattant.logo = self.ui.edc_logo.image()
        
        self.combattant.formeDef[self.vueForme.formeCases()] = self.vueForme.formeDef()
        self.combattant.img = self.vueForme.imageDef()
        self.combattant.etiquette = self.vueForme.etiquetteDef()

        #page dep
        self.combattant.hauteur = self.ui.edc_taille.value()
        self.combattant.depMarche = self.ui.edc_depMarche.value()
        self.combattant.depNage = self.ui.edc_depNage.value()
        self.combattant.depEscalade = self.ui.edc_depEscalade.value()
        self.combattant.depVol = self.ui.edc_depVol.value()
        self.combattant.saut = self.ui.edc_saut.value()

        #page attributs
        self.combattant.listeAttributs = self.listeAttributs()

        #page attaque
        listeAttaques = []
        for i in range(0, self.layoutAtt().count()):
            panneau = self.layoutAtt().itemAt(i).widget()
            if panneau != 0:
                attaque = panneau.attaque()
                if attaque:
                    listeAttaques.append(attaque)
        self.combattant.attaques = listeAttaques

        #page inventaire
        self.combattant.inventaire = self.ui.edc_listeInventaire.inventaire()

        #page notes
        listeWidget = self.ui.edc_pages.findChildren(dm.DmLineEdit)
        for widget in listeWidget:
            detail = str(widget.objectName()).replace("edc_detail_","")
            txt = widget.texte()
            if len(txt) > 0:
                self.combattant.details[detail] = txt
        
        self.combattant.notes = str(self.ui.edc_notes.toPlainText().toUtf8())

##        enregistrer(self.combattant.id, self.combattant, "lib\\biblio\\combattant")
##        self.combattant = None
        self.done(1)

    def annuler(self):
        """annule la creation/edition"""
        self.combattant = None
        self.done(0)

if __name__ == "__main__":
    app = QApplication(sys.argv)
    ecran = EcranEditionCombattant()
    ecran.show()
    r = app.exec_()
    exit(r)