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

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

from Decor import Decor
from Forme import Forme



class PionDecor(QGraphicsItem):
    """pion du plateau de combat representant un decor"""
    def __init__(self, plateau, numero, parent=None):
        super(PionDecor, self).__init__(parent)
        #plateau
        self.plateau = plateau    

        #attributs
        self.nom = "decor"
        self.numero = numero
        self.decor = Decor()
        self.position = (-1, -1)
        self.forme = Forme(self.plateau.formeCases)
        self.z = 0
        self.hauteur = 1   #hauteur de l'objet en cases
        self.pixGraphique = None
        self.largeurOriginale = 0
        self.hauteurOriginale = 0
        self.polygoneGraphique = None
        self.nbRotations = 0

    def __getstate__(self):
        state = {key:value for key, value in self.__dict__.items() if not key in ["plateau", "forme", "polygoneGraphique", "pixGraphique", "shadow"]}
        return (state)

    def __setstate__(self, state):
        self.__dict__ = state

    def paint(self, painter, option, widget = None):
        """reimplemente de QGraphicsItem"""
        pass

    def surbrillance(self, active):
        """active/desactive la surbrillance"""
        pass

    def txtId(self):
        return self.nom

    ########### fonctions graphiques et geometriques   ##############
    def creer(self, posX, posY, decor, nbRotations):
        """place le pion decor sur le plateau"""        
        self.decor = decor
        self.setFlag(QGraphicsItem.ItemHasNoContents) #inutile de peindre l'item
        self.setHandlesChildEvents(True)
        
        if len(self.decor.formeDef[self.plateau.formeCases]) > 0:
            self.forme.definirForme(self.decor.formeDef[self.plateau.formeCases])
        self.hauteur = self.decor.hauteur
        
        self.position = (posX, posY)
        self.majNbRotations(nbRotations)

        #aspect graphique
        self.majAspectGraphique()

        #ajout de l'objet graphique et placement
        self.plateau.addItem(self)

    def recreer(self, plateau):
        """recree l'objet graphique apres un chargement"""
        self.plateau = plateau
        super(PionDecor, self).__init__()
        self.setFlag(QGraphicsItem.ItemHasNoContents) #inutile de peindre l'item
        self.setHandlesChildEvents(True)
        self.polygoneGraphique = None
        self.pixGraphique = None
        self.forme = Forme(self.plateau.formeCases)
        if len(self.decor.formeDef[self.plateau.formeCases]) > 0:
            self.forme.definirForme(self.decor.formeDef[self.plateau.formeCases])        
        #aspect graphique
        self.majAspectGraphique()
        #ajout de l'objet graphique et placement
        self.plateau.addItem(self)
             
    def majAspectGraphique(self):
        """met a jour l'aspect graphique du pion"""
        #creation de la forme
        if not self.polygoneGraphique:
            polygone = self.plateau.polygoneAgglo(self.forme.listeCases((0,0)))
            self.polygoneGraphique = QGraphicsPolygonItem()
            self.polygoneGraphique.setPolygon(polygone)
            self.polygoneGraphique.setAcceptHoverEvents(True)
            self.polygoneGraphique.setFlag(QGraphicsItem.ItemIsFocusable)   #l'item peut recevoir des commandes souris/clavier
            self.polygoneGraphique.setParentItem(self)
            self.polygoneGraphique.setPos(QPointF(0,0))
            if self.plateau.formeCases == "H":
                self.polygoneGraphique.setTransformOriginPoint(QPointF(2*0.2886*self.plateau.hCase,0.5*self.plateau.hCase))
            else:
                self.polygoneGraphique.setTransformOriginPoint(QPointF(0.5*self.plateau.hCase,0.5*self.plateau.hCase))
                
        if self.plateau.formeCases == "H":
            angleRotation = 60
            positionGraphique = QPointF(self.position[0] * 0.866 * self.plateau.hCase, self.position[1] * self.plateau.hCase)
        else:
            angleRotation = 90
            positionGraphique = QPointF(self.position[0] * self.plateau.hCase, self.position[1] * self.plateau.hCase)
            
        self.polygoneGraphique.setRotation(self.nbRotations*angleRotation)    
        self.setPos(positionGraphique)
        self.setZValue(10)    #place au dessus des cases
        
        #interactions
        self.setFlag(QGraphicsItem.ItemIsFocusable)
        self.setAcceptHoverEvents(True)   #accepte les evenements survol souris

        #bordure
        pinceau = QPen()
        #pinceau.setColor(self.decor.couleur.darker(130))
        pinceau.setColor(self.decor.couleur)
        pinceau.setWidth(10)
        self.polygoneGraphique.setPen(pinceau)

        #ombre
        self.shadow = QGraphicsDropShadowEffect()
        self.shadow.setColor(QColor(50, 50, 50)) 
        self.shadow.setXOffset(1) 
        self.shadow.setYOffset(2) 
        self.shadow.setBlurRadius(3)  
        self.shadow.setEnabled(True)
        self.polygoneGraphique.setGraphicsEffect(self.shadow)

        #maj de l'image
        self.majImage()

        #fond 
        if self.decor.couleur.isValid():
            self.polygoneGraphique.setBrush(self.decor.couleur)
        else:
            self.polygoneGraphique.setBrush(QColor(255, 0, 0, 100))

        #on met a jour l'occupation des cases
        for coord in self.forme.listeCases((self.position[0],self.position[1]), self.nbRotations):
            self.plateau.cases[coord].majOccupation(self, self.z)

    def majImage(self):
        """met a jour la taille, la position et l'orientation de l'image"""
        if len(self.decor.img["nom"]) > 0:
            pix = QPixmap(QString.fromUtf8("img\\"+self.decor.img["nom"]))
            if self.decor.img["masqueAuto"]:
                pix.setMask(pix.createHeuristicMask())
            if not pix.isNull():
                if not self.pixGraphique:
                    self.pixGraphique = QGraphicsPixmapItem()
                    self.pixGraphique.setZValue(10) 
                    if pix.height() >= pix.width():
                        pix = pix.scaledToHeight(self.plateau.hCase*0.9, Qt.SmoothTransformation)
                    else:
                        pix = pix.scaledToWidth(self.plateau.hCase*0.9, Qt.SmoothTransformation)
                    self.largeurOriginale = pix.width()
                    self.hauteurOriginale = pix.height()
                    pix = pix.scaled((self.decor.img["kx"]/10)*pix.width(), \
                                     (self.decor.img["ky"]/10)*pix.height(), \
                                      Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
                    self.pixGraphique.setPixmap(pix)

                deltaX = self.decor.img["dx"] + 0.5*(self.plateau.hCase*1.1544 - self.largeurOriginale)
                deltaY = self.decor.img["dy"] + 0.5*(self.plateau.hCase - self.hauteurOriginale)
                if self.decor.img["nom"] != self.decor.logo and self.decor.img["pivote"] == True:
                    self.pixGraphique.setParentItem(self.polygoneGraphique)
                else:
                    self.pixGraphique.setParentItem(self)
                self.pixGraphique.setRotation(self.decor.img["rotation"])
                self.pixGraphique.setPos(QPointF(deltaX, deltaY))            

    def majNbRotations(self, nbRotations):
        self.nbRotations = nbRotations
        if self.plateau.formeCases == "H":
            rotationsTour = 6
        else:
            rotationsTour = 4
            
        if self.nbRotations >= 0:
            self.nbRotations = self.nbRotations % rotationsTour
        else:
            self.nbRotations = self.nbRotations % (-rotationsTour)

    def majPosition(self, position, nbRotations = 0):
        for coord in self.forme.listeCases((self.position[0],self.position[1]), self.nbRotations):
            self.plateau.cases[coord].majOccupation(self)
        self.position = position
        self.majNbRotations(nbRotations)
        self.majAspectGraphique()
        
    def afficheOmbreSelection(self, actif = False):
        if actif:
            self.shadow.setXOffset(3) 
            self.shadow.setYOffset(3)
        else:
            self.shadow.setXOffset(1) 
            self.shadow.setYOffset(2)  

    def supprimer(self):
        """'deconnecte' les items enfants avant de supprimer du pion"""
        if self.pixGraphique != None:
            self.pixGraphique.prepareGeometryChange()
            self.pixGraphique.setParentItem(None)
        self.polygoneGraphique.prepareGeometryChange()
        self.polygoneGraphique.setParentItem(None)
        self.plateau.removeItem(self)
        self.plateau = None

    ##################

    ###############   evenements clavier et souris    ##############         
    def boundingRect(self):
        return QRectF()

    def hoverEnterEvent(self, event):
        """evenement lors du survol de la souris (en entree)""" 
        self.plateau.caseSurvol(self.plateau.cases[self.position])
        self.plateau.pionDecorSurvol(self.numero)

    def hoverLeaveEvent(self, event):
        """evenement lors du survol de la souris (en sortie)"""
        self.plateau.pionDecorSurvol(None)

    def mousePressEvent(self, event):
        """evenement lors du clic souris"""
        if event.button() == 1: #sur clic gauche  
            #en mode creation, on peut selectionner le decor pour le deplacer ou le supprimer
            if self.plateau.modePrincipal == "creation":
                 self.plateau.pionDecorSaisir(self.numero)
                 event.accept()
        else:
            event.ignore()            
            
    
    #######################
