/*
 * Créé le 18 nov. 03
 *
 */
package fonction.similitude;

import java.util.Vector;

import principal.Commun;
import principal.copiercoller.Tampon;
import traitement.similitude.InterfaceContientSimilitude;
import traitement.similitude.InterfaceSimilitude;
import traitement.similitude.Similitude0Sigmoide;

import fonction.FonctionEvent;
import fonction.FonctionListener;
import fonction.InterfaceFonctionFils;
import fonction.magnitude.VectorFonctionFilsMagnitude;
import fonction.reel.DefaultDelegueParentReel;
import fonction.reel.InterfaceFonctionFilsReel;
import fonction.reel.InterfaceFonctionParentReel;
import fonction.reel.ReelConstante;
import fonction.reel.VectorFonctionFilsReel;
import gui.InterfaceAffichable;
import gui.menu.IChoixDefinition;
import gui.menu.IChoixProposition;
import gui.menu.IGroupe;
import gui.menu.IMethode;
import gui.menu.IVectorMethode;

/**
 * représente une Similitude sigmoide. 
 * 
 * @author	Vincent Labatut
 * @version	1
  */
public class SimilitudeSimilitude0Sigmoide extends AbstractFonctionFilsSimilitude implements InterfaceFonctionParentReel, FonctionListener, InterfaceContientSimilitude 
{	/**
	* représentation textuelle de cette fonction.
	 */
	public static final String NOM_FONCTION = "Sim0Sig";
	/**
	* délégué gérant les InterfaceFonctionFilsReels.
	 */
	private DefaultDelegueParentReel delegueReel; //pente, centreSym
	/**
	* nombre maximal d'InterfaceFonctionFilsReels.
	 */
	private static final int MAX_REEL = 2;
	/**
	* position du fils représentant la pente parmi les fils réels.
	 */
	public static final int INDEX_PENTE = 0;
	/**
	* position du fils représentant le centre de symétrie parmi les fils réels.
	 */
	public static final int INDEX_CENTRE_SYM = 1;
	
//	----------------------------------------	
//	Constructeurs
//	----------------------------------------
	/**
	 * crée une fonction de parent la fonction passée en paramčtre.
	 * 
	 * @param	p	parent de cette fonction.	
	 * 
	  */
	public SimilitudeSimilitude0Sigmoide(InterfaceFonctionParentSimilitude p)
	{	super(p);
		similitude = new Similitude0Sigmoide(this);
		delegueReel = new DefaultDelegueParentReel(this,MAX_REEL,true);
		// on rajoute automatiquement les fils
		// car ils sont en nombre fixe
		addFils(new ReelConstante(this));
		addFils(new ReelConstante(this));
	}	

//	----------------------------------------	
//	Fils
//	----------------------------------------
	/*
	 *
	 */
	public InterfaceFonctionFils getFils(int rang)
	{	return delegueReel.getFilsReel(rang);
	}
	/*
	 *
	 */
	public void addFils(InterfaceFonctionFils fils)
	{	delegueReel.addFilsReel((InterfaceFonctionFilsReel)fils);
	}
	/*
	 *
	 */
	public void setFils(int rang, InterfaceFonctionFils fils)
	{	delegueReel.setFilsReel(rang,(InterfaceFonctionFilsReel)fils);
	}
	/*
	 *
	 */
	public void newFils(Class classe)
	{	delegueReel.newFilsReel(classe);
	}
	/*
	 *
	 */
	public void remplacerFils(InterfaceFonctionFils ancien, InterfaceFonctionFils nouveau)
	{	delegueReel.remplacerFilsReel((InterfaceFonctionFilsReel)ancien,(InterfaceFonctionFilsReel)nouveau);
	}
	/*
	 *
	 */
	public void removeFils(InterfaceFonctionFils fils)
	{	delegueReel.removeFilsReel((InterfaceFonctionFilsReel)fils);
	}
	/*
	 *
	 */
	public void removeFils(int rang)
	{	delegueReel.removeFilsReel(rang);
	}
	/*
	 *
	 */
	public int sizeFils()
	{	return delegueReel.sizeFilsReel();
	}
	/*
	 *
	 */
	public int indexOfFils(InterfaceFonctionFils fils)
	{	return delegueReel.indexOfFilsReel((InterfaceFonctionFilsReel)fils);
	}
	/*
	 *
	 */
	public void traiterEltModif(int cat, int type, int index)
	{	if (delegueReel.getFilsReel(index).estModifie())
			setModifie();
		fireFonctionEltModif(new FonctionEvent(this,type, index));
	}

//	----------------------------------------	
//	Delegue
//	----------------------------------------
	/**
	 * renvoie le délégué chargé des InterfaceFonctionFilsReels. 
	 * 
	 * @return	le délégué gérant les fils Reels.
	  */
	public DefaultDelegueParentReel getDelegueReel()
	{	return delegueReel;
	}
	
//	----------------------------------------	
//	Parent
//	----------------------------------------
	/*
	 *
	 */
	public void setParent(InterfaceFonctionParentSimilitude p)
	{	boolean flag = (p.getModele() != getModele());
		// on positione le nouveau parent
		parent =  p;
		// on s'occupe des fils
		delegueReel.setParent(this);
		//
		similitude.setParent(this);
		if (flag)
			fireFonctionChangementModele(new FonctionEvent(this));
	}

//	----------------------------------------	
//	This
//	----------------------------------------
	/*
	 *
	 */
	 public void remove()
	{	fireFonctionSuppr(new FonctionEvent(this));
		//
	   similitude.remove();
	   similitude = null;
	   //
	   delegueReel.remove();
	   delegueReel = null;
	   //
	   parent = null;
	}
	
//	----------------------------------------	
//	Interface Graphique
//	----------------------------------------
	 /*
	 *
	 */
	public IVectorMethode getVectorMethode()
	{	IMethode im;
		IGroupe ig;
		IChoixProposition ic;
		IChoixDefinition ic2;
		Class[] parameterTypes;
		boolean autorisation;
		
		IVectorMethode vectorMethode = new IVectorMethode();
		try
		{// supprimer
			// IMethode(Method, String, boolean)
			im = new IMethode(getClass().getMethod("supprimer", null), "Supprimer", editable);
			vectorMethode.addMethode(im);
		
		// insérer la pente
			if (editable && sizeFils()==INDEX_PENTE)
			{	parameterTypes = new Class[1];//nbre param
				parameterTypes[0] = Class.class;
				ig = new IGroupe();
				im = new IMethode(getClass().getMethod("inserer", parameterTypes), "Pente", true);			
				im.addGroupe(ig);
				Vector vclass = Commun.VECTOR_IFF_REEL;
				for (int i=0;i<vclass.size();i++)
				{	Class c = (Class) vclass.get(i);
					ic = new IChoixProposition((String) c.getField("NOM_FONCTION").get(null));
					ic.addValeur(c);
					ig.addChoix(ic);
				}
			}
			else
				 im = new IMethode(null, "Pente", false);			
			vectorMethode.addMethode(im);	
		
		// insérer le centre de symétrie
			if (editable && sizeFils()==INDEX_CENTRE_SYM)
			{	parameterTypes = new Class[1];//nbre param
				parameterTypes[0] = Class.class;
				ig = new IGroupe();
				im = new IMethode(getClass().getMethod("inserer", parameterTypes), "Ctr.Sym", true);			
				im.addGroupe(ig);
				Vector vclass = Commun.VECTOR_IFF_REEL;
				for (int i=0;i<vclass.size();i++)
				{	Class c = (Class) vclass.get(i);
					ic = new IChoixProposition((String) c.getField("NOM_FONCTION").get(null));
					ic.addValeur(c);
					ig.addChoix(ic);
				}
			}
			else
				 im = new IMethode(null, "Ctr.Sym", false);			
			vectorMethode.addMethode(im);	
					
		// remplacer
			if (editable)
			{    parameterTypes = new Class[1]; //nbre param
				 parameterTypes[0] = Class.class;
				 im = new IMethode(getClass().getMethod("substituer", parameterTypes), "Remplacer par", true);			
				 ig = new IGroupe();
				 im.addGroupe(ig);
				 // suivant le parent, on peut remplacer par un simple réel ou par un réelSim 
				 Vector vclass= Commun.VECTOR_IFF_SIMILITUDE;
				 for (int i=0;i<vclass.size();i++)
				 {	Class c = (Class) vclass.get(i);
					 ic = new IChoixProposition((String) c.getField("NOM_FONCTION").get(null));
					 ic.addValeur(c);
					 ig.addChoix(ic);
				 }
			}
			else
				 im = new IMethode(null, "Remplacer par", false);			
			vectorMethode.addMethode(im);	
		 
		 // copier
			im = new IMethode(getClass().getMethod("copier", null), "Copier", true);
			vectorMethode.addMethode(im);
		 
		 // couper
			im = new IMethode(getClass().getMethod("couper", null), "Couper", editable);
			vectorMethode.addMethode(im);
		 
		 // coller
			// condition : Class du buffer adéquate
			if (editable)
			{	autorisation = true; 
				Tampon tmp = getNoeud().getModele().getTampon();
				if (!tmp.estVide())
				{	Class classe = tmp.get().getClass();
					if (InterfaceFonctionFilsSimilitude.class.isAssignableFrom(classe))
						autorisation = true;
				}
			}
			else
				autorisation = false;
			im = new IMethode(getClass().getMethod("coller", null), "Coller", autorisation);
			vectorMethode.addMethode(im);
		} 
		catch (SecurityException e)
		{	e.printStackTrace();
		}
		catch (NoSuchMethodException e)
		{	e.printStackTrace();
		}
		catch (IllegalArgumentException e)
		{	e.printStackTrace();
		}
		catch (IllegalAccessException e)
		{	e.printStackTrace();
		}
		catch (NoSuchFieldException e)
		{	e.printStackTrace();
		}
		return vectorMethode;
	}
	/**
	 * crée et insčre un nouveau fils de la classe passée en paramčtre.
	 * 
	 * @param	classe	la classe du nouveau fils.
	 * 
	  */
	public void inserer(Class classe)
	{	newFils(classe);
	}

//	----------------------------------------	
//	FonctionListener
//	----------------------------------------
	/*
	 * appelée lors de la réception d'un FonctionEvent de modification de constituant.
	 * 
	  */
	public void fonctionEltModif(FonctionEvent e)
	{	setModifie();
		fireFonctionEltModif(e);
	}
	/*
	 * appelée lors de la réception d'un FonctionEvent de raffraichissement.
	 * 
	  */
	public void fonctionRaffr(FonctionEvent e)
	{	if (e.getSource().estModifie())
		{    setModifie();
			fireFonctionRaffr(new FonctionEvent(this));
		}
	}
	/*
	* appelée quand l'InterfaceFonction est déplacée dans
	* un autre Modele.
	* 
	 */
	public void fonctionChangementModele(FonctionEvent e)
	{	InterfaceFonctionFilsReel temp = (InterfaceFonctionFilsReel)e.getSource();
		if (temp.getModele() != getModele())
		{	// on sort le listener
			temp.removeFonctionListener(this);
			// on sort le constituant
			VectorFonctionFilsReel vTemp = delegueReel.getVectorFilsReel();
			vTemp.removeInterfaceFonctionFilsReel(temp);
		}
	}

//	----------------------------------------	
//	Simulation
//	----------------------------------------
	/*
	 *
	 */
	public boolean estComplet()
	{	boolean resultat;

		if (sizeFils() != MAX_REEL)
			resultat = false;
		else if (similitude == null)
			resultat = false;
		else 
			resultat = similitude.estComplet();
				
		return(resultat); 
	}	
	/*
	 *
	 */
	public InterfaceSimilitude evaluer(int instant)
	{	Vector res = delegueReel.evaluer(instant);		
		((Similitude0Sigmoide)similitude).setPente(((Double)res.get(INDEX_PENTE)).doubleValue());
		((Similitude0Sigmoide)similitude).setCentreSymetrie(((Double)res.get(INDEX_CENTRE_SYM)).doubleValue());
		// on efface les valeurs désormais inutiles
		while (res.size()!=0)
			res.remove(0);
		// on renvoie le résultat
		return similitude.cloner();
	}
	/*
	 *
	 */
	public VectorFonctionFilsMagnitude getMagnitudeBruit()
	{	VectorFonctionFilsMagnitude resultat;
		resultat = delegueReel.getMagnitudeBruit();
		return resultat;
	}

//	----------------------------------------	
//	InterfaceAffichable
//	----------------------------------------
	/*
	 *
	 */
	public void remplacer(InterfaceAffichable nouveau)
	{	if (nouveau instanceof SimilitudeSimilitude0Sigmoide)
		{	similitude.remplacer(((SimilitudeSimilitude0Sigmoide)nouveau).getSimilitude());
			delegueReel.remplacer(((SimilitudeSimilitude0Sigmoide)nouveau).getDelegueReel());
		} 
		else //InterfaceFonctionReel
		{	similitude.cacher();
			delegueReel.cacher();
		}
		fireFonctionRempl(new FonctionEvent(this,(InterfaceFonctionFils)nouveau));
	}
	/*
	 *
	 */
	public void cacher()
	{	delegueReel.cacher();
		similitude.cacher();
		fireFonctionCache(new FonctionEvent(this));
	}
//	----------------------------------------	
//	Divers
//	----------------------------------------
	/*
	 *
	 */
	public InterfaceFonctionFils cloner()
	{	SimilitudeSimilitude0Sigmoide resultat;
		resultat = new SimilitudeSimilitude0Sigmoide((InterfaceFonctionParentSimilitude)getParent());
		for (int i=0;i<sizeFils();i++)
			resultat.setFils(i,getFils(i).cloner());
		resultat.setEditable(editable);
		resultat.setNonModifie();
		return(resultat);
	}
	/*
	 *
	 */
	public String toString()
	{	return NOM_FONCTION;
	}
	/*
	 *
	 */
	public String getNom()
	{	return NOM_FONCTION;
	}

//	----------------------------------------	
//	Modification
//	----------------------------------------
	/*
	 *
	 */
	public void setNonModifie()
	{	modifie = false;
		delegueReel.setNonModifie();
		fireFonctionRaffr(new FonctionEvent(this));
	}
}