/*
    * Créé le 24 janv. 2005
    */
   
   package atg.metier.dao.hibernate;
   
   /**
    * <p>
    * Titre : Pool de connexions aux bases de données en JDO
   * </p>
   * <p>
   * Description : Gestion de pool de connexion
   * </p>
   * <p>
   * Copyright : FERRARI Olivier
   * </p>
   * 
   * @author YSMAL Vincent
   * @version 1.0 Ce logiciel est régi par la licence CeCILL soumise au droit
   *          français et respectant les principes de diffusion des logiciels
   *          libres. Vous pouvez utiliser, modifier et/ou redistribuer ce
   *          programme sous les conditions de la licence CeCILL telle que
   *          diffusée par le CEA, le CNRS et l'INRIA sur le site
   *          http://www.cecill.info.
   * 
   * Le fait que vous puissiez accéder à cet en-tête signifie que vous avez pris
   * connaissance de la licence CeCILL, et que vous en avez accepté les termes.
   */
  import javax.jdo.PersistenceManager;
  
  import org.hibernate.Session;
  import org.hibernate.SessionFactory;
  import org.hibernate.cfg.Configuration;
  
  import atg.metier.dao.jdbc.exception.ATGDaoBaseIndisponibleException;
  import atg.service.constante.AtgConstantes;
  import atg.service.log.AtgLogManager;
  import atg.util.service.ATGBasicClass;
  
  /**
   * @author Administrateur
   */
  public class ATGDaoHibernatePoolDataSource extends ATGBasicClass {
  	// ***************************************************************************
  	// Attributs
  	// ***************************************************************************
  
  	/**
  	 * Référence du pool par défaut
  	 */
  	public static final String								CSTE_DEFAULT_REFERENCE	= "Reference par defaut";
  
  	/**
  	 * Instances uniques (pour une référence donnée) du pool de connections
  	 */
  
  	private static java.util.Hashtable<String,ATGDaoHibernatePoolDataSource>				instances								= new java.util.Hashtable<String,ATGDaoHibernatePoolDataSource>();
  
  	/**
  	 * Commande à executer sur la connexion nouvellement créées
  	 */
  	// private static java.util.Hashtable connexionRequests = new
  	// java.util.Hashtable();
  	/**
  	 * nombre de connections maximum crées sur la base de données
  	 */
  	private static final int									MAX_CONNECTION					= 10;
  
  	/**
  	 * nombre de connections automatiquement crées au démarrage du pool
  	 */
  	private static final int									START_CONNECTION				= 1;
  
  	/**
  	 * Delai d'attente pour l'obtention d'une connection, exemple 3000 = 3
  	 * secondes
  	 */
  	private static final int									MAX_WAIT								= 3000;
  
  	/**
  	 * delai au dela duquel une connexion est consideree comme perdue, exemple
  	 * 60000 = 60 secondes
  	 */
  	private static final int									MAX_CTRL_TIME						= 60000;
  
  	/**
  	 * Attribut de la connexion standard
  	 */
  	/*
  	 * private String DRIVER_NAME = null; private String USER_NAME = null; private
  	 * String USER_PWD = null; private String DB_NAME = null;
  	 */
  	/**
  	 * liste des connections créées mais non utilisées
  	 */
  	private java.util.Vector<Session>									freeConnections					= null;
  
  	/**
  	 * nombre de connections en cours (demandées mais pas encore libérées)
 	 */
 	private int																checkedOut							= 0;
 
 	/**
 	 * driver permettant d'obtenir une connection
 	 */
 	// protected java.sql.Driver driver = null;
 	/**
 	 * référence du pool de données
 	 */
 	protected String													reference								= "";
 
 	/**
 	 * ensemble des connections creees sur la base de donnees
 	 */
 	protected java.util.Hashtable							ctrlConnexion						= null;
 
 	protected static java.util.logging.Logger	logger_									= null;
 
 	private SessionFactory										sessionFactory					= null;
 
 	/**
 	 * Ecriture des logs
 	 */
 	protected java.util.logging.Logger getLogger() {
 		if (logger_ == null)
 			logger_ = AtgLogManager
 					.getLog(AtgConstantes.ATG_LOG_CATEGORY_METIER_DAO_HIBERNATE);
 
 		return logger_;
 	}
 
 	private ATGDaoHibernatePoolDataSource(String reference) {
 		/*
 		 * String properties = atg.service.constante.AtgConstantesWF
 		 * .getValue("PATH_HIBERNATE_FILE");
 		 * 
 		 * Properties props = new Properties(); String nomFichier = properties +
 		 * reference + "_JDO.properties"; try { props.load(new
 		 * FileInputStream(nomFichier)); //props.setProperty("host",
 		 * "128.96.197.228"); //logFinest("Connection à la machine : " +
 		 * "128.96.197.228"); //props.setProperty("server", "versant"); //pmf =
 		 * JDOHelper.getPersistenceManagerFactory(props);
 		 */
 		sessionFactory = null;
 		sessionFactory = new Configuration().configure().buildSessionFactory();
 
 		// TODO Pensez à rendre cette partie dynamique, pour le moment c'est le
 		// fichier
 		// Hibernate.hbm.xml par défaut
 
 		/*
 		 * } catch (FileNotFoundException e) { this .logSevere("Immpossible de
 		 * trouver le fichier de properties pour le serveur JDO : " + nomFichier); }
 		 * catch (IOException e) { this.logSevere("Erreur d'entrée/sortie dans le
 		 * fichier de properties : " + nomFichier); }
 		 */
 	}
 
 	/**
 	 * Renvoie une connection au serveur de persistance.
 	 * 
 	 * @return PersistenceManager Reférence vers le gestionnaire de persistance
 	 *         Jdo
 	 */
 	public Session getSession() throws ATGDaoBaseIndisponibleException {
 		try {
 			Session sessionFactory = getSession(MAX_WAIT);
 			return sessionFactory;
 		} catch (ATGDaoBaseIndisponibleException exception) {
 			// ecriture d'une trace + renvoie de la valeur 'null'
 			logSevere("Impossible de fournir une connection correcte : "
 					+ exception.getCause() + " / " + exception.getMessage());
 			throw new ATGDaoBaseIndisponibleException();
 		}
 	}
 
 	/**
 	 * Renvoie une connection à la base de données. Attend au maximum 'timeout'
 	 * millisecondes l'obtention de la connection.
 	 * 
 	 * @param timeout
 	 *          Temps d'attente maximum de la connection
 	 * @throws java.sql.SQLException
 	 *           Exception SQL
 	 * @return java.sql.Connection Connection à la base de données
 	 */
 	protected synchronized Session getSession(long timeout)
 			throws ATGDaoBaseIndisponibleException {
 		long startTime = System.currentTimeMillis(); // heure d'appel à la fonction
 		long remaining = timeout; // temps restant
 		Session conn = null; // connection à la base
 
 		while ((conn = getPooledSession()) == null) {
 			// la connection n'a pas ete obtenue...
 			try {
 				// attente du delai souhaité
 				// le processus est reveillé des qu'une connection se libère
 				logFinest("Attente d'une connection (" + timeout + ").");
 				wait(timeout);
 			} catch (InterruptedException exception) {
 				// le processus d'attente est interrompu
 			}
 
 			// calcul du temps restant - temps que l'on peut encore passer
 			// à attendre
 			remaining = timeout - (System.currentTimeMillis() - startTime);
 
 			if (remaining <= 0) {
 				// le delai d'attente est expiré
 				throw new ATGDaoBaseIndisponibleException(
 						"getSessionFactory() time-out");
 			}
 		}
 		// vérifie si la connexion demeure valide
 		if (!isConnectionOk(conn)) {
 			// problème de connexion => refaire une tentative avec le delai restant
 			return getSession(remaining);
 		}
 
 		// mise a jour des informations de suivi
 		checkedOut++;
 
 		return conn;
 	}
 
 	/**
 	 * Renvoie une connection.
 	 * 
 	 * @throws ATGDaoBaseIndisponibleException
 	 * @return PersistenceManager Connection au gestionnaire de persistance
 	 */
 	protected Session getPooledSession() throws ATGDaoBaseIndisponibleException {
 		Session conn = null;
 
 		// gestion des traces
 		logFinest("Une connection est demandee au pool.");
 
 		// existe t'il une connection de libre ?
 		if (freeConnections.size() > 0) {
 			// la première est récupèrée
 			conn = (Session) freeConnections.firstElement();
 			freeConnections.removeElementAt(0);
 		} else {
 			// le nombre maximum des connexions creees a ete atteint
 			// => essai de liberation
 			if (checkedOut == MAX_CONNECTION) {
 				logWarning("Attention, le nombre maximum de connexions creees sur le session factory Hibernate est atteint : "
 						+ MAX_CONNECTION);
 				ckeckCtrlConnexion();
 			}
 
 			// rmq : pas de 'else' car ckeckCtrlConnexion() peut avoir libere des
 			// connexions
 			// et mis a jour 'checkedOut'
 
 			// il n'existe pas de connection de libre => on en crée une nouvelle
 			// (dans la limite)
 			if (checkedOut < MAX_CONNECTION)
 				conn = newConnection();
 		}
 
 		return conn;
 	}
 
 	/**
 	 * Vérifie si toutes les connexions ont bien été rendues au pool.
 	 */
 	public void ckeckCtrlConnexion() {
 		// liste des connexions
 		java.util.Enumeration conns = ctrlConnexion.keys();
 
 		// parcours des connexions et verification de leur validité
 		do {
 			Object conn = conns.nextElement();
 			long delta = System.currentTimeMillis()
 					- ((Long) (ctrlConnexion.get(conn))).longValue();
 			if ((!freeConnections.contains(conn)) && (delta > MAX_CTRL_TIME)) {
 				// la connexion est consideree comme perdue
 				// => on la libere
 				ctrlConnexion.remove(conn);
 				logSevere("La connexion " + conn
 						+ " est consideree comme perdue : elle n'a pas ete rendue au pool.");
 				// le plus important : mise à jour du compteur de connexions
 				checkedOut--;
 
 				// fermeture de la connexion
 				((PersistenceManager) conn).close();
 			}
 		} while (conns.hasMoreElements());
 	}
 
 	/**
 	 * Création d'une nouvelle connection.
 	 * 
 	 * @throws ATGDaoBaseIndisponibleException
 	 * @return PersistenceManager Nouvelle connection à la base de données
 	 */
 	protected Session newConnection() throws ATGDaoBaseIndisponibleException {
 		this.logFinest("Demande d'une reférence sur le SessionFactory");
 		Session session = (Session) this.sessionFactory.openSession();
 		if (session != null) {
 			logFinest("  newConnection() ok ");
 		} else {
 			logSevere("Impossible de récupérer une Session sur le SessionFactory");
 		}
 		return session;
 	}
 
 	/**
 	 * Contrôle si la connection specifiée est valide.
 	 * 
 	 * @param conn
 	 *          Connection à tester
 	 * @return boolean Connection valide ou non
 	 */
 	protected boolean isConnectionOk(Session conn) {
 		
 		//TODO Ecrire ce qu'il faut pour gérer l'état de la Session
 		return true;
 		/*if (!conn.isConnected()) {
 			return true;
 		} else
 			return false;
 			*/
 	}
 
 	/**
 	 * Renvoie l'instance unique du pool de connections pour la référence donnée.
 	 * 
 	 * @param reference
 	 *          Référence du pool de connection
 	 * @return StdPoolDataSource Instance d'un pool d'accès aux données
 	 */
 	static public ATGDaoHibernatePoolDataSource getInstance(String reference) {
 		if ((instances.get(reference) != null)) {
 			// l'instance pour cette référence existe déjà
 			return instances.get(reference);
 		} else {
 			// création de l'instance 'reference'
 			ATGDaoHibernatePoolDataSource instance = new ATGDaoHibernatePoolDataSource(
 					reference);
 			// initialisation de cette instance
 			instance.initPool();
 			// ajout de l'instance à la liste des instances
 			instances.put(reference, instance);
 			return instance;
 		}
 	}
 
 	/**
 	 * Initialisation du pool. Appelé lors de l'instanciation.
 	 */
 	protected void initPool() {
 		freeConnections = new java.util.Vector<Session>();
 
 		// un certain nombre de connections sont créees automatiquement
 		// lors de l'instanciation du pool
 		for (int i = 0; i < START_CONNECTION; i++) {
 			try {
 				freeConnections.addElement(newConnection());
 			} catch (ATGDaoBaseIndisponibleException exception) {
 				logSevere("Impossible d'initialiser le pool de Connection Hibernate!"
 						+ exception.getCause() + " / " + exception.getMessage());
 			}
 		}
 	}
 
 	/**
 	 * Libére la connection spécifiée.
 	 * 
 	 * @param conn
 	 *          Connection à libérer
 	 */
 	public synchronized void release(Session conn) {
 		// gestion des traces
 		logFinest("Un Session hibernate est liberee : "
 				+ (freeConnections.size() + 1) + " session(s) libre(s");
 
 		// la connection est recyclee - ajout à la liste des connections libres
 		freeConnections.addElement(conn);
 		checkedOut--;
 
 		// on signale aux processus qui 'dorment' (attente d'une connection)
 		// qu'une connection vient de se liberer
 		notifyAll();
 	}
 }