/*
 * Créé le 25 juil. 2004
 *
 */
package traitement.section;

import information.DomaineIncompatibleException;
import information.InformationAdapter;
import information.InformationEvent;
import information.InformationExistanteException;
import information.InformationIncompleteException;
import information.InformationListener;
import information.domaine.InterfaceDomaine;
import information.type.InterfaceContientType;
import information.type.Type;
import information.type.VectorType;

import java.util.Vector;

import principal.Commun;
import principal.copiercoller.CopiableIncompatibleException;
import principal.copiercoller.HomonymeIntrouvableException;
import principal.copiercoller.InterfaceCollable;
import principal.copiercoller.InterfaceCopiable;
import principal.copiercoller.InterfaceHomonyme;
import principal.copiercoller.Tampon;

import gui.InterfaceAffichable;
import traitement.InterfaceTraitement;
import traitement.TraitementEvent;
import traitement.TraitementIncompletException;
import traitement.TraitementListener;
import traitement.modele.Modele;

/**
 * permet d'éditer un ensemble de Types utilisés dans un EditeurEntree.
 * Le but est de faciliter l'édition de Types en créant des Types qui vont
 * ętre utilisés plusieurs fois, et en les regroupant dans un répertoire.
 * Le RepertoireType appartient ŕ un EditeurEntree.
 * 
 * @author	Vincent Labatut
 * @version	1
 * @see		traitement.section.EditeurEntree
 * @see		traitement.section.SectionInformationExogene
  */

public class RepertoireType extends InformationAdapter implements InterfaceTraitement, InformationListener, InterfaceAffichable, InterfaceContientType, InterfaceCollable
{   /**
	* Liste des Types du répertoire, sous forme d'un VectorType.
	 */
	private VectorType vectorType;
	/**
	* Liste des TraitementListeners ŕ l'écoute de ce RepertoireType.
	 */
	private Vector vectorTraitementListener;
	/**
	* EditeurEntree parent de ce RepertoireType.
	 */
	private EditeurEntree parent;
	/**
	* Compteur utilisé lors de la création de nouveaux Types.
	 */
	private int compteur;
	/**
	 * indique si cet objet a été modifé depuis sa derničre sauvegarde.
	  */
	private boolean modifie;
	
//	----------------------------------------	
//	Constructeurs
//	----------------------------------------
	/**
	 * Constructeur pour créer un RepertoireType
	 * de parent l'EditeurEntree
	 * passée en paramčtre.
	 * 
	 * @param	p	parent de ce RepertoireType.
	 * 
	  */
	public RepertoireType(EditeurEntree p) 
	{	
    	vectorType = new VectorType();
		vectorTraitementListener = new Vector();
		compteur = 0;
		//
		parent = p;
		setModifie();
	}

//	----------------------------------------	
//	Types
//	----------------------------------------
	/**
	 * renvoie le VectorType de ce Répertoire.
	 *
	 * @return	la liste de Types contenu dans ce Repertoire.
	  */
	public VectorType getVectorType()
	{	return vectorType;
	}
	/*
	 * 
	 */
	public Type getType(int index)
	{	return vectorType.getType(index);
	}
	/**
	 * renvoie un Type en fonction de son nom.
	 *
	 * @param	nom	nom du Type désiré. 
	 * @return	le Type correspondant au nom spécifié.
	  */
	public Type getType(String nom)
	{	return getType(vectorType.indexOfNom(nom));
	}
	/**
	 * ajoute un Type ŕ la fin de ce Repertoire.
	 * 
	 * @param	t	le Type ŕ rajouter.
	 * @throws 	DomaineIncompatibleException si le Domaine du Type n'est pas compatible avec le Domaine de ce Repertoire.
	 * @throws 	InformationExistanteException si un Type du męme nom existe déjŕ dans ce Repertoire.
	  */
	public void addType(Type t) throws DomaineIncompatibleException, InformationExistanteException
	{	if (vectorType.containsNom(t.getNom()))
			throw new InformationExistanteException(getIdentification()+":"+t.getIdentification());
		if (!getDomaine().estCompatibleDomaine(t.getDomaine()))
			throw new DomaineIncompatibleException(getIdentification()+":"+t.getIdentification());
		//
		if (t.getNom().equals(Commun.STRING_ANONYME))
		{	String nom = Type.NOUVEAU+" "+compteur;
			while (vectorType.containsNom(nom))
			{	compteur ++;
				nom = Type.NOUVEAU+" "+compteur;
			}
			t.setNom(nom);
		}
		//
		vectorType.addType(t);
		t.setParent(this);
		t.addInformationListener(this);
		compteur++;
		setModifie();
	    fireTraitementEltModif(new TraitementEvent(this,TraitementEvent.ELT_INSER,size()-1));
	}
	/**
	 * crée et rajoute un Type ŕ la fin de ce Repertoire.
	 * Son nom est généré ŕ partir du compteur.
	 * 
	  */
	public void newType()
	{	Type type;
		int i;
		
		String nom = Type.NOUVEAU+" "+compteur;
		try
		{	while (vectorType.containsNom(nom))
			{	compteur ++;
				nom = Type.NOUVEAU+" "+compteur;
			}
			type = new Type(this);
			type.setNom(nom);
			addType(type);
		}
		catch (InformationExistanteException e)
		{	e.printStackTrace();
		}
		catch (DomaineIncompatibleException e)
		{	e.printStackTrace();
		}
	}		
	/**
	 * modifie le nom d'un des Types de ce Repertoire,
	 * passé en paramčtre. Son nom est remplacé par
	 * le nom passé en second paramčtre.
	 * 
	 * 
	 * @param	ancien	Type ŕ renommer.
	 * @param	nouveau	nouveau nom de ce Type.
	 * @throws	InformationExistanteException	si un Type de ce nom existe déjŕ dans ce Repertoire.
	  */
	public void renommerType(Type ancien,String nouveau) throws InformationExistanteException
	{	nouveau = Commun.normaliserNom(nouveau);
		if (!ancien.getNom().equals(nouveau))
			if (vectorType.containsNom(nouveau) || nouveau.equals(Commun.STRING_ANONYME))
				throw new InformationExistanteException(getIdentification()+":"+nouveau);
			else
				ancien.setNom(nouveau);
	}
	/**
	 * supprime un Type de ce Repertoire, en 
	 * fonction de sa position dans le répertoire.
	 * 
	 * @param	index	position du Type ŕ supprimer.
	  */
	public void removeType(int index)
	{	Type temp = vectorType.getType(index);
//		parent.viderType(temp);
		temp.removeInformationListener(this); 
		temp.remove(); 
		vectorType.removeType(index);
		setModifie();
	    fireTraitementEltModif(new TraitementEvent(this,TraitementEvent.ELT_SUPPR,index));
	}
	/**
	 * renvoie le nombre de Types dans le répertoire.
	 * 
	 * @return	nombre de Types dans ce Repertoire.
	  */
	public int size()
	{	return vectorType.size();
	}

	/**
	 * détermine s'il existe dans ce Repertoire un Type 
	 * du męme nom que le nom passé en paramčtre.
	 * 
	 * @param	nom	nom du Type dont on veut savoir s'il est contenu dans ce Repertoire.
	 * @return	vrai si un Type du męme nom existe dans ce Repertoire, faux sinon.
	  */
	public boolean containsType(String nom)
	{	return vectorType.containsNom(nom);
	}
	/**
	 * détermine le Type passé en paramčtre appartient
	 * ŕ ce Repertoire, en tant qu'objet (pas juste 
	 * en comparant les noms).
	 * 
	 * @param	type	Type dont on veut connaitre la position.
	 * @return	vrai si ce Type existe dans ce Repertoire, faux sinon.
	  */
	public boolean containsObjet(Type type)
	{	return vectorType.containsObjet(type);
	}
	/**
	 * renvoie la position du Type portant le nom passé en paramčtre.
	 * 
	 * @param	nom	nom du Type dont on veut connaitre la position.
	 * @return	position du Type portant le nom passé en paramčtre.
	  */
	public int indexOfType(String nom)
	{	return vectorType.indexOfNom(nom);
	}
	/**
	 * renvoie la position, en tant qu'objet,
	 * du Type passé en paramčtre (on ne tient pas compte
	 * que du nom).
	 * 
	 * @param	type	Type dont on veut connaitre la position.
	 * @return	position du Type passé en paramčtre.
	  */
	public int indexOfObjet(Type type)
	{	return vectorType.indexOfObjet(type);
	}

//	----------------------------------------	
//	Domaine
//	----------------------------------------
	/*
	 * 
	 */
	public InterfaceDomaine getDomaine()
	{	InterfaceDomaine resultat = null;
		resultat = parent.getDomaine();
		return resultat;
	}
	
//	----------------------------------------	
//	This
//	----------------------------------------
	/*
	 * 
	 */
  public void remove()
  {	fireTraitementSuppr(new TraitementEvent(this));
  	// on efface tous les liens
	while (size()!=0)
		removeType(0);
	parent = null;
	vectorType = null;
	  
  }
  
//----------------------------------------	
//Simulation
//----------------------------------------
	/*
	 * 
	 */
  public boolean estComplet()
  {	boolean resultat = true;
		
	  if (!vectorType.estComplet())
	  	resultat = false;
		
	  return resultat;				
  }

//	----------------------------------------	
//	Parent
//	----------------------------------------
	/**
	 * renvoie l'EditeurEntree parent de ce Repertoire.
	 * 
	 * @return 	l'EditeurEntree parent.
	  */
	public EditeurEntree getParent()
	{	return parent;
	}
	/**
	 * modifie l'EditeurEntre qui contient ce Repertoire (i.e. son parent).
	 * Les Types de ce répertoire sont mis ŕ jour afin de raffraichir le domaine écouté.
	 * Un TraitementEvent de raffraichissement est émis.
	 * 
	 * @param	p nouveau parent de ce Repertoire.
	 * @throws	DomaineIncompatibleException si le Domaine des Types contenus dans ce Repertoire
	 * 			n'est pas compatible avec le Domaine du nouveau parent. 
	  */
	public void setParent(EditeurEntree p) throws DomaineIncompatibleException
	{	// si le Domaine du parent n'est pas compatible avec les Types actuellement en mémoire
		// on lčve une DomaineIncompatibleException
		if (size()>0)
			if (!p.getDomaine().estCompatibleDomaine(getType(0).getDomaine()))
				throw new DomaineIncompatibleException(getIdentification()+":"+p.getIdentification());
		parent = p;
		for (int i=0;i<size();i++)
			getType(i).setParent(this);
		setModifie();
	    fireTraitementRaffr(new TraitementEvent(this));
	}
	
//	----------------------------------------	
//	Modele
//	----------------------------------------
	/*
	 * 
	 */
	public Modele getModele()
	{	return parent.getModele();
	}

//	----------------------------------------	
//	InterfaceTraitement
//	----------------------------------------
	/*
	 * 
	 */
	public void addTraitementListener(TraitementListener i)
	{	vectorTraitementListener.add(i);
	}
	/*
	 * 
	 */
	public void removeTraitementListener(TraitementListener i)
	{	vectorTraitementListener.remove(i);
	}
	/**
	 * annonce la suppression de ce Repertoire.
	 * Chaque TraitementListener doit se supprimer lui-męme de la liste des listeners de cet EditeurObservation.  
	 * 
	 * @param 	e	le TraitementEvent qui est émis vers les TraitementListeners. 
	  */
	private void fireTraitementSuppr(TraitementEvent e)
	{	
	    while (vectorTraitementListener.size()!=0)
			try {
				((TraitementListener) vectorTraitementListener.get(0)).traitementSuppr(e);
			} catch (TraitementIncompletException e1) {
				e1.printStackTrace();
			}
	}
	/**
	 * annonce une modification d'un des constituants de ce Repertoire.
	 * 
	 * @param 	e	le TraitementEvent qui est émis vers les TraitementListeners. 
	  */
	private void fireTraitementEltModif(TraitementEvent e)
	{	
	    for (int i=0;i<vectorTraitementListener.size();i++)
			try {
				((TraitementListener) vectorTraitementListener.get(i)).traitementEltModif(e);
			} catch (TraitementIncompletException e1) {
				e1.printStackTrace();
			}
	}
	/**
	 * annonce un raffraichissement de ce Repertoire.
	 * 
	 * @param 	e	le TraitementEvent qui est émis vers les TraitementListeners. 
	  */
	private void fireTraitementRaffr(TraitementEvent e)
	{	
	    for (int i=0;i<vectorTraitementListener.size();i++)
			try {
				((TraitementListener) vectorTraitementListener.get(i)).traitementRaffr(e);
			} catch (TraitementIncompletException e1) {
				e1.printStackTrace();
			}
	}
	/**
	 * annonce un échange.
	 * 
	 * @param 	e	l'TraitementEvent qui est émis vers les TraitementListeners. 
	  */
	private void fireTraitementRempl(TraitementEvent e)
	{	for (int i=0;i<vectorTraitementListener.size();i++)
			try
			{	((TraitementListener) vectorTraitementListener.get(i)).traitementRempl(e);
			}
			catch (TraitementIncompletException e1)
			{	e1.printStackTrace();
			}
	}
	/**
	 * annonce un masquage.
	 * 
	 * @param 	e	l'TraitementEvent qui est émis vers les TraitementListeners. 
	  */
	private void fireTraitementCache(TraitementEvent e)
	{	for (int i=0;i<vectorTraitementListener.size();i++)
			try
			{	((TraitementListener) vectorTraitementListener.get(i)).traitementCache(e);
			}
			catch (TraitementIncompletException e1)
			{	e1.printStackTrace();
			}
	}

//	----------------------------------------	
//	InformationListener
//	----------------------------------------
	/*
	 * appelée lors de la réception d'un InformationEvent de modification de constituant.
	 * ce Repertoire écoute exclusivement ses Types.
	 * On fait passer un raffraichissement.
	  */
	public void informationEltModif(InformationEvent e)
	{	setModifie();
		fireTraitementRaffr(new TraitementEvent(this));
	}
	/*
	 * appelée lors de la réception d'un InformationEvent de raffraichissement.
	 * ce Repertoire écoute exclusivement ses Types.
	 * On lčve un TraitementEvent de raffraichissement
	  */
	public void informationRaffr(InformationEvent e)
	{	if (e.getSource().estModifie())
		{    setModifie();
			fireTraitementRaffr(new TraitementEvent(this));
		}
	}
	/*
	 * appelée lors de la réception d'un InformationEvent de changement
	 * de Modele.
	 * ce Repertoire écoute exclusivement ses Types.
	 * Les liens vers le Type concernés sont supprimés.
	  */
	public void informationChangementModele(InformationEvent e)
	{	Type temp = (Type)e.getSource();
		try
		{	if (temp.getModele() != getModele())
			{	temp.removeInformationListener(this); 
				vectorType.removeType(temp);
			} 
		}
		catch (InformationIncompleteException e1)
		{	e1.printStackTrace();
		}	
	}
		
		
//	----------------------------------------	
//	InterfaceContientType
//	----------------------------------------
	/*
	 * 
	 */
	public int indexOfType(Type type)
	{	return vectorType.indexOfObjet(type);
	}	

//	----------------------------------------	
//	InterfaceAffichable
//	----------------------------------------
	/*
	 * 
	 */
	public void remplacer(InterfaceAffichable d)
	{	fireTraitementRempl(new TraitementEvent(this,(RepertoireType)d));
	}
	/*
	 * 
	 */
	public void cacher()
	{	fireTraitementCache(new TraitementEvent(this));
	}

//	----------------------------------------	
//	Copier/Coller/Undo
//	----------------------------------------
	/*
	 * renvoie une copie de ce Repertoire.
	 * Le nouveau Repertoire est réglé sur le męme fichier, mais par défaut,
	 * il est désactivé. Il a le męme parent que cet Editeur, 
	 * mais c'est temporaire : la copie est destinée ŕ 
	 * ętre insérée dans une autre SectionInformationExogene.
	 * L'entreeFichier est le męme.
	 * Le reste n'est pas copié.
	  */
	public RepertoireType cloner()
	{	RepertoireType resultat;		
		// COPIE
		resultat = new RepertoireType(parent);
		// on copie la liste de Type
		VectorType tempVtype = new VectorType();
		for (int i=0;i<size();i++)
		{	Type type = getType(i).cloner();
			tempVtype.addType(type);
			type.setParent(resultat);
			type.addInformationListener(resultat);
		}
		resultat.setclonerVectorType(tempVtype);
		// on copie le compteur
		resultat.setclonerCompteur(compteur);
		resultat.setNonModifie();
		return resultat;
	}
	/**
	 * utilisée lors du clonage pour modifier un champ 
	 * de façon directe.
	 * 
	  */
	public void setclonerVectorType(VectorType v)
	{	vectorType = v;
	}
	/**
	 * utilisée lors du clonage pour modifier un champ 
	 * de façon directe.
	 * 
	  */
	public void setclonerCompteur(int cpt)
	{	compteur = cpt;
	}
	/*
	 * 
	 */
	public InterfaceHomonyme getHomonyme(Modele m) throws HomonymeIntrouvableException
	{	InterfaceHomonyme resultat;
		if (m == getModele())
		    resultat = this;
		else
		{	resultat = ((EditeurEntree)parent.getHomonyme(m)).getRepertoire();
		}
		return resultat;
	}
	/*
	 *
	 */
	public boolean estCollable()
	{	boolean resultat = true;
	    Tampon tampon = getModele().getTampon();
		if (tampon.estVide())
			resultat = false;
		else
		{	InterfaceCopiable buffer = tampon.get();
			if (buffer instanceof Type)
			{	if (!getDomaine().estCompatibleDomaine(((Type)buffer).getDomaine()))
			    	resultat = true;
				else
				    resultat = false;
			}
			else
				resultat = false;
		}
		return resultat;
	}
	/*
	 * 
	 */
	public void coller() throws CopiableIncompatibleException
	{	  Tampon tampon = getModele().getTampon();
		if (tampon.estVide())
			throw new CopiableIncompatibleException(getIdentification());
		InterfaceCopiable buffer = tampon.get();
		if (buffer instanceof Type)
		{	Type temp = (Type) buffer;
			String nom = temp.getNom();
		  	if (nom.equals(Commun.STRING_ANONYME))
				nom = Type.NOUVEAU;
			try
			{	String nom2 = nom;
				while (vectorType.containsNom(nom2))
					{	compteur ++;
						nom2 = nom+" "+compteur;
					}
				temp.setNom(nom2);
				addType(temp);
			}
			catch (InformationExistanteException e)
			{	throw new CopiableIncompatibleException(getIdentification());
			}
			catch (DomaineIncompatibleException e)
			{	throw new CopiableIncompatibleException(getIdentification());
			}
		}
		else
			throw new CopiableIncompatibleException(getIdentification());
	}
	/*
	 * 
	 */
	public String getIdentification()
	{	return parent.getIdentification()+">"+Commun.STRING_REPERTOIRE+" "+Commun.STRING_TYPE;
	}

	//	----------------------------------------	
	//	Modification
	//	----------------------------------------
	/*
	 * 
	 */
	public void setModifie()
	{	modifie = true;
	}
	/*
	 * 
	 */
	public boolean estModifie()
	{	return modifie;  
	}
	/*
	 * 
	 */
	public void setNonModifie()
	{	modifie = false;
		for (int i=0;i<size();i++)
			getType(i).setNonModifie();
  	    fireTraitementRaffr(new TraitementEvent(this));
	}
}