# -*- 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

import shelve,os,os.path,shutil,dircache
import Utile.constantesDonnees, Utile.exceptionsDonnees
import FInfoManager
from Utile.exceptionsDonnees import *

class DGManager(object):
    def getDirAuteur(self,nomAuteur):
        """ Renvoie le dossier associé à un auteur 
        pre: isinstance(nomAuteur,str) """
        return os.path.join(Utile.constantesDonnees.DG_REP, nomAuteur)
    def getFileAuteur(self,nomAuteur):
        """ Renvoie le nom du fichier stockant l'objet auteur 
        pre: isinstance(nomAuteur,str) """
        return os.path.join(self.getDirAuteur(nomAuteur),Utile.constantesDonnees.DG_AUTEUR_FILE)        
    def getDG(self,nomAuteur,nomOeuvre):
        """ Renvoie le DG associé à un auteur et une oeuvre
        pre: isinstance(nomAuteur,str) and isinstance(nomOeuvre,str)"""
        return os.path.join(self.getDirAuteur(nomAuteur),nomOeuvre) 
    def existeAuteur(self,nomAuteur):
        """ Vrai si l'auteur existe
        pre: isinstance(nomAuteur,str)
        post: isinstance(__return__,bool) """
        lAuteurs = os.listdir(Utile.constantesDonnees.DG_REP)
        if nomAuteur in lAuteurs: return True
        else: return False
    def addAuteur(self,auteur):
        """ Crée un dossier nomAuteur 
        pre: isinstance(auteur,Auteur) """
        if (self.existeAuteur(auteur.getNom())):
            raise AuteurDejaExistant('L\'auteur "'+auteur.getNom()+'" existe deja.',auteur)
        dirAuteur = self.getDirAuteur(auteur.getNom())
        if not os.path.isdir(dirAuteur):
            os.mkdir(dirAuteur)
        fileAuteur = self.getFileAuteur(auteur.getNom())
        # stocke l'objet auteur dans 1 fichier
        dicAuteur = shelve.open(fileAuteur)
        dicAuteur[Utile.constantesDonnees.DG_AUTEUR_CLE] = auteur
        dicAuteur.close()
    def delAuteur(self,nomAuteur):
        """ Supprime un dossier nomAuteur 
        pre: isinstance(nomAuteur,str) """
        dirAuteur = self.getDirAuteur(nomAuteur)
        if os.path.isdir(dirAuteur):
            self.recDelFolder(dirAuteur)  
    def getAuteur(self,nomAuteur):
        """ Renvoie l'objet Auteur associé à nomAuteur ou en crée si il n'existe pas 
        pre: isinstance(nomAuteur,str) 
        post: isinstance(__return__,Auteur)"""
        fileAuteur = self.getFileAuteur(nomAuteur)
        if os.path.isfile(fileAuteur):
            dicAuteur = shelve.open(fileAuteur)
            auteur = dicAuteur[Utile.constantesDonnees.DG_AUTEUR_CLE]
            dicAuteur.close()
        else: auteur = Auteur(nomAuteur)
        return auteur
    def getListeAuteurs(self):
        """ Renvoie une liste des noms des dossiers auteurs 
        post: isinstance(__return__,list) """
        dirAuteurs = self.getDirAuteur("")
        ld = dircache.listdir(dirAuteurs)
        ld = filter(lambda x: x != "CVS" and x!= Utile.constantesDonnees.DG_AUTEUR_FILE, ld)
        return ld
        
    def addOeuvre(self,nomAuteur,oeuvre):
        """ Crée un DG 
        pre: isinstance(nomAuteur,str) and isinstance(oeuvre,Oeuvre) """
        nomDG = self.getDG(nomAuteur,oeuvre.getTitre())
        if not os.path.isdir(nomDG):
            os.mkdir(nomDG)
        auteur = self.getAuteur(nomAuteur)
        fim = FInfoManager.FInfoManager(auteur,oeuvre)
        fim.creerFichierInformations()
        
    def delOeuvre(self,nomAuteur,nomOeuvre):
        """ Supprime un DG 
        pre: isinstance(nomAuteur,str) and isinstance(nomOeuvre,str) """
        nomDG = self.getDG(nomAuteur,nomOeuvre)
        if os.path.isdir(nomDG):
            self.recDelFolder(nomDG)
    def getListeOeuvresAuteur(self,nomAuteur):
        """ Renvoie une liste des oeuvres d'un auteur
        pre: isinstance(nomAuteur,str)
        post: isinstance(__return__,list) """
        dirAuteur = self.getDirAuteur(nomAuteur)
        ld = dircache.listdir(dirAuteur)
        ld = filter(lambda x: x != "CVS" and x!='.cvsignore' and x!= Utile.constantesDonnees.DG_AUTEUR_FILE, ld)
        return ld  
        
        
    def loadDG(self,nomAuteur,nomOeuvre):
        pass        
        
    def addVersion(self,nomAuteur,nomOeuvre,nomVersion):
        """ Crée une version
        pre: isinstance(nomAuteur,str) and isinstance(nomOeuvre,str) and isinstance(nomVersion,str)"""
        nomDG = self.getDG(nomAuteur,nomOeuvre)
        dirVersion = os.path.join(nomDG,nomVersion)
        if not os.path.isdir(dirVersion):
            os.mkdir(dirVersion)
        fim = FInfoManager.FInfoManager(Auteur(nomAuteur),Oeuvre(nomOeuvre))
        fim.creerVersion(nomVersion)
    def delVersion(self,nomAuteur,nomOeuvre,nomVersion):
        """ Supprime une version
        pre: isinstance(nomAuteur,str) and isinstance(nomOeuvre,str) and isinstance(nomVersion,str)"""
        nomDG = self.getDG(nomAuteur,nomOeuvre)
        dirVersion = os.path.join(nomDG,nomVersion)
        if os.path.isdir(dirVersion):
            self.recDelFolder(dirVersion)
        fim = FInfoManager.FInfoManager(Auteur(nomAuteur),Oeuvre(nomOeuvre))
        fim.supprimerVersion(nomVersion)    
        
    def addEtat(self,nomAuteur,nomOeuvre,nomVersion,fileEtat,etatPere=""):
        """ Ajoute un état à partir du fichier fileEtat dans la version nomVersion
        et ayant éventellement un etatPere
        pre: isinstance(nomAuteur,str) and isinstance(nomOeuvre,str) and \
             isinstance(nomVersion,str) and isinstance(fileEtat,str) and isinstance(etatPere,str)"""
        (filepath, nomEtat) = os.path.split(fileEtat) 
        nomDG = self.getDG(nomAuteur,nomOeuvre)
        dirVersion = os.path.join(nomDG,nomVersion)
        cheminEtat=os.path.join(dirVersion,nomEtat)
        self.__copieFichier(fileEtat,cheminEtat)
        fim = FInfoManager.FInfoManager(Auteur(nomAuteur),Oeuvre(nomOeuvre))
        fim.creerEtat(nomVersion, nomEtat, etatPere)
    
    def delEtat(self,nomAuteur,nomOeuvre,nomVersion,nomEtat):
        """ Supprime un état 
        pre: isinstance(nomAuteur,str) and isinstance(nomOeuvre,str) and \
             isinstance(nomVersion,str) and isinstance(nomEtat,str) """
        fim = FInfoManager.FInfoManager(Auteur(nomAuteur),Oeuvre(nomOeuvre))
        lEtatsFils = fim.getListeEtatsFils(nomVersion,nomEtat)
        nomDG = self.getDG(nomAuteur,nomOeuvre)
        dirVersion = os.path.join(nomDG,nomVersion)
        cheminEtat=os.path.join(dirVersion,nomEtat)
        self.recDelFolder(cheminEtat)
        if lEtatsFils != None and lEtatsFils != []:
            for etatFils in lEtatsFils: 
                cheminEtat=os.path.join(dirVersion,etatFils)
                self.recDelFolder(cheminEtat)  
        fim.supprimerEtat(nomVersion, nomEtat) 
        
    def getListeVersionsDG(self,nomAuteur,nomOeuvre):
        """ Renvoie une liste des versions d'un DG
        pre: isinstance(nomAuteur,str) and isinstance(nomOeuvre,str) 
        post: isinstance(__return__,list) """
        nomDG = self.getDG(nomAuteur,nomOeuvre)
        ld = dircache.listdir(nomDG)
        ld = filter(lambda x: x != "CVS" and x != '.cvsignore' and x!= Utile.constantesDonnees.DG_FILE_INFO, ld)
        return ld  
    def getListeEtatsVersion(self,nomAuteur,nomOeuvre,nomVersion):
        """ Renvoie une liste des etats d'une  version
        pre: isinstance(nomAuteur,str) and isinstance(nomOeuvre,str) and isinstance(nomVersion,str)
        post: isinstance(__return__,list) """
        nomDG = self.getDG(nomAuteur,nomOeuvre)
        path = os.path.join(nomDG,nomVersion)
        #if not os.path.isdir(path): return [] 
        ld = dircache.listdir(path)
        ld = filter(lambda x: x != "CVS" and x != '.cvsignore', ld)
        return ld 
        
    def __copieFichier(self,pSource,pDestinataire):
        """ Methode privee qui sert a la copie d'un fichier """
        if os.path.isfile(pDestinataire):
            raise Utile.exceptionsDonnees.FichierExistant(pSource,pDestinataire)
        else: shutil.copyfile(pSource,pDestinataire)

    def importTextFolder(self,nomAuteur,nomOeuvre,textFolder):  
        """ Importe un répertoire d'états 
        pre: isinstance(nomAuteur,str) and isinstance(nomOeuvre,str) and isinstance(textFolder,str)  """
        (filepath, nomVersion) = os.path.split(textFolder)
        # création de la version du nom du répertoire
        self.addVersion(nomAuteur,nomOeuvre,nomVersion)
        for fichier in os.listdir(textFolder):
            if os.path.isfile(os.path.join(textFolder,fichier)):
                self.addEtat(nomAuteur,nomOeuvre,nomVersion,os.path.join(textFolder,fichier))
              
    def getEtatPath(self,nomAuteur,nomOeuvre,nomVersion,nomEtat):
        """ Renvoie le fichier associé à un état 
        pre: isinstance(nomAuteur,str) and isinstance(nomOeuvre,str) and \
             isinstance(nomVersion,str) and isinstance(nomEtat,str) 
        post: isinstance(__return__,str) """
        nomDG = self.getDG(nomAuteur,nomOeuvre)
        dirVersion = os.path.join(nomDG,nomVersion)
        cheminEtat = os.path.join(dirVersion,nomEtat)
        return cheminEtat
        
    def recDelFolder(self,folder):
        """Efface récursivement un dossier et tout ce qu'il contient
        pre: isinstance(folder,str) or isinstance(folder,unicode) """
        if os.path.isdir(folder):
            liste = os.listdir(folder)
            for i in liste :
                self.recDelFolder(os.path.join(folder,i))
            os.rmdir(folder)
        else:
            os.remove(folder)                
	
class Auteur(object):
    def __init__(self, pNom, pPrenom="", pNais="", pDeces=""):
        self.__nom = pNom
        self.__prenom = pPrenom
        self.__naissance = pNais
        self.__deces = pDeces
    def getNom(self):
        return self.__nom
    def getPrenom(self):
        return self.__prenom
    def getNaissance(self):
        return self.__naissance
    def getDeces(self):
        return self.__deces
    def equals(self,auteur):
        """pre: isinstance(auteur,Auteur) """
        return (self.getNom()==auteur.getNom() and self.getPrenom()==auteur.getPrenom() and
        self.getNaissance()==auteur.getNaissance() and self.getDeces()==auteur.getDeces())

class Oeuvre(object):
    def __init__(self, pTitre, pEdition="", pPublication=""):
        self.__titre = pTitre
        self.__edition = pEdition
        self.__publication = pPublication
    def getTitre(self):
        return self.__titre
    def getEdition(self):
        return self.__edition
    def getPublication(self):
        return self.__publication