# -*- coding: utf-8 -*-
"""outils de gestion de l'occupation de l'espace sur le plateau
- la matrice occupation [mO] est de la forme {(x,y):{z0: 0, z1:N, z2:N, z3:N...}} 
ou N est le numero du pion, et 0 le niveau du sol, et zi est l'altitude ABSOLUE de la case
"""

class Occupation():
    def __init__(self):
        self._mO = {}
        
    def majMo(self, mo):
        self._mO = mo

    def mo(self):
        return self._mO
        
    def generer(self, plateau):
        """genere la matrice"""
        self._mO = {key:{value.altitude:0} for key, value in plateau.cases.items()}

        for num in plateau.pions:
            pion = plateau.pions[num]
            for x, y in pion.forme.listeCases(pion.position, pion.nbRotations):
                for z in range(1, pion.hauteur + 1):
                    zAbs = (plateau.cases[(x,y)].altitude + pion.z + z)
                    self._mO[(x,y)][zAbs] = num
            
    
    def maj(self, *args):
        """met a jour l'occupation, selon ce qui est apsse en parametre:
           - si (liste de coord, altitude), met a jour l'altitude des cases correspondantes et celle des pions qui les occupent
           - si (pion), met a jour l'occupation en fonction de sa nouvelle situation (deplace, pivote, supprime, nouveau)
           - si (plateau), regenere
        """   
        if len(args) == 1:
            if args[0].__class__.__name__ == "Plateau":
                self.generer(args[0])
            
            else:
                print "pion"
        
        elif len(args) == 2:   
            self._majAltitudes(args[0], args[1])
             
    def _altitudeCase(self, coord):
        for key, val in self._mO[coord].items():
            if val == 0: return key
        return 0
       
    def _majAltitudes(self, lstCoord, altitude):
        
        for coord in lstCoord:
            ancien = self._mO[coord]
            self._mO[coord] = {}
            
            for z in ancien:
                if ancien[z] == 0:
                    dz = altitude - z

            for z in ancien:
                self._mO[coord][(z + dz)] = ancien[z]

    def _majPion(self, pion):
        #on efface son ancienne occupation
        num = pion.numero
        for coord in self._mO:
            for key, val in self._mO[coord].items():
                if val == num: del self._mO[coord][key]
        
        #on l'ajoute la ou il se trouve maintenant
        for x, y in pion.forme.listeCases(pion.position, pion.nbRotations):
            for z in range(1, pion.hauteur + 1):
                zAbs = (self._altitudeCase((x,y)) + pion.z + z)
                self._mO[(x,y)][zAbs] = num                    

    def occupant(self, coord, zAbs = None):
        """renvoie l'occupant de la case a l'altitude precisee, a celle du sol sinon"""
        if not zAbs: zAbs = self._altitudeCase(coord)
        return (self._mO[coord][zAbs] if zAbs in self._mO[coord] else None)
        
    def estOccupee(self, coord, zAbs = None):
        return (self.occupant(coord, zAbs) != None)   

    
    

o = Occupation()
o.majMo({(0,0): {0: 0, 2: 1}, (1,1): {0: 0, 2: 1}})
o.majAltitudes([(1,1)], 10)
print o.mo()