/*
 * Créé le 11 sept. 2004
 *
 */
package resultat;

import information.DomaineIncompatibleException;
import information.InformationExistanteException;
import information.InformationIncompleteException;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Vector;

import fichier.ContenuFichierIncompatibleException;
import fichier.TypeFichierIncompatibleException;
import fichier.VersionFichierIncompatibleException;
import fichier.flux.RageInputStream;

import principal.Commun;

import traitement.TraitementAdapter;
import traitement.TraitementEvent;
import traitement.TraitementExistantException;
import traitement.TraitementIncompletException;
import traitement.TraitementListener;
import traitement.projet.Projet;

/**
 * permet d'ouvrir les données issues des simulations.
 * Pour chaque simulation ŕ ouvrir, un Projet est ouvert.
 * Chaque Section du Projet ouvre ses propres fichiers de données
 * contenant les résultats de la simulation, et des vues sont créées,
 * qui permettent l'accčs de la GUI aux données.
 * <p>
 * Un VisionneurResultat peut ouvrir plusieurs simulations indépendemment.
 * A noter qu'il n'est pas possible (et de toute façon inutile) d'ouvrir plusieurs fois
 * la męme simulation.
 *  
 * 
 * @author	Vincent Labatut
 * @version	1
 * @see		resultat.ResultatListener
  */
public class VisionneurResultat extends TraitementAdapter implements InterfaceResultat, TraitementListener
{	/**
	 * liste des simulations ouvertes.  
	  */
	private Vector vectorSimulation;
	/**
	 * liste des ResultatListeners ŕ l'écoute de ce VisionneurResultat.  
	  */
	private Vector vectorResultatListener;

//	----------------------------------------	
//	Constructeurs
//	----------------------------------------
	/**
	 * crée un nouveau VisionneurResultat vierge (sans aucune simulation ouverte).  
	  */
		public VisionneurResultat()
	{	vectorSimulation = new Vector();
		vectorResultatListener = new Vector();
	}
	
//	----------------------------------------	
//	Projets
//	----------------------------------------
	/**
	 * renvoie le projet correspondant ŕ la simulation située au rang passé en paramčtre.
	 * 
	 * @param	index	le rang de la simulation dont on veut le projet.
	 * @return	le projet de la simulation située au rang spécifié.  
	  */
	public Projet getProjet(int index)
	{	return (Projet)vectorSimulation.get(index);
	}
	/**
	 * renvoie le nom de la simulation correspondant au rang passé en paramčtre.
	 * Ce nom inclue la data et l'heure de simulation et le nom du projet.
	 * 
	 * @param	index	le rang de la simulation dont on veut le nom.
	 * @return	le nom associé ŕ la simulation située au rang spécifié.  
	  */
	public String getNom(int index)
	{	String resultat;
		// on récup le nom du projet originel
		resultat = getProjet(index).getRepertoireBasique().getParentFile().getName();
		// on récup le temps
		resultat = resultat + Commun.STRING_RESULTAT_SEPARATEUR+getProjet(index).getRepertoireBasique().getName();
		// on renvoie le tout
		return resultat;
	}
	/**
	 * ouvre la simulation contenues dans le répertoire passé en paramčtre.
	 * La simulation est rajoutée ŕ la liste des simulation ouvertes de ce VisionneurResultat.
	 * 
	 * @param	repertoire	le répertoire contenant les fichiers de simulation ŕ ouvrir.
	 * @throws	ResultatExistantException	si la simulation correspondant au répertoire est déjŕ ouverte.  
	 * @throws	IOException	si une erreur d'accčs ŕ un fichier se produit lors de l'ouverture des donnnées.  
	 * @throws	ContenuFichierIncompatibleException	si le format d'un des fichiers de données est erroné.  
	 * @throws	VersionFichierIncompatibleException	si la version de Rage qui a généré ces données est incompatible avec la présente version.  
	 * @throws	TypeFichierIncompatibleException	si un des fichiers de données n'en n'est pas un.  
	  */
	public void ouvrirSimulation(File repertoire) throws ResultatExistantException, IOException, ContenuFichierIncompatibleException, VersionFichierIncompatibleException, TypeFichierIncompatibleException
	{	File fichier = null;
		
		// on récupčre le bon fichier projet dans le répertoire		
		// le nom cherché
		String nomTemp = repertoire.getParentFile().getName()+Commun.EXT_PROJET; 
		// le contenu du répertoire
		File[] contenu = repertoire.listFiles();
		boolean trouve = false;
		int i = 0;
		while (i<contenu.length && !trouve)
			if (contenu[i].getName().equals(nomTemp))
				trouve = true;
			else
				i++;
		if (!trouve)
			throw new FileNotFoundException(nomTemp);
		else
			fichier = contenu[i];		
		
		// on teste s'il n'a pas été déjŕ ouvert
		String n = repertoire.getParentFile().getName()+Commun.STRING_RESULTAT_SEPARATEUR+repertoire.getName();
		//System.out.println(n);
		if (containsSimulation(n))
			throw new ResultatExistantException(getIdentification()+":"+nomTemp);
		
		// on peut enfin l'ouvrir
		FileInputStream in = null;
		Projet p = null;
		try
		{	in = new FileInputStream(fichier);
			RageInputStream inputStream = new RageInputStream(in,true,true);

			// on récupčre la version du fichier
			Float version = (Float)inputStream.readObject();
			if (version.compareTo(Commun.VERSION)>0)
				throw new VersionFichierIncompatibleException(fichier.getPath());
	
			// on récupčre le type de fichier
			String typeFichier = (String)inputStream.readObject();
			if (!typeFichier.equals(Commun.FICHIER_CODE_PROJET))
				throw new TypeFichierIncompatibleException(fichier.getPath());

			// on lit le Projet
			p = inputStream.readProjet();
			in.close();

			p.setRepertoireBasique(fichier.getParentFile());
			//on remplit le Projet avec les résultats calculés précédemment
			p.recupererResultat();
		}
		catch (IOException e)
		{	if (in!=null)
				in.close();
			if (p!=null)
				p.remove();
			throw e;
		}			
		catch (TraitementExistantException e)
		{	if (in!=null)
				in.close();
			if (p!=null)
				p.remove();
			throw new ContenuFichierIncompatibleException(fichier.getPath());
		}			
		catch (InformationExistanteException e)
		{	if (in!=null)
				in.close();
			if (p!=null)
				p.remove();
			throw new ContenuFichierIncompatibleException(fichier.getPath());
		}			
		catch (TraitementIncompletException e)
		{	if (in!=null)
				in.close();
			if (p!=null)
				p.remove();
			throw new ContenuFichierIncompatibleException(fichier.getPath());
		}			
		catch (DomaineIncompatibleException e)
		{	if (in!=null)
				in.close();
			if (p!=null)
				p.remove();
			throw new ContenuFichierIncompatibleException(fichier.getPath());
		}			
		catch (InformationIncompleteException e)
		{	if (in!=null)
				in.close();
			if (p!=null)
				p.remove();
			throw new ContenuFichierIncompatibleException(fichier.getPath());
		}			
		catch (ClassNotFoundException e)
		{	if (in!=null)
				in.close();
			if (p!=null)
				p.remove();
			throw new ContenuFichierIncompatibleException(fichier.getPath());
		}			
		catch (VersionFichierIncompatibleException e)
		{	if (in!=null)
				in.close();
			if (p!=null)
				p.remove();
			throw e;
		}			
		catch (TypeFichierIncompatibleException e)
		{	if (in!=null)
				in.close();
			if (p!=null)
				p.remove();
			throw e;
		}
		catch (ContenuFichierIncompatibleException e)
		{	if (in!=null)
				in.close();
			if (p!=null)
				p.remove();
			throw e;
		}

		// on place le Projet dans le Vector
		vectorSimulation.add(p);
		// on l'écoute
		p.addTraitementListener(this);
		// on émet un evt
		fireResultatEltModif(new ResultatEvent(this,ResultatEvent.ELT_INSER,vectorSimulation.size()-1));
	}
	/**
	 * ferme la simulation située ŕ la position spécifiée en paramčtre.
	 * 
	 * @param	index	la position de la simulation ŕ fermer.
	  */
	public void fermerSimulation(int index)
	{	Projet p = getProjet(index);
		p.removeTraitementListener(this);
		vectorSimulation.remove(index);
		p.remove();
		fireResultatEltModif(new ResultatEvent(this,ResultatEvent.ELT_SUPPR,index));
	}
	/**
	 * détermine si la simulation dont le nom est passé en paramčtre est déjŕ ouverte.
	 * 
	 * @param	res	nom de la simulation ŕ rechercher.
	 * @return	vrai si cette simulation est déjŕ ouverte.
	  */
	public boolean containsSimulation(String res)
	{	boolean trouve = false;
		int i = 0;
		while (i<size() && !trouve)
			if (getNom(i).equals(res))
				trouve = true;
			else
				i++;
		return trouve;
	}
	/**
	 * renvoie le nombre de simulations ouvertes dans ce résultat.
	 * 
	 * @return	vrai si cette simulation est déjŕ ouverte.
	  */
	public int size()
	{	return vectorSimulation.size();
	}
//	----------------------------------------	
//	InterfaceResultat
//	----------------------------------------
	/*
	 * 
	 */
	public void addResultatListener(ResultatListener i)
	{	vectorResultatListener.add(i);
	}
	/*
	 * 
	 */
	public void removeResultatListener(ResultatListener i)
	{	vectorResultatListener.remove(i);
	}
	/**
	 * annonce la suppression de ce VisionneurResultat.
	 * Chaque ResultatListener doit se supprimer lui-męme de la liste des listeners de ce VisionneurResultat.  
	 * 
	 * @param 	e	le ResultatEvent qui est émis vers les ResultatListeners. 
	  */
	private void fireResultatSuppr(ResultatEvent e)
	{	while (vectorResultatListener.size()!=0)
			((ResultatListener) vectorResultatListener.get(0)).resultatSuppr(e);
	}
	/**
	 * annonce une modification d'un des constituants de ce VisionneurResultat.
	 * 
	 * @param 	e	le ResultatEvent qui est émis vers les ResultatListeners. 
	  */
	private void fireResultatEltModif(ResultatEvent e)
	{	for (int i=0;i<vectorResultatListener.size();i++)
			((ResultatListener) vectorResultatListener.get(i)).resultatEltModif(e);
	}

//	----------------------------------------	
//	This
//	----------------------------------------
	/**
	 * supprime ce VisionneurResultat et toutes les données qu'il possčde.
	 * Par conséquent, toutes les simulations ouvertes sont refermées.
	 * 
	  */
	public void remove()
	{	fireResultatSuppr(new ResultatEvent(this));
		while (size()!=0)
			fermerSimulation(0);
		vectorSimulation = null;
		
	}
	/**
	 * détermine la complétude de ce résultat. Inutile ici.
	 * 
	  */
	public boolean estComplet()
	{	return true;
	}
	/**
	 * renvoie une représentation textuelle de ce VisionneurResultat, en 
	 * remontant ŕ partir de celui-ci jusqu'ŕ ses parents.
	 * (utilisé lors du débuggage)  
	 * 
	  */
	public String getIdentification()
	{	return Commun.STRING_RESULTAT;
	}

//	----------------------------------------	
//	TraitementListener
//	----------------------------------------
	/*
	 * le VisionneurResultat écoute les Projets correspondant aux simulations ouvertes.
	 * Si l'un d'eux est supprimé, les liens vers ce Projet sont effacés,
	 * et un évčnement de modification est émis.  
	 * 
	  */
	public void traitementSuppr(TraitementEvent e)
	{	int index = vectorSimulation.indexOf(e.getSource());
		((Projet)e.getSource()).removeTraitementListener(this);
		vectorSimulation.remove(index);
		fireResultatEltModif(new ResultatEvent(this,ResultatEvent.ELT_SUPPR,index));
	}
}