# -*- coding: iso-8859-1 -*-
# Copyright 20003 - 2008: Julien Bourdaillet (julien.bourdaillet@lip6.fr), Jean-Gabriel Ganascia (jean-gabriel.ganascia@lip6.fr)
# This file is part of MEDITE.
#
#    MEDITE is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    MEDITE is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with Foobar; if not, write to the Free Software
#    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
#----------------------------------------------------------------------------
# Nom:          resultatAppli.py
# Objet:        Classe qui regroupe les donnees d'une comparaison d'un couple
#               de etats  ( utilisee par l'interface )              
#----------------------------------------------------------------------------
import sys,logging,contract,Utile.decodage
import numpy
import planTravail
import MediteAppli.utile
contract.checkmod(__name__)

class Resultat(object):
    """ Classe qui retourne le resulat obtenu apres comparaison de deux etats """    
    def __init__(self, pLI, pLS, pLD, pLR, pLgSource, pTextes, pBlocsCommuns, pairesBlocsDepl):
        self._li = pLI # liste des insertions
        self._ls = pLS # liste des suppression
        self._ld = pLD # liste des deplacements
        self._lr = pLR # liste des remplacements
        self._lgTexteS = pLgSource # longueur du texte source
        self._textes = pTextes # les deux etats concatenes
        self._blocsCom = pBlocsCommuns   # blocs communs    
        self._pairesBlocsDepl = pairesBlocsDepl #paires de blocs déplacés
        
    def getListeInsertions(self):
        return self._li
    
    def getListeSuppressions(self):
        return self._ls

    def getListeDeplacements(self):
        return self._ld

    def _filtre(self,liste,deb,fin):
        """ Renvoie la sous-liste des items de liste compris entre deb et fin 
        
        pre: 0<=deb<fin #<=len(self._textes)
        post: isinstance(__return__,list)
            forall([x in __return__],deb<=x[0]<=x[1]<=fin)
        """
        res=[]
        for x in liste:
            if deb <= x[0] < x[1] <= fin:
                res.append(x)
        return res
     	 ###test
    def shiba(self):
        return 'test'
        
    def getListeDeplacementsT1(self):
        return self._filtre(self._ld,0,self._lgTexteS)
    
    def getListeDeplacementsT2(self):
        return self._filtre(self._ld,self._lgTexteS,len(self._textes))
        
    def getListeRemplacements(self):
        return self._lr

    def getListeRemplacementsT1(self):
        return self._filtre(self._lr,0,self._lgTexteS)
    
    def getListeRemplacementsT2(self):
        return self._filtre(self._lr,self._lgTexteS,len(self._textes))
        
    def getTextesConcatenes(self):
        return self._textes

    def getLgSource(self):
        return self._lgTexteS

    def getBlocsCommuns(self):
        return self._blocsCom
        
    def getBlocsCommunsT1(self):
        return self._filtre(self._blocsCom,0,self._lgTexteS)
        
    def getBlocsCommunsT2(self):
        return self._filtre(self._blocsCom,self._lgTexteS,len(self._textes))        

    def getPairesBlocsDeplaces(self):
        return self._pairesBlocsDepl
        
    def setPairesBlocsDeplaces(self,liste):
        self._pairesBlocsDepl = liste
        
    def toString_(self):
        s = u"Type RESULTAT \nInsertions : "
        for i in self._li:
            s += unicode(i).encode("iso-8859-2", "replace")+u" / "
        s += u"\nSuppressions : "
        for i in self._ls:
            s += unicode(i).encode("iso-8859-2", "replace")+u" / "
        s += u"\nDéplacements : "
        for i in self._ld:
            s += unicode(i).encode("iso-8859-2", "replace")+u" / "
        s += "\nRemplacements  : "
        if self._lr != []:
          for i in self._lr:
            s += unicode(i).encode("iso-8859-2", "replace")+" / "
         
#       s2,x,y = Utile.decodage.decode_string_heuristically(self._texteCible.toxml())
#       s += s2
#       s += unicode(self._texteCible).encode("iso-8859-2", "replace")
        s += "\nBlocs communs : "
        if self._blocsCom != []:
          for i in self._blocsCom:
            s += "["
            for ii in i:
             #iii,x,y=Utile.decodage.decode_string_heuristically(ii)
             s += str(ii)+"/"    
            s +="]"
        s += "\n lgTexteSource  : "+str(self._lgTexteS)
        sys.stderr.write(unicode(s).encode("iso-8859-2", "replace"))
        sys.stderr.flush()
        
    def toString(self):
        """Retourne le texte correspondant aux listes de blocs"""
        f = lambda res,l: [res.append(self.getTextesConcatenes()[x[0]:x[1]]) for x in l]
        def f(res,l):
            """Fonction anonyme permettant de traiter les paires de blocs déplacés"""
            for x in l:
                if isinstance(x,tuple):#les paires de Bloc deplacé sont des tuples
                    res.extend(['(', self.getTextesConcatenes()[x[0][0]:x[0][1]],
                                '/',self.getTextesConcatenes()[x[1][0]:x[1][1]],')'])    
                else:# bloc normal
                    res.extend(['(',self.getTextesConcatenes()[x[0]:x[1]],')'])
        return self.__str(f)
        
    def __str__(self):
        """Retourne uniquement les listes de blocs"""
        f = lambda res,l: [res.append(str(x)) for x in l]
        return "longueur T1="+str(self._lgTexteS)+"\n"+self.__str(f)
        
    def __str(self,f):    
        """Fonction privée construisant la chaine à retourner
        
        f est une fonction concaténant de la manière souhaitée le bloc courant
        
        pre: callable(f)"""
        res = ['BC :']
        #f = lambda l: [res.append(str(x)) for x in l]
        f(res,self.getBlocsCommuns())
        res.append('\nDEP: ')
        f(res,self.getListeDeplacements())
        res.append('\nPDEP: ')
        f(res,self.getPairesBlocsDeplaces())
        res.append('\nSUP: ')
        f(res,self.getListeSuppressions())
        res.append('\nINS: ')
        f(res,self.getListeInsertions())
        res.append('\nREMP: ')
        f(res,self.getListeRemplacements())
        return ''.join(res)
        
    def __xor__(self,res):
        """Différence symétrique
        
        Extrait les intervalles de chaque liste présents dans l'un ou l'autre des 2 objets
        mais pas dans les 2, cad une différence symétrique de chaque liste.
        
        pre: isinstance(res,Resultat) """
        assert self.getTextesConcatenes() == res.getTextesConcatenes() # on traite bien le meme texte
        assert self.getLgSource() == res.getLgSource()
        bc = self.__diff_sym(self.getBlocsCommuns(), res.getBlocsCommuns())
        dep = self.__diff_sym(self.getListeDeplacements(), res.getListeDeplacements())
        pdep = self.__diff_sym(self.getPairesBlocsDeplaces(), res.getPairesBlocsDeplaces())
        ins = self.__diff_sym(self.getListeInsertions(), res.getListeInsertions())
        sup = self.__diff_sym(self.getListeSuppressions(), res.getListeSuppressions())
        remp = self.__diff_sym(self.getListeRemplacements(), res.getListeRemplacements())
        
        return Resultat(ins, sup, dep, remp, self.getLgSource(), 
                        self.getTextesConcatenes(),bc, pdep)
        
    def __diff_sym(self,L1,L2):
        """Différence symétrique effective de 2 listes: (L1 - L2) U (L2 - L1) """
        tool = MediteAppli.utile.Utile()
        res = []
        for x in L1:
            if x not in L2: res = tool.addition_intervalle(res,x) # addition sans fusion
        for x in L2:
            if x not in L1: res = tool.addition_intervalle(res,x)
        return res            
    
    def __sub__(self,res):
        """Différence: objet courant - res"""
        assert self.getTextesConcatenes() == res.getTextesConcatenes() # on traite bien le meme texte
        assert self.getLgSource() == res.getLgSource()
        bc = self.__diff(self.getBlocsCommuns(), res.getBlocsCommuns())
        dep = self.__diff(self.getListeDeplacements(), res.getListeDeplacements())
        pdep = self.__diff(self.getPairesBlocsDeplaces(), res.getPairesBlocsDeplaces())
        ins = self.__diff(self.getListeInsertions(), res.getListeInsertions())
        sup = self.__diff(self.getListeSuppressions(), res.getListeSuppressions())
        remp = self.__diff(self.getListeRemplacements(), res.getListeRemplacements())
        
        return Resultat(ins, sup, dep, remp, self.getLgSource(), 
                        self.getTextesConcatenes(),bc, pdep)
    def __diff(self,L1,L2):
        """Différence effective de 2 listes: (L1 - L2)"""
        tool = MediteAppli.utile.Utile()
        res = []
        for x in L1:
            if x not in L2: res = tool.addition_intervalle(res,x) # addition sans fusion
        return res
    ###########################################
    ## POUR CHANGER LE RESULTAT MANUELLEMENT ##
    ###########################################
    def enleverChangement(self,element,txt):
        insertions=self._li
        suppressions=self._ls
        deplacements=self._ld
        remplacements=self._lr
        blocsCommuns=self._blocsCom    
        blocsDeplaces=self._pairesBlocsDepl
        if txt == 1:
            ###SUPPR
            if element in suppressions :
                suppressions.remove(element)

                            

            ###REMPL
            if element in remplacements :
                ln=len(remplacements)/2
                item=remplacements.index(element)
                remplacements.remove(element)
                del remplacements[item+ln-1]

                
            ###DEPL
            if element in deplacements:
                paires = [x for x in blocsDeplaces if x[0]==element]
                correspondants = [ x[1] for x in  paires]
                paires = [x for x in blocsDeplaces if x[1] in correspondants]
                elements = [x[0] for x in paires ]
                elements = list(set(elements))
                for x in elements :
                    deplacements.remove(x)
                for x in paires :
                    blocsDeplaces.remove(x)
                for x in correspondants :
                    deplacements.remove(x)


        elif txt == 2:
            deb,fin=element
            element = (deb+self.getLgSource(),fin+self.getLgSource())
            ###INSERT
            if element in insertions :
                #print 'avant : ',insertions
                insertions.remove(element)
                #print 'apres : ',insertions

                
            ###REMPL
            if element in remplacements :
                ln=len(remplacements)/2
                item=remplacements.index(element)
                remplacements.remove(element)
                del remplacements[item-ln]

                
            ###DEPL
            if element in deplacements:
                paires = [x for x in blocsDeplaces if x[1]==element]
                #print paires
                correspondants = [ x[0] for x in  paires]
                paires = [x for x in blocsDeplaces if x[0] in correspondants]
                elements = [x[1] for x in paires]
                elements = list(set(elements))
                print elements
                for x in elements:
                    deplacements.remove(x)
                for x in paires :
                    blocsDeplaces.remove(x)
                for x in correspondants :
                    deplacements.remove(x)

            
     

    def ajouterInsertion(self,element):
        self.enleverChangement(element,2)
        deb,fin=element
        self._li.append((deb+self.getLgSource(),fin+self.getLgSource()))
        self._li.sort()

    def ajouterSuppression(self,element):
        self.enleverChangement(element,1)
        self._ls.append(element)
        self._ls.sort()

    def ajouterDeplacement(self,element,txt):
        deb,fin=element
        self.enleverChangement(element,txt)
        if txt == 1 :
            self._ld.append(element)
        elif txt == 2 :
            self._ld.append((deb+self.getLgSource(),fin+self.getLgSource()))
        self._ld.sort()

    def ajouterRemplacement(self,element,txt):
        self.enleverChangement(element,txt)
        deb,fin=element
        if txt == 1 :
            self._lr.append(element)
        elif txt == 2 :
            self._lr.append((deb+self.getLgSource(),fin+self.getLgSource()))
        self._lr.sort()
        
        
        
class Resultat__(Resultat): #buggé
    def __init__(self, pLI, pLS, pLD, pLR, pLgSource, pTextes, pBlocsCommuns, pairesBlocsDepl):
        ResultatListe.__init__(self,[], [], [], [], pLgSource, pTextes, [], [])
        self._li = self.__listeToTab(pLI) 
        self._ls = self.__listeToTab(pLS) 
        self._ld = self.__listeToTab(pLD) 
        self._lr = self.__listeToTab(pLR) 
        self._blocsCom = self.__listeToTab(pBlocsCommuns)   
        self._pairesBlocsDepl = self.__listeToTab(pairesBlocsDepl) 
        
    def __listeToTab(self, liste):
        if isinstance(liste,list):
            tab = numpy.array(liste)#, Numeric.Int16)
        else: tab = liste # c deja un array
        return tab
        
    def getListeInsertions(self):
        return self._li.tolist()
    def getListeSuppressions(self):
        return self._ls.tolist()
    def getListeDeplacements(self):
        return self._ld.tolist()
    def getListeDeplacementsT1(self):
        return self._filtre(self._ld,0,self._lgTexteS)
    def getListeDeplacementsT2(self):
        return self._filtre(self._ld,self._lgTexteS,len(self._textes))
    def getListeRemplacements(self):
        return self._lr.tolist()
    def getListeRemplacementsT1(self):
        return self._filtre(self._lr,0,self._lgTexteS)
    def getListeRemplacementsT2(self):
        return self._filtre(self._lr,self._lgTexteS,len(self._textes))
    def getBlocsCommuns(self):
        return self._blocsCom.tolist()
    def getBlocsCommunsT1(self):
        return self._filtre(self._blocsCom,0,self._lgTexteS)
    def getBlocsCommunsT2(self):
        return self._filtre(self._blocsCom,self._lgTexteS,len(self._textes))        
    def getPairesBlocsDeplaces(self):
        return self._pairesBlocsDepl.tolist()
    def setPairesBlocsDeplaces(self,liste):
        self._pairesBlocsDepl = self.__listeToTab(liste)
       
class Informations(object):
    def __init__(self, pVersionSource, pEtatSource, pVersionCible, pEtatCible,
                 pParametres, pTransformations, pCommentaire = None):
        """ pre: isinstance(pVersionSource,str) and isinstance(pEtatSource,str) 
                 isinstance(pVersionCible,str) and isinstance(pEtatCible,str) 
                 isinstance(pParametres,planTravail.Parametres)  
                 isinstance(pTransformations,Transformations) 
                 (pCommentaire==None or isinstance(pCommentaire,Commentaire)) """
        self.__versionSource = pVersionSource
        self.__etatSource = pEtatSource 
        self.__versionCible = pVersionCible
        self.__etatCible = pEtatCible
        self.__parametres = pParametres
        self.__transformations = pTransformations
        self.__commentaire = pCommentaire

    # Methodes d'acces aux attributs
    def getVersionSource(self):
        return self.__versionSource
    def getEtatSource(self):
        return self.__etatSource
    def getVersionCible(self):
        return self.__versionCible
    def getEtatCible(self):
        return self.__etatCible
    def getParametres(self):
        return self.__parametres
    def getTransformations(self):
        return self.__transformations
    def getCommentaire(self):
        return self.__commentaire
    
    def existeCommentaire(self):
        """ Verifie si le commentaire existe """
        if self.__commentaire == None:
            return 1    ## FAUX
        else:
            return 0    ## VRAI
    def existeTransformations(self):
        """ Verifie si les transformations existent """
        if self.__transformations == None:
            return 1    ## FAUX
        else:
            return 0    ## VRAI        
    # Methode de modification d'attribut
    # Seul le commentaire est modifiable
    def setCommentaire(self, pCommentaire):
        self.__commentaire = pCommentaire
        
        
class Transformations(object):
    def __init__(self, pInsertions, pSuppressions, pDeplacements, pRemplacements, pTexteSource, pTexteCible):
        ## les attributs ci-dessous sont des listes de sequence de caracteres
        self.__insertions =pInsertions
        self.__suppressions =pSuppressions
        self.__deplacements = pDeplacements
        self.__remplacements = pRemplacements
        ## les attributs ci-dessous sont des noeuds xml
        self.__texteSource = pTexteSource
        self.__texteCible = pTexteCible

    def getInsertions(self):
        return self.__insertions

    def getSuppressions(self):
        return self.__suppressions

    def getDeplacements(self):
        return self.__deplacements

    def getRemplacements(self):
        return self.__remplacements

    def getSource(self):
        return self.__texteSource

    def getCible(self):
        return self.__texteCible
        
    def toString(self):
        s = u"Type TRANSFORMATION\nInsertions : "
        for i in self.__insertions:
            s += i+u" / "
        s += u"\nSuppressions : "
        for i in self.__suppressions:
            s += i+u" / "
        s += u"\nDéplacements : "
        for i in self.__deplacements:
            s += i+u" / "
        s += "\nRemplacements  : "
        if self.__remplacements:
          for i in self.__remplacements:
            s += unicode(i).encode("iso-8859-2", "replace")+" / "
        s += "\nTexteSource : "
        #s += unicode(self.__texteSource.toxml()).encode("iso-8859-2", "replace")
        s2,x,y = Utile.decodage.decode_string_heuristically(self.__texteSource.toxml())
        s += s2
#       if self.__texteSource != []:
#         for i in self.__texteSource:
#           s += unicode(i).encode("iso-8859-2", "replace")+" / "    
        s += "\nTexteCible : "
        s2,x,y = Utile.decodage.decode_string_heuristically(self.__texteCible.toxml())
        s += s2
#       s += unicode(self.__texteCible).encode("iso-8859-2", "replace")
#       if self.__texteCible != []:
#         for i in self.__texteCible:
#           s += unicode(i).encode("iso-8859-2", "replace")+" / "    
        sys.stderr.write(unicode(s).encode("iso-8859-2", "replace"))
        sys.stderr.flush()
        
        
class Commentaire(object):
    def __init__(self, pCommentaire):
        self.__commentaire = pCommentaire
    # Methode d'acces a l'attribut
    def getCommentaire(self):
        return self.__commentaire
    # Methodes de modification de l'attribut
    # Methode qui remplace le commentaire
    def setCommentaire(self, pCommentaire):
        self.__commentaire = pCommentaire
    # Methode qui ajoute du texte au commentaire
    def addCommentaire(self, pCommentaire):
        self.__commentaire += ' ' + pCommentaire