package database.migration.etape1.depotEtFermeture;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.HashSet;
import java.util.InvalidPropertiesFormatException;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

import database.dataset.Depot;
import database.dataset.Employe;
import database.dataset.Fermeture;
import database.dataset.Utilisateur;
import database.migration.SqlFactory;

public class NormalisedDepotAndFermeture {
	private final Set<Depot> depots;
	private final Set<Fermeture> fermetures;
	private final Set<Employe> employes;
	private final Set<Utilisateur> utilisateurs;

	public NormalisedDepotAndFermeture(Set<Depot> depots,
			Set<Fermeture> fermetures, Set<Employe> employes,
			Set<Utilisateur> utilisateurs) {
		super();
		this.depots = depots;
		this.fermetures = fermetures;
		this.employes = employes;
		this.utilisateurs = utilisateurs;
	}

	public Set<Depot> getDepots() {
		return depots;
	}

	public Set<Fermeture> getFermetures() {
		return fermetures;
	}

	public Set<Employe> getEmployes() {
		return employes;
	}

	public Set<Utilisateur> getUtilisateurs() {
		return utilisateurs;
	}

	public static boolean sameEmploye(Employe a, Employe b){
		return a.getEmploye_nom().equals(b.getEmploye_nom());
	}
	
	public static boolean sameUtilisateur(Utilisateur a, Utilisateur b){
		return a.getUtilisateur_nom().equals(b.getUtilisateur_nom());
	}
	
	public static int dejaEmploye(Set<Employe> liste, Employe employe){
		for (Employe deja : liste){
			if (sameEmploye(deja, employe))
				return deja.getemploye_p_id();
		}
		return 0;
	}
	
	public static NormalisedDepotAndFermeture from(List<ReadFermeture> rflst, List<ReadDepot> rdlst) throws InvalidPropertiesFormatException, FileNotFoundException, IOException{
		System.out.println("normalise depot et fermeture");
		Set<Depot> depots = new HashSet<>();
		Set<Fermeture> fermetures = new HashSet<>();
		Set<Employe> employes = new HashSet<>();
		Set<Utilisateur> utilisateurs = new HashSet<>();
		//commencons par depot et fermeture qui sont migré tel quel
		for (ReadDepot rd : rdlst){
			depots.add(rd.getDepot());
		}
		for (ReadFermeture rf : rflst){
			fermetures.add(rf.getFermeture());
		}
		/*etape speciale de normalisation car plusieurs foie le meme nom apparait dans
		 * des orthographes différents dans la table employe et utilisateur*/
	    Properties changementDeNom = new Properties();
	    changementDeNom.loadFromXML(new FileInputStream("importation_changement_nom_employe_utilisateur.xml"));
		for (ReadDepot rd : rdlst){
			for (Map.Entry<Object, Object> entry : changementDeNom.entrySet()){
				if (rd.employe.getEmploye_nom().equals(entry.getKey()))
					rd.employe.setEmploye_nom((String)entry.getValue());
				if (rd.utilisateur.getUtilisateur_nom().equals(entry.getKey()))
					rd.utilisateur.setUtilisateur_nom((String)entry.getValue());
			}
		}
		for (ReadFermeture rf : rflst){
			for (Map.Entry<Object, Object> entry : changementDeNom.entrySet()){
				if (rf.employe.getEmploye_nom().equals(entry.getKey()))
					rf.employe.setEmploye_nom((String)entry.getValue());
				if (rf.utilisateur.getUtilisateur_nom().equals(entry.getKey()))
					rf.utilisateur.setUtilisateur_nom((String)entry.getValue());
				
			}
		}
		//utilisateur et employer sont des pairs (un seul pour chaque employe)
		//"du moin pendant la migration"
		//dépot et fermeture eux on une clé qui pointe à ce dernier
		//donc il faut les changer au besoin
		for (ReadDepot rd : rdlst){
			int occurence = dejaEmploye(employes, rd.getEmploye());
			if (occurence==0){
				employes.add(rd.getEmploye());
				utilisateurs.add(rd.getUtilisateur());
			}
			else{
				for (Depot depot : depots)
					if (depot.getEmploye_fk_id()==rd.getEmploye().getemploye_p_id())
						depot.setEmploye_fk_id(occurence);
				for (Fermeture fermeture : fermetures)
					if (fermeture.getemploye_fk_id()==rd.getEmploye().getemploye_p_id())
						fermeture.setemploye_fk_id(occurence);
			}
		}
		for (ReadFermeture rf : rflst){
			int occurence = dejaEmploye(employes, rf.getEmploye());
			if (occurence==0){
				employes.add(rf.getEmploye());
				utilisateurs.add(rf.getUtilisateur());
			}
			else{
				for (Depot depot : depots)
					if (depot.getEmploye_fk_id()==rf.getEmploye().getemploye_p_id())
						depot.setEmploye_fk_id(occurence);
				for (Fermeture fermeture : fermetures)
					if (fermeture.getemploye_fk_id()==rf.getEmploye().getemploye_p_id())
						fermeture.setemploye_fk_id(occurence);
			}
		}
		//ça doit être passable
		return new NormalisedDepotAndFermeture(depots, fermetures, employes, utilisateurs);
	}


	/**
	 * @param args
	 * @throws IOException 
	 * @throws SQLException 
	 * @throws FileNotFoundException 
	 */
	public static void main(String[] args) throws FileNotFoundException, SQLException, IOException {
		Connection connection = SqlFactory.connect(SqlFactory.loadProperties("hotel_orford_import.xml"));

		NormalisedDepotAndFermeture data = NormalisedDepotAndFermeture.from(
				  							          ReadFermeture.from(connection), 
				  							          ReadDepot.from(connection)
				  						   );
		for (Fermeture f : data.getFermetures())
			System.out.println(f.toString());
		for (Depot d : data.getDepots())
			System.out.println(d.toString());
		for (Employe e : data.getEmployes())
			System.out.println(e.toString());
		for (Utilisateur u : data.getUtilisateurs())
			System.out.println(u.toString());
		
		connection.close();
			
			
	}

}