/*
 * Créé le 14 nov. 03
 *
 */
package traitement.distance;

import information.DomaineIncompatibleException;
import information.InformationIncompleteException;
import information.domaine.InterfaceDomaine;
import information.type.PartieType;
import information.type.Type;

import java.util.Vector;
import principal.Commun;
import principal.copiercoller.HomonymeIntrouvableException;
import principal.copiercoller.InterfaceHomonyme;
import traitement.TraitementEvent;
import traitement.TraitementIncompletException;
import traitement.TraitementListener;
import traitement.modele.Modele;

/**
 * mesure la distance linéaire entre deux Types.
 * Pour cela, on fait la somme des valeurs absolues des différences des poids des deux Types
 * pour chaque PartieType disponible. Si l'un des Types ne possčde pas une PartieType, son poids
 * est nul pour cette PartieType. Puis la somme est normalisée ŕ 1 (pour cela elle est divisée par 2).
 * 
 * @author	Vincent Labatut
 * @version	1
 * @see		information.type.Type
 * @see		traitement.distance.InterfaceContientDistance
  */
public class Distance0 implements InterfaceDistance
{	/**
	* Liste des TraitementListeners écoutant cette Distance.
	* 
	 */
	private Vector vectorTraitementListener;
	/**
	* InterfaceContientDistance parent de cette Distance.
	* 
	 */
	private InterfaceContientDistance parent;
	/**
	 * indique si cet objet a été modifé depuis sa derničre sauvegarde.
	  */
	private boolean modifie;
	
//	----------------------------------------	
//	Constructeurs
//	----------------------------------------
	/**
	 * Constructeur pour créer une Distance0
	 * de parent l'InterfaceContientDistance
	 * passée en paramčtre.
	 * 
	 * @param	p	parent de cette Distance0.
	 * 
	  */
	public Distance0(InterfaceContientDistance p)
	{	
    	vectorTraitementListener = new Vector();
		parent = p;
		vectorTraitementListener = new Vector();
		setModifie();
	}

//	----------------------------------------	
//	Modele
//	----------------------------------------
	/*
	 * 
	 */
	public Modele getModele()
	{	Modele resultat = null;
		resultat = parent.getModele();
		return resultat;
	}
	
//	----------------------------------------	
//	Parent
//	----------------------------------------
	/*
	 * 
	 */
	public InterfaceContientDistance getParent()
	{	return parent;
	}
	/*
	 * 
	 */
	public void setParent(InterfaceContientDistance p)
	{	parent = p;
	}
	
//	----------------------------------------	
//	This
//	----------------------------------------
	/*
	 * 
	 */
	public void remove()
	{	fireTraitementSuppr(new TraitementEvent(this));
		//
		parent = null;
		//
		
	}

//	----------------------------------------	
//	InterfaceTraitement
//	----------------------------------------
	/*
	 * 
	 */
	public void addTraitementListener(TraitementListener i)
	{	vectorTraitementListener.add(i);
	}
	/*
	 * 
	 */
	public void removeTraitementListener(TraitementListener i)
	{	vectorTraitementListener.remove(i);
	}
	/**
	 * annonce la suppression de cette Distance.
	 * Chaque TraitementListener doit se supprimer lui-męme de la liste des listeners de cette Distance.  
	 * 
	 * @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 le remplacement de cette Distance.
	 * 
	 * @param 	e	le 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 le masquage de cette Distance.
	 * 
	 * @param 	e	le 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();
			}		
	}
	/**
	 * annonce le raffraichissement de cette Distance.
	 * 
	 * @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();
			}		
	}

//	----------------------------------------	
//	Simulation
//	----------------------------------------
	/*
	 * 
	 */
	public double evaluer(Type type1, Type type2) throws DomaineIncompatibleException, InformationIncompleteException
	{	int i, index1, index2;
		double resultat, poids1, poids2; 
		PartieType pt1, pt2;
		InterfaceDomaine domaine1, domaine2;
		
		resultat = 0;
		domaine1 = type1.getDomaine();
		domaine2 = type2.getDomaine();  			
		if (domaine1.egaleDomaine(domaine2))
		{	for (i=0;i<type1.size();i++)
			{	pt1 = type1.getPartieType(i);
				poids1 = pt1.getPoids();
				index2 = type2.indexOfElement(pt1.getElement());
				if (index2 < 0)
					poids2 = 0;
				else
					poids2 = type2.getPartieType(index2).getPoids();
				resultat = resultat + Math.abs(poids1-poids2);
			}
			for (i=0;i<type2.size();i++)
			{	pt2 = type2.getPartieType(i);
				poids2 = pt2.getPoids();
				if (!type1.containsElement(pt2.getElement()))
					resultat = resultat + Math.abs(poids2);
			}
			resultat = resultat/2;
		}
		else
			throw new DomaineIncompatibleException(getIdentification()+":"+type1.getIdentification()+":"+type2.getIdentification());
		return(resultat);	
	}
	/*
	 * 
	 */
	public boolean estComplet()
	{	return true;
	}

//	----------------------------------------	
//	  Copier/Coller
//	----------------------------------------
	/*
	 * 
	 */
	public InterfaceDistance cloner()
	{	Distance0 resultat;
		resultat = new Distance0(parent);
		resultat.setNonModifie();
		return resultat;
	}
	/*
	 * 
	 */
	public InterfaceHomonyme getHomonyme(Modele m) throws HomonymeIntrouvableException
	{	InterfaceHomonyme resultat;
		if (m == getModele())
		    resultat = this;
		else
		{	resultat = ((InterfaceContientDistance)parent.getHomonyme(m)).getDistance(); 
		}
		return resultat;
	}
	/*
	 * 
	 */
	public void remplacer(InterfaceDistance nouveau)
	{	fireTraitementRempl(new TraitementEvent(this));
	}
	/*
	 * 
	 */
	public void cacher()
	{	fireTraitementCache(new TraitementEvent(this));
	}
	/*
	 * 
	 */
	public String getIdentification()
	{	return parent.getIdentification()+">"+Commun.STRING_DISTANCE;
	}

//	----------------------------------------	
//	Modification
//	----------------------------------------
	/*
	 * 
	 */
  public void setModifie()
  {	modifie = true;
  }
	/*
	 * 
	 */
  public boolean estModifie()
  {	return modifie;  
  }
	/*
	 * 
	 */
  public void setNonModifie()
  {	modifie = false;
	fireTraitementRaffr(new TraitementEvent(this));
  }
}