package personne;

import java.util.Iterator;
import java.util.HashMap;
import java.io.*;


/**
 * Classe qui gère un ensemble de Personne via 6 op�rations.
 */
public class DataManagerPersonne implements IPersonne {

    /**
     * Dernier identifiant utilis� pour une personne. A chaque nouvelle personne, on 
     * l'incr�mante de 1 et on l'utilise pour l'identifiant de la personne. Permet
     * tr�s facilement de g�rer un identifiant unique.
     */
    protected int dernierIdentifiant = 0;
    /**
     * Hashmap qui contient les personnes et leur identifiant
     * L'identifiant d'une personne est donc en double : dans la personne
     * et en tant que clé dans la hashmap
     */
    protected HashMap<Integer, Personne> personnes = new HashMap<Integer, Personne>();

    /**
     * La classe HashMap ne permet pas de r�cup�rer directement la cl� � partir de l'objet
     * On passera donc par cette m�thode d�di�e
     */
    protected synchronized Integer getPersonneKey(Personne p) {
        Iterator<Integer> iter = personnes.keySet().iterator();
        Integer id;
        while (iter.hasNext()) {
            id = iter.next();
            if ((personnes.get(id)).equals(p)) {
                return id;
            }
        }
        // rien trouv� : retourne null
        return null;
    }

    /**
     * Sauvegarde la liste des personnes. Pour faire simple, on ne prend pas 
     * en compte les erreurs survenues.
     */
    public synchronized void enregistrerDonnees() {
        try {
            FileOutputStream file = new FileOutputStream("ListePersonnes.ser");
            ObjectOutputStream output = new ObjectOutputStream(file);
            output.writeObject(personnes);
            output.writeObject(new Integer(dernierIdentifiant));
            output.close();
            file.close();
        } catch (Exception e) {
            System.err.println("[Enregistrement] probl�me pendant �criture de ListePersonnes.ser : " + e);
        }
    }

    /**
     * Ajoute une personne dans la liste et retourne son identificateur
     * @param nom le nom de la personne
     * @param adresse l'adresse de la personne
     * @return l'identificateur de la personne
     */
    public synchronized int addPersonne(String nom, Adresse adr) {
        // génére l'identifiant de la nouvele personne
        dernierIdentifiant++;
        Personne p = new Personne();
        p.setIdPersonne(dernierIdentifiant);
        p.setNom(nom);
        p.setAdresse(adr);
        personnes.put(new Integer(dernierIdentifiant), p);
        // on sauvegarde la nouvelle liste car elle a �t� modifi�e
        enregistrerDonnees();
        return dernierIdentifiant;
    }

    /**
     * R�cup�re une personne dans la liste � partir de son
     * identifiant.
     * @param id l'idenfiant de la personne � r�cup�rer
     * @throws InvalidIdException dans le cas o� l'identifiant
     * n'est attribu� � aucune personne
     */
    public synchronized Personne getPersonne(int id) {
        if (!(personnes.containsKey(new Integer(id)))) {
            return null;
        }
        return (personnes.get(new Integer(id)));
    }

    /**
     * R�cup�re l'identifiant d'une personne. 
     * @param p la personne dont on veut r�cup�rer l'identifiant
     * @return l'identificateur de la personne. Si la personne n'est
     * pas dans la liste, retourne -1.
     */
    public synchronized int getId(Personne p) {
        Integer res = getPersonneKey(p);
        if (res == null) {
            return -1;
        } else {
            return res.intValue();
        }
    }

    /** 
     * Supprime de la liste la personne dont on passe l'identifiant en 
     * param�tre. 
     * @param id l'identifiant de la personne � supprimer
     * @return <code>true</code> si la personne a bien �t� supprim�e, <code>false</code>
     * dans le cas contraire (c'est � dire si son identifiant n'existait pas)
     */
    public boolean removePersonne(int id) {
        Personne p;
        p = personnes.remove(new Integer(id));
        if (p == null) {
            return false;
        } else {
            // on sauvegarde la nouvelle liste car elle a �t� modifi�e
            enregistrerDonnees();
            return true;
        }
    }

    /**
     * Retourne la liste des personnes sous la forme d'une HashMap<Integer, Personne>
     * La cl� est l'identifiant et l'objet associ� la personne
     */
    public HashMap<Integer, Personne> getAllPersonnes() {
        return personnes;
    }

    /**
     * Cr�e un nouveau gestionnaire de personnes, en r�utilisant une liste pr�c�demment 
     * sauvegard�e ou en repartant sur une liste vide.
     * @param nouvelleBase si <code>true</code> alors la liste des personnes g�r�e est inialement vide,
     * sinon, r�utilise la lste sauvegard�e (si n'existe pas, cr�e une liste vide)
     */
    public DataManagerPersonne(boolean nouvelleBase) {

        // si nouvelleBase = faux : charge la liste � partir du fichier
        // par d�faut si n'existe pas, en cr�er une vide
        if (!(nouvelleBase)) {
            try {
                FileInputStream file = new FileInputStream("ListePersonnes.ser");
                ObjectInputStream input = new ObjectInputStream(file);
                personnes = (HashMap<Integer, Personne>) input.readObject();
                dernierIdentifiant = ((Integer) input.readObject()).intValue();
                input.close();
                file.close();
            } catch (Exception e) {
                System.err.println("[Lecture] problème pendant lecture de ListePersonnes.ser : " + e);
            }
        }

    }
}