import java.io.File;
import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;
import java.io.FileOutputStream;
import java.io.FileInputStream;
import java.io.Serializable;
import java.io.IOException;

import java.util.HashMap;

import java.security.SecureRandom;
import java.security.NoSuchAlgorithmException;

import java.rmi.server.UnicastRemoteObject;
import java.rmi.RemoteException;

class AgendaImpl extends UnicastRemoteObject implements Agenda
{
    static final long serialVersionUID = 0xdefaced;

    /** Les utilisateurs et leurs droits */
    private String [][]users = {
	{"bob", "flop", "rw"},
	{"alice", "flup", "w"},
	{"john", "coin", "r"},
	};

    /** Liste des sessions */
    private static HashMap sessions = new HashMap();

    /** Semaines des RDV */
    private Semaine semaines[] = new Semaine[ 52 ];

    /** Mutex sur les sauvegardes/chargements */
    private static Object statemutex = new Object();

    public AgendaImpl() throws RemoteException {
	super();
    }

    /**
     * Authentifie un utlisateur 
     * @param user Le nom d'utilisateur
     * @param pass Le mot de passe
     * @return La session ou null si échoué
     */
    public Session login(String user, String pass)
	throws RemoteException, AgendaException
    {
	for(int i=0;i<users.length;i++)
	    {
		if ( users[i][0].equals(user) && users[i][1].equals(pass) )
		    {

			String sessid = "";
			try {
			    /* Génération d'un nombre aléatoire */
			    SecureRandom prng = SecureRandom.getInstance("SHA1PRNG");
			    sessid = new Integer( prng.nextInt() ).toString();
			}
			catch (NoSuchAlgorithmException e) {
			    System.out.println("SHA1 non supporté!");
			    System.exit(1);
			}

			/* Enregistrer la session */
			sessions.put(sessid, users[i][2]);

			return new Session(sessid);
		    }
	    }

	throw new AgendaException("Login incorrect");
    }

    /**
     * Délogge un utilisateur
     * @param s La session à délogger
     */
    public void logout(Session s)
	throws RemoteException
    {
	if ( sessions.containsKey(s.getID()) )
	    sessions.remove(s.getID());
    }



    /**
     * Vérifie si l'utilisateur a les permissions nécessaires
     * @param s La session
     * @param type Les permission à vérifier (format : "r", "w")
     */
    private void checkPerms(Session s, String type)
	throws AgendaException
    {
	if ( s == null )
	    throw new AgendaException("Vous devez vous identifier pour utiliser l'agenda");

	if ( sessions.containsKey(s.getID()) )
	    {
		String gottype = (String)sessions.get(s.getID());
		if ( ! gottype.matches(".*" + type + ".*") )
		    throw new AgendaException("Vous n'avez pas les droits nécessaires pour cette action");
	    }
	else
	    throw new AgendaException("Session incorrecte.");
    }

    /**
     * Charge un agenda depuis son fichier d'état
     * @param fichier Le chemin vers lequel sauver
     * @return L'agenda chargé
     */
    public static Agenda chargeEtat(String fichier)
    {
	synchronized(statemutex) {
	    try {

		File f = new File(fichier);
		ObjectInputStream in = new ObjectInputStream(new FileInputStream(f));

		/* Désérialiser */
		Semaine s[] = (Semaine[])in.readObject();
		String [][]u = (String[][])in.readObject();
		in.close();

		AgendaImpl a = new AgendaImpl();
		a.semaines = s;
		a.users = u;

		return a;
	    } catch(Exception e) {
		return null;
	    }
	}
    }

    /**
     * Sauve l'état de l'agenda dans un fichier
     * @param fichier Le chemin vers lequel sauver
     */
    public synchronized void sauverEtat(String fichier)
    {
	synchronized(semaines) {
	    synchronized(statemutex) {
		try {
		    File f = new File(fichier);
		    ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f));

		    /* Sérialisation */
		    out.writeObject(semaines);
		    out.writeObject(users);

		    out.close();
		} catch(IOException e) {
		    System.out.println("Erreur de sauvegarde !");
		}
	    }
	}
    }

    /**
     * Recherche une plage disponible dans une plage donnée 
     * @param ses La session ("r" nécessaire)
     * @param p La plage à tester
     * @param duree La durée nécessaire
     * @return La plage trouvée ou null si aucune
     */
    public PlageJournee plageDisponible(Session ses, Plage p, int duree)
	throws RemoteException, AgendaException
    {
	checkPerms(ses, "r");

	synchronized(semaines) {

	    int res_s=0, res_j=0, res_h=0;
	    
	    /* Parcours des semaines */
	    for(int s=p.getSemDebut(); s<=p.getSemFin(); s++)
		{
		    res_s = s;

		    if ( semaines[s] == null )
			return new PlageJournee(res_s, res_j, res_h, duree);

		    int j_deb = 0, j_fin = 6;
		    if ( s == p.getSemDebut() )
			j_deb = p.getJourDebut();

		    if ( s == p.getSemFin() )
			j_fin = p.getJourFin();

		    /* Parcours des jours */
		    for(int j=j_deb; j<=j_fin; j++)
			{
			    res_j = j;

			    if ( semaines[s].jours[j] == null )
				return new PlageJournee(res_s, res_j, res_h, duree);

			    int h_deb = 0, h_fin = 7;
			    if ( j == p.getHeureDebut() && s == p.getSemDebut() )
				h_deb = p.getHeureDebut();
			    if ( j == p.getHeureFin() && s == p.getSemFin() )
				h_fin = p.getHeureFin();

			    int count = 0;
			    /* Parcours des périodes */
			    for(int i = h_deb; i<=h_fin; i++)
				{
				    res_h = i;
				    /* Si la période est disponible */
				    if ( semaines[s].jours[j].periodeDispo(i) )
					{
					    count++;
					    if ( count == duree )
						return new PlageJournee(res_s, res_j, res_h - duree + 1, duree);
					}
				    else
					count = 0;
				}
			    res_h = 0;

			}

		    res_j = 0;

		}

	    return null;
	}

    }

    /**
     * Retourne le rendezVous associé à la période demandée 
     * @param ses La session ("r" nécessaire)
     * @param sem Le numéro de la semaine
     * @param jour Le jour de la semaine
     * @param heure L'heure du jour
     * @return Le rendez-vous de la période
     */
    public RendezVous periodeVersRDV(Session ses, int sem, int jour, int heure)
	throws RemoteException, AgendaException
    {
	checkPerms(ses, "r");

	synchronized(semaines) {
	    try {
		return (semaines[sem].jours[jour].getPeriode(heure)).getRdv();
	    } catch (Exception e) {
		throw new AgendaException("Aucun RDV pendant cette periode");
	    }
	}
    }

    /**
     *  Prend un RDV sur la plage demandée
     * @param ses La session ("w" nécessaire)
     * @param rdv Le rendez vous à prendre
     */
    public void prendreRDV(Session ses, RendezVous rdv)
	throws AgendaException, RemoteException
    {
	checkPerms(ses, "w");

	synchronized(semaines) {

	    PlageJournee p = rdv.getPlage();

	    int s_deb = p.getSemaine();
	    int s_fin = s_deb;
	    if ( rdv.repetSem() )
		s_fin = 51;

	    /* Verifier la dispo de la plage */
	    for(int s=s_deb; s<=s_fin; s++)
		{
		    if ( semaines[s] == null )
			continue;

		    int j_deb = p.getJour();
		    int j_fin = j_deb;
		    if ( rdv.repetJour() )
			j_fin = 6;

		    for(int j=j_deb; j<=j_fin; j++)
			{
			    if ( semaines[s].jours[j] == null )
				continue;

			    for(int i = p.getHeureDebut(); i<p.getHeureFin(); i++)
				if ( ! semaines[s].jours[j].periodeDispo(i) )
				    throw new AgendaException("Periode (" + s + "," + j + "," + i + ") non disponible");
			}

		}

	    /* Réellement inscrire le RDV */
	    for(int s=s_deb; s<=s_fin; s++)
		{
		    if ( semaines[s] == null )
			semaines[s] = new Semaine(s);

		    int j_deb = p.getJour();
		    int j_fin = j_deb;
		    if ( rdv.repetJour() )
			j_fin = 6;

		    for(int j=j_deb; j<=j_fin; j++)
			{
			    if ( semaines[s].jours[j] == null )
				semaines[s].jours[j] = new Journee(j);
		
			    for(int i = p.getHeureDebut(); i<p.getHeureFin(); i++)
				semaines[s].jours[j].setPeriode(i, rdv);
			}
		}
	}
    }

    /**
     * Modifier un RDV oldrdv par le nouveau newrdv 
     * @param ses La session ("w" nécessaire)
     * @param oldrdv L'ancien Rendez Vous
     * @param newrdv Le nouveau Rendez Vous
     */
    public void modifierRDV(Session ses, RendezVous oldrdv, RendezVous newrdv)
	throws AgendaException, RemoteException
    {
	annulerRDV(ses, oldrdv);
	prendreRDV(ses, newrdv);
    }
    
    /**
     * Annule le RendezVous rdv 
     * @param ses La session ("w" nécessaire)
     * @param rdv Le rendez vous à annuler
     */
    public void annulerRDV(Session ses, RendezVous rdv)
	throws RemoteException, AgendaException
    {
	checkPerms(ses, "w");

	synchronized(semaines) {

	    PlageJournee p = rdv.getPlage();

	    int s_deb = p.getSemaine();
	    int s_fin = s_deb;
	    if ( rdv.repetSem() )
		s_fin = 51;

	    for(int s=s_deb; s<=s_fin; s++)
		{
		    int j_deb = p.getJour();
		    int j_fin = j_deb;
		    if ( rdv.repetJour() )
			j_fin = 6;

		    for(int j=j_deb; j<=j_fin; j++)
			{
			    for(int i = p.getHeureDebut(); i<=p.getHeureFin(); i++)
				semaines[s].jours[j].annulerPeriode(i);
			}
		}
	}
    }

    /**
     * Affiche les rendezvous sur la plage donnée
     * @param ses La session ("r" nécessaire)
     * @param p La plage
     * @return La représentation de l'agenda
     */
    public String afficher(Session ses, Plage p)
	throws RemoteException, AgendaException
    {
	checkPerms(ses, "r");

	synchronized(semaines) {

	    String msg = "";
	    for(int i=p.getSemDebut(); i<=p.getSemFin(); i++)
		{
		    msg += "====================\n";
		    if ( semaines[i] == null )
			{
			    msg += ">> Semaine " + i + " : vide <<\n";
			    continue;
			}
		    else
			msg += ">> Semaine " + i + " <<\n";

		    int j_deb = 0;
		    if ( i == p.getSemDebut() )
			j_deb = p.getJourDebut();

		    int j_fin = 6;
		    if ( i == p.getSemFin() )
			j_fin = p.getJourFin();

		    for(int j=j_deb ; j<=j_fin ; j++)
			{
			    msg += "-------------------\n";
			    if ( semaines[i].jours[j] == null )
				{
				    msg += "[ Jour " + j + " : vide ]\n";
				    continue;
				}
			    else
				msg += "[ Jour " + j  + " ]\n";

			    int h_deb = 0;
			    if ( j == p.getJourDebut() && i == p.getSemDebut() )
				h_deb = p.getHeureDebut();

			    int h_fin = 7;
			    if ( j == p.getJourFin() && i == p.getSemFin() )
				h_fin = p.getHeureFin();

			    for(int k=h_deb; k<=h_fin; k++)
				{
				    Periode per = semaines[i].jours[j].getPeriode(k);
				    if ( per != null )
					msg += "\t* P" + k + " : " + per.getRdv() + "\n";
				    else
					msg += "\t* P" + k + " : VIDE\n";
				}

			}
		}

	    return msg;
	}
    }

    /** 
     * Réplique l'agenda à travers le réseau
     * @param ses La session ("r" nécessaire)
     * @return L'agenda
     */
    public Semaine[] repliquer(Session ses)
	throws RemoteException, AgendaException
    {
	checkPerms(ses, "r");

	synchronized(semaines) {
	    return semaines;
	}

    }
}