#from __future__ import unicode_literals
# -*- coding: utf-8 -*-
"""Interface principale du programme DMonde
"""
from __future__ import division
import os
from sys import exit, argv, getsizeof, settrace
from time import time, sleep, strftime, localtime
import pydoc

from PyQt4.QtCore import *
from PyQt4.QtGui import *

from lib.ui.ecran_principal import Ui_principal

from lib.EcranCreationPlateau import EcranCreationPlateau
from lib.EcranFondPlateau import EcranFondPlateau
from lib.Plateau import Plateau

from lib.outilsSvg import *

from lib.Case import Case
from lib.Pion import Pion
from lib.PionDecor import PionDecor
from lib.Decor import Decor
from lib.Terrain import Terrain
from lib.Creature import Creature
from lib.Attaque import Attaque

from lib.Cache import Cache
from lib.EntreeSortie import EntreeSortie


#fonction ci dessous: deboguage, suit les appels faits aux fonctions
#settrace(trace_calls)
def trace_calls(frame, event, arg):
    if event != 'call':
        return
    co = frame.f_code
    func_name = co.co_name
    if func_name == 'write':
        # Ignore write() calls from print statements
        return
    func_line_no = frame.f_lineno
    func_filename = co.co_filename
    caller = frame.f_back
    caller_line_no = caller.f_lineno
    caller_filename = caller.f_code.co_filename
    #print 'Call to %s on line %s of %s from line %s of %s' % \
    #    (func_name, func_line_no, func_filename,
    #     caller_line_no, caller_filename)
    print("{} ({})".format(func_name, func_filename))
    return


class DMonde(QMainWindow):
    """interface comprenant: chat ecrit, fenetre d'infos, lancer de des, echange de fichiers, lancement du chat vocal"""
    def __init__(self, parent=None):
        """initialisation de la fenetre"""
        super (DMonde, self).__init__()
        self.plateau = None
        self.partie = "partie1"
        self.idPlateauEnCours = ""
        self.plateauConnecte = False
        self.createWidgets()
        
    def createWidgets(self):
        """construction de l'interface"""
        self.ui = Ui_principal()
        self.ui.setupUi(self)
        self.majVisibilitePanneauxPlateau("")
        self.connect(self.ui.sauverPlateau, SIGNAL("clicked()"), self.sauverPlateau)   
        self.connect(self.ui.fermerPlateau, SIGNAL("clicked()"), self.fermerPlateau)
        self.ui.vuePlateau.setViewportUpdateMode(QGraphicsView.BoundingRectViewportUpdate)

        self.majFichierInfosSvg()
        self.creerEcranFondPlateau()
        
    def creerEcranFondPlateau(self):
        ecranFondPlateau = EcranFondPlateau(self)
        self.ui.vuePlateau.resetTransform()
        self.ui.vuePlateau.setScene(ecranFondPlateau)
        
    def afficherEcranCreationPlateau(self):
        """ouvre la fenetre de creation de plateau"""
        valide = True
        if self.plateau != None:
            if self.plateau.estCree() == True:
                valide = False
        if valide:
            self.creationPlateau = EcranCreationPlateau(self)
            self.creationPlateau.setWindowModality(Qt.ApplicationModal)
            self.creationPlateau.show()
            self.creationPlateau.raise_()

    def creerPlateau(self, nom, chapitre, formeCases, largeur, hauteur, couleur):
        """cree le plateau entre en parametre"""
        nouvelId = str(len(afficheSvg("parties\\{}\\svg\\infos_sauvegarde".format(self.partie))))
        QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
        self.plateau = Plateau(self)
        self.plateau.creer(nouvelId, nom, chapitre, formeCases, largeur, hauteur, couleur)
        QApplication.restoreOverrideCursor()
        del self.creationPlateau
                                   
    def sauverPlateau(self):
        QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
        if self.plateau.id in afficheSvg("parties\\{}\\svg\\infos_sauvegarde".format(self.partie)):
           idPlateau = self.plateau.id
        else:   
           idPlateau = str(len(afficheSvg("parties\\{}\\svg\\infos_sauvegarde".format(self.partie))))

        enregistrerUnique(self.plateau, "parties\\{}\\svg\\{}.p".format(self.partie, idPlateau))
        infos = {"nom": self.plateau.nom, "chapitre": self.plateau.chapitre, "dateCreation":self.plateau.dateCreation, "dateSvg":self.plateau.dateSvg, \
                 "public": self.plateau.public, "enCours": self.plateau.enCours}
        enregistrer(str(idPlateau), infos, "parties\\{}\\svg\\infos_sauvegarde".format(self.partie))
        QApplication.restoreOverrideCursor()

    def chargerPlateau(self, nomFichierSvg):
        if self.plateau != None:
            if self.plateau.estCree() == True:
                self.fermerPlateau()
        QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
        self.plateau = chargerUnique("parties\\{}\\svg\\{}.p".format(self.partie, nomFichierSvg))
        if self.plateau:
            self.plateau.recreer(self)
        else:
            self.plateau = Plateau(self)
        QApplication.restoreOverrideCursor()

    
    def fermerPlateau(self):
        self.plateau.fermer()
        self.plateau = None
        self.creerEcranFondPlateau()
##        self.majVisibilitePanneauxPlateau("") 

    def majFichierInfosSvg(self):
        """construit/maj le fichier contenant la liste des
           plateaux sauvegardes et leurs informations"""
        #on parcourt les fichiers de sauvegarde
        index = 0   
        f = []
        lstFichiersSvg = []
        for (dirpath, dirnames, filenames) in os.walk("parties\\{}\\svg\\".format(self.partie)):
            f.extend(filenames)
            break
        for fichier in f:
            fileName, fileExtension = os.path.splitext(fichier)
            if fileExtension == ".p":
                lstFichiersSvg.append(fileName)
      
        #on verifie leur presence dans le fichier 'infos_sauvegarde'
        infosSvg = afficheSvg("parties\\{}\\svg\\infos_sauvegarde".format(self.partie))
        index = len(infosSvg)

        #on ajoute les sauvegardes manquantes si besoin
        for fichier in lstFichiersSvg:
            if not fichier in infosSvg:
                plateau = chargerUnique("parties\\{}\\svg\\{}.p".format(self.partie, fichier))
                enregistrer(fichier, {"nom": plateau.nom, "chapitre": plateau.chapitre, "dateCreation":plateau.dateCreation, "dateSvg":plateau.dateSvg, \
                                      "public": plateau.public, "enCours": plateau.enCours}, "svg\\infos_sauvegarde")
                index += 1       
        #on supprime ceux qui ne sont plus trouves
        for fichier in infosSvg:
            if not fichier in lstFichiersSvg:
                supprSvg("parties\\{}\\svg\\infos_sauvegarde".format(self.partie), fichier)

    def majVisibilitePanneauxPlateau(self, mode):
        """affiche ou cache les panneaux d'edition, d'information et de gestion du plateau"""
        #self.ui.panneauInfosPlateau.setVisible(False)
        conditionPlateau = (len(mode) > 0)
        conditionModeCreation = (len(mode) > 0 and mode == "creation")
        conditionModeCombat = (len(mode) > 0 and mode == "combat")

        #panneaux d'infos
        self.ui.infoOrdreJeu.setVisible(conditionPlateau)   
        self.ui.infoPion.setVisible(conditionPlateau)
        self.ui.infoDecor.setVisible(conditionPlateau)
        self.ui.infoCase.setVisible(conditionPlateau)

        #autre
        self.ui.nomPlateau.setVisible(conditionPlateau)
        self.ui.sauverPlateau.setVisible(conditionPlateau)
        self.ui.fermerPlateau.setVisible(conditionPlateau)
        self.ui.etiquetteModeAffichagePlateau.setVisible(conditionPlateau)
        self.ui.modeAffichagePlateau.setVisible(conditionPlateau)
        self.ui.combatTour.setVisible(conditionPlateau)
        
        #barre de combat:
        if len(mode) > 0:
            self.majVisibiliteBarreCombat("menu")
        else:
            self.majVisibiliteBarreCombat("aucun")
        self.ui.combatPasserTour.setVisible(conditionPlateau)
        self.ui.combatInventaire.setVisible(conditionPlateau)

        #modes creation/combat
        self.ui.modeCombatPlateau.setVisible(conditionModeCreation)
        self.ui.outilsEditionPlateau.setVisible(conditionModeCreation)
        self.ui.outilsCombatPlateau.setVisible(conditionModeCombat)
        self.ui.modeCreationPlateau.setVisible(conditionModeCombat)

    def reinitialiserPanneauxPlateau(self):
        """remet a neuf les commandes liees au plateau"""
        for panneau in [self.ui.panneauInfosPlateau, \
                         self.ui.outilsEditionPlateau, \
                         self.ui.outilsCombatPlateau]:
            #listes
            for liste in panneau.findChildren(QTableWidget):
                while liste.rowCount() > 0:
                    liste.removeRow(0)
            #textes
            for texte in panneau.findChildren(QLineEdit):
                texte.clear()         
            for texte in panneau.findChildren(QTextEdit):
                texte.clear()
            #a cocher
            for bouton in panneau.findChildren(QToolButton):
                if bouton.isCheckable():
                    bouton.setChecked(False)
            #autre
            for item in panneau.findChildren(QSlider):
                item.setValue(1)
            for item in panneau.findChildren(QDoubleSpinBox):
                item.setValue(0)                

    def barreCombatMenu(self):
        self.majVisibiliteBarreCombat("menu")

    def barreCombatVol(self):
        self.majVisibiliteBarreCombat("vol")

    def barreCombatZone(self):
        self.majVisibiliteBarreCombat("zone")        

    def majVisibiliteBarreCombat(self, mode = ""):
        """affiche ou cache les commandes de la barre de combat"""
        #modes : "aucun", "menu", "vol", "zone"
        for item in self.ui.barreBasCombat.children():
            try:
                item.setVisible(False)
            except:
                pass
            
        if mode != "aucun":
            self.ui.combatPionSelectionne.setVisible(True)
            self.ui.combatPionSelectionne_img.setVisible(True)
            self.ui.combatPionSelectionne_img.setPixmap(QPixmap())   
            self.ui.combatPasserTour.setVisible(True)
            self.ui.combatInventaire.setVisible(True)
        
        if mode == "menu" or mode == "":
            self.ui.combatDeplacement.setVisible(True)
            self.ui.combatAttaqueCaC.setVisible(True)
            self.ui.combatAttaqueDist.setVisible(True)
            self.ui.combatAttaqueZone.setVisible(True)
            self.ui.combatVol.setVisible(True)
            
        elif mode == "vol":
            self.ui.combatVol.setVisible(True)
            self.ui.combatVol_altitude.setVisible(True)
            self.ui.combatRetour.setVisible(True)
            
        elif mode == "zone":
            self.ui.combatZone_ligne.setVisible(True)
            self.ui.combatZone_disque.setVisible(True)
            self.ui.combatZone_disqueRayon.setVisible(True)
            self.ui.combatZone_cone.setVisible(True)
            self.ui.combatRetour.setVisible(True)








        
if __name__ == "__main__":
   app = QApplication(argv)
   #settrace(trace_calls)
   dm = DMonde()
   dm.show()
   r = app.exec_()
   exit(r)      








