/*
 * Créé le 10 sept. 2004
 *
 */
package traitement.moteur;

import information.DomaineIncompatibleException;
import information.magnitude.Magnitude;
import information.tpt.TPT;
import information.type.Type;
import java.io.IOException;
import java.util.Vector;
import principal.copiercoller.HomonymeIntrouvableException;
import principal.copiercoller.InterfaceHomonyme;
import fichier.ContenuFichierIncompatibleException;
import gui.InterfaceAffichable;
import traitement.TraitementEvent;
import traitement.TraitementIncompletException;
import traitement.TraitementListener;
import traitement.modele.Modele;
import traitement.noeud.InterfaceNoeud;
import traitement.noeud.fonctionnel.NoeudFonctionnelEndogene;
import traitement.noeud.fonctionnel.NoeudFonctionnelExogene;
import traitement.noeud.fonctionnel.VectorNoeudFonctionnel;

/**
 * les Magnitudes sont traitées comme des variables déterministes,
 * on ne tient pas du tout compte des écart-types.
 * C'est plutot un premier moteur de test.
 * 
 * @author	Vincent Labatut
 * @version	1
 * @see		traitement.modele.Modele
  */
public class MoteurDeterministe implements InterfaceMoteur
{	
//	----------------------------------------	
//	Moteur
//	----------------------------------------
	/**
	* Liste des TraitementListeners écoutant cette Moteur.
	* 
	 */
	private Vector vectorTraitementListener;
	/**
	* Modele parent de ce Moteur.
	* 
	 */
	private Modele parent;
	/**
	 * indique si cet objet a été modifé depuis sa derničre sauvegarde.
	  */
	private boolean modifie;
//	----------------------------------------	
//	Listes de Noeuds
//	----------------------------------------
	/**
	* Liste des NoeudExogenes utilisée pendant le traitement.
	* 
	 */
	private VectorNoeudFonctionnel vectorNoeudExogene;
	/**
	* Liste des NoeudEndogenes non observés pour l'activation, utilisée pendant le traitement.
	* 
	 */
	private VectorNoeudFonctionnel vectorNoeudEndogene;

//	----------------------------------------	
//	Constructeurs
//	----------------------------------------
	/**
	 * Constructeur pour créer un Moteur
	 * de parent le Modele
	 * passé en paramčtre.
	 * 
	 * @param	m	parent de ce Moteur.
	 * 
	  */
	public MoteurDeterministe(Modele m)
	{	parent = m;
		vectorTraitementListener = new Vector();
		setModifie();
	}

//	----------------------------------------	
//	Parent
//	----------------------------------------
	/*
	 *
	 */
	public Modele getParent()
	{	return parent;
	}
	/*
	 *
	 */
	public void setParent(Modele p)
	{	parent = p;
	}	
	
//	----------------------------------------	
//	Modele
//	----------------------------------------
	/*
	 *
	 */
	public Modele getModele()
	{	return parent;
	}

//	----------------------------------------	
//	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 un 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();
			}		
	}
	/**
	 * annonce un raffraichissement 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 un raffraichissement 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();
			}		
	}

//----------------------------------------	
//	This
//----------------------------------------
	/*
	 *
	 */
	public void remove()
	{	fireTraitementSuppr(new TraitementEvent(this));
		//
		parent = null;
		//
		
	}
	
//	----------------------------------------	
//	Simulation
//	----------------------------------------
	/*
	 *
	 */
	public boolean estComplet()
	{	return true;
	}
	/*
	 *
	 */
	public void preparerSimulation()
	{	VectorNoeudFonctionnel vectorNoeudFonctionnel = parent.getVectorNoeudFonctionnel();
		// déterminer la liste de NoeudFonctionnelEndogene et celle de NoeudFonctionnelExogene
		// on néglige les observations
		vectorNoeudExogene = new VectorNoeudFonctionnel();
		vectorNoeudEndogene = new VectorNoeudFonctionnel();
		for (int i=0;i<vectorNoeudFonctionnel.size();i++)
		{	InterfaceNoeud n = vectorNoeudFonctionnel.getNoeudFonctionnel(i);
			if (n instanceof NoeudFonctionnelEndogene)
				vectorNoeudEndogene.addNoeudFonctionnel((NoeudFonctionnelEndogene)n); 
			else if (n instanceof NoeudFonctionnelExogene)
				vectorNoeudExogene.addNoeudFonctionnel((NoeudFonctionnelExogene)n);
		}
	    fireTraitementRaffr(new TraitementEvent(this));		
	}
	/*
	 *
	 */
	public void evaluer(int instant) throws IOException, ClassNotFoundException, ContenuFichierIncompatibleException
	{	// algo général :
		// 1) mąj valeurs d'émission des NoeudExogenes
		// 2) mąj valeurs d'activation des NoeudEndogenes
		// 3+4) mąj des valeurs d'émission des NoeudEndogenes
		// 5) mąj TPT (apprentissage) des NoeudEndogenes


		// ------------------------------------------------------
		// 1) mąj valeurs d'émission des NoeudExogenes
		// ------------------------------------------------------
		for (int i=0;i<vectorNoeudExogene.size();i++)
		{	NoeudFonctionnelExogene n = (NoeudFonctionnelExogene)vectorNoeudExogene.getNoeudFonctionnel(i);
			if (instant != 0)
			{	Vector resultat;
				resultat = n.lireEntreeFichier();
				// Magnitude
				Magnitude resM = (Magnitude) resultat.get(0);
				n.addMagnitudeEmission(resM);
				// Type
				Type resT = (Type) resultat.get(1);
				try
				{	n.addTypeEmission(resT);
				}
				catch (DomaineIncompatibleException e)
				{	e.printStackTrace();
				}
			}
		}	  


		// ------------------------------------------------------
		// 2) mąj valeurs d'activation des NoeudEndogenes
		// ------------------------------------------------------
		// non-observables
		for (int i=0;i<vectorNoeudEndogene.size();i++)
		{	NoeudFonctionnelEndogene n = (NoeudFonctionnelEndogene)vectorNoeudEndogene.getNoeudFonctionnel(i);
			// Magnitude d'activation
			Magnitude resM = n.getSectionActivation().getFonctionMagnitude().evaluer(instant);
			n.addMagnitudeActivation(resM);
			// Type d'activation
			Type resT = n.getSectionActivation().getFonctionType().evaluer(instant);
			try
			{	n.addTypeActivation(resT);
			}		
			catch (DomaineIncompatibleException e)
			{	e.printStackTrace();
			}
			// mise ą jour des variables persistantes du Noeud
			n.getSectionApprentissage().getFonctionTPT().raffraichirNoeud(instant);
		}	  

		// ------------------------------------------------------
		// 3+4) mąj valeurs d'émission des NoeudEndogenes
		// ------------------------------------------------------
		for (int i=0;i<vectorNoeudEndogene.size();i++)
		{	NoeudFonctionnelEndogene n = (NoeudFonctionnelEndogene)vectorNoeudEndogene.getNoeudFonctionnel(i);
			//	Magnitude d'émission
			Magnitude resM = n.getSectionEmission().getFonctionMagnitude().evaluer(instant);
			n.addMagnitudeEmission(resM);
			// Type d'émission
			Type resT = n.getSectionEmission().getFonctionType().evaluer(instant);
			try
			{	n.addTypeEmission(resT);
			}		
			catch (DomaineIncompatibleException e)
			{	e.printStackTrace();
			}
		}	  
		
		// ------------------------------------------------------
		// 5) mąj TPT (apprentissage) des NoeudEndogenes
		// ------------------------------------------------------
		// non-observables
		for (int i=0;i<vectorNoeudEndogene.size();i++)
		{	NoeudFonctionnelEndogene n = (NoeudFonctionnelEndogene)vectorNoeudEndogene.getNoeudFonctionnel(i);
			TPT res = n.getSectionApprentissage().getFonctionTPT().evaluer(instant);
			try
			{	n.addTPT(res);
			}
			catch (DomaineIncompatibleException e)
			{	e.printStackTrace();
			}
		}	  
	}
	/*
	 *
	 */
	public void interrompreSimulation()
	{	
	}	
	/*
	 *
	 */
	public void terminerSimulation()
	{	
	}	
	
//	----------------------------------------	
//	  Copier/Coller
//	----------------------------------------
	/*
	 *
	 */
	public InterfaceMoteur cloner()
	{	MoteurDeterministe resultat = new MoteurDeterministe(parent);
		resultat.setNonModifie();
	    return resultat;
	}
	/*
	 *
	 */
	public InterfaceHomonyme getHomonyme(Modele modele) throws HomonymeIntrouvableException
	{	InterfaceHomonyme resultat;
		if (modele == getModele())
		    resultat = this;
		else
		{	resultat = modele.getMoteur();
		}
		return resultat;
	}

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

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