package atg.service.log;
   
   import java.io.FileInputStream;
   import java.util.Properties;
   import java.util.StringTokenizer;
   import java.util.logging.Handler;
   import java.util.logging.Level;
   import atg.service.constante.AtgConstantesWF;
   
  /**
   * Titre : Manageur de logs<BR>
   * Description : Gestion des logs<BR>
   * Le chemin de logging.properties indiqué dans le fichier de constantes<br>
   * est cherché d'abord dans le file system sinon dans le classpath du jar<br>
   * <p>
   * Copyright : FERRARI Olivier
   * </p>
   * 
   * @author BOSC Frédéric repris et modifié par FERRARI Olivier
   * @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.
   */
  
  public class AtgLogManager {
  
  	// ***************************************************************************
  	// Attributs
  	// ***************************************************************************
  
  	/**
  	 * Log par défaut
  	 */
  	protected static java.util.logging.Logger defaultLogger_ = null; // Log
  
  	// par
  	// défaut
  
  	/**
  	 * Table des initialisation des logs
  	 */
  	protected static java.util.Hashtable<String, String> logInit = null;
  
  	/**
  	 * Chemin du fichier logging.properties
  	 */
  	protected static String pathFileProperties = null;
  
  	/**
  	 * Proprietés des logs
  	 */
  	protected static Properties lesProperties = null;
  
  	/**
  	 * Nom des Handlers à gèrer
  	 */
  	protected static String[] lesHandlers = null;
  
  	// ***************************************************************************
  	// Méthodes statiques
  	// ***************************************************************************
  
  	/**
  	 * Contient l'initialisation des logs boolean Initialisation ou pas
  	 */
  	protected static boolean isInit = false;
  
  	/**
  	 * Fixe le fichier de paramètrage
  	 * 
  	 * @param newPathFileProperties
  	 *            Chemin du fichier logging.properties
  	 */
  	public static void setPathFileProperties(String newPathFileProperties) {
  		pathFileProperties = newPathFileProperties;
  	}
  
  	/**
  	 * Initialise le manageur de logs
  	 * Cherche d'abord logging.properties sur le filesystem sinon dans le classpath du jar
  	 * @throws java.io.IOException
  	 *             Impossible de lire le fichier
  	 */
  	public static void init() throws java.io.IOException {
  		// Initialisation des properties
  		lesProperties = new Properties();
  		try {
  			lesProperties.load(new FileInputStream(pathFileProperties));
  		} catch (java.io.IOException e) {
  			if (pathFileProperties.charAt(0) != '/'){
  				pathFileProperties = "/"+pathFileProperties;
  			}
  			java.io.InputStream in = AtgLogManager.class.getResourceAsStream(pathFileProperties);
 			if (in==null){
 				throw (new java.io.IOException(pathFileProperties+ " n'est ni dans le File System ni dans le CLASSPATH"));
 			}
 			lesProperties.load(in);
 		}
 		// java.util.logging.Logger.getAnonymousLogger().log(java.util.logging.Level.
 		// SEVERE, "Lectures des Handlers désirés ");
 		StringTokenizer lesTokens = new StringTokenizer(lesProperties
 				.getProperty("handlers"), ",");
 		lesHandlers = new String[lesTokens.countTokens()];
 		for (int i = 0; i < lesHandlers.length; i++) {
 			lesHandlers[i] = lesTokens.nextToken().trim();
 			// java.util.logging.Logger.getAnonymousLogger().log(java.util.logging.Level.
 			// SEVERE, "-- Handler : " + lesHandlers[i]);
 		}
 		logInit = new java.util.Hashtable<String, String>();
 	}
 
 	/**
 	 * Retourne le log associée au nom
 	 * 
 	 * @param logName
 	 *            Categorie du log
 	 * @return java.util.logging.Logger Log associée à la categorie
 	 */
 	public static java.util.logging.Logger getLog(String logName) {
 		// log initialisée ?
 		if (!isInit) {
 			try {
 				init();
 				isInit = true;
 			} catch (Exception exception) {
 				java.util.logging.Logger.getAnonymousLogger().log(
 						java.util.logging.Level.SEVERE,
 						"Impossible d'initialiser les logs", exception);
 			}
 		}
 
 		// recuperation du log
 		java.util.logging.Logger logger = java.util.logging.Logger
 				.getLogger(logName);
 
 		// initialisation du log
 		if (logInit.get(logName) == null) {
 			initLogger(logger, logName);
 		} else {
 			logInit.put(logName, "-");
 
 		}
 		return logger;
 	}
 
 	/**
 	 * Retourne le log par défaut
 	 * 
 	 * @return java.util.logging.Logger Log par défaut
 	 */
 	public static java.util.logging.Logger getDefaultLog() {
 		// log initialisé ?
 		if (!isInit) {
 			try {
 				init();
 				isInit = true;
 			} catch (Exception exception) {
 				exception.printStackTrace();
 			}
 		}
 
 		if (defaultLogger_ == null) {
 			// recuperation du log par défaut
 			defaultLogger_ = java.util.logging.Logger.getAnonymousLogger();
 
 			// initialisation du log
 			if (logInit.get("java.util.logging.Logger.getAnonymousLogger()") == null) {
 				initLogger(defaultLogger_, "");
 			} else {
 				logInit.put("java.util.logging.Logger.getAnonymousLogger()",
 						"-");
 			}
 		}
 
 		return defaultLogger_;
 	}
 
 	/**
 	 * Initialise du log
 	 * 
 	 * @param logger
 	 *            Log à initialiser
 	 * @param logName
 	 *            Catégorie du log associé
 	 */
 	protected static void initLogger(java.util.logging.Logger logger,
 			String logName) {
 		java.util.logging.ConsoleHandler consoleHandler = null;
 		java.util.logging.FileHandler fileHandler = null;
 
 		logger.setUseParentHandlers(false);
 		Level levelTemp = null;
 
 		// Réucpération du level pour ce logger
 		if (lesProperties.getProperty(logName + ".level") != null) {
 			levelTemp = Level.parse(lesProperties.getProperty(logName
 					+ ".level"));
 		}
 		// on regarde si le level pas defaut existe
 		else if (lesProperties.getProperty(".level") != null) {
 			levelTemp = Level.parse(lesProperties.getProperty(".level"));
 		} else {
 			levelTemp = java.util.logging.Level.FINEST;
 		}
 		// On vide les Handlers
 		Handler[] handlersTemp = logger.getHandlers();
 		for (int h = 0; h < handlersTemp.length; h++) {
 			logger.removeHandler(handlersTemp[h]);
 		}
 		logger.setLevel(levelTemp);
 		// On parcour tout les handlers désirés et on les ajoute
 		for (int i = 0; i < lesHandlers.length; i++) {
 			if (lesHandlers[i]
 					.compareToIgnoreCase("java.util.logging.ConsoleHandler") == 0) {
 				// ajout de la console
 				consoleHandler = new java.util.logging.ConsoleHandler();
 				consoleHandler.setFormatter(new AtgLogFormatter());
 
 				consoleHandler.setLevel(levelTemp);
 				logger.addHandler(consoleHandler);
 			} else if (lesHandlers[i]
 					.compareToIgnoreCase("java.util.logging.FileHandler") == 0) {
 				// ajout du fichier
 				try {
 					// determination du nom du fichier
 					String file = AtgConstantesWF.getValue("PATH_LOG_FILE");
 					int posPoint = file.lastIndexOf(".");
 					String realFile = file.substring(0, posPoint) + "-"
 							+ logName + file.substring(posPoint, file.length());
 
 					// 500000 nombre de bytes par défaut écrit dans les fichiers
 					// de logs
 					if ((AtgConstantesWF.getValue("LOG_NB_BYTES_MAX") != null)
 							&& (!AtgConstantesWF.getValue("LOG_NB_BYTES_MAX")
 									.equals(""))) {
 						fileHandler = new java.util.logging.FileHandler(
 								realFile, (new Integer(AtgConstantesWF
 										.getValue("LOG_NB_BYTES_MAX")))
 										.intValue(), 2);
 					} else {
 						fileHandler = new java.util.logging.FileHandler(
 								realFile, 500000, 2);
 					}
 					fileHandler.setFormatter(new AtgLogFormatter());
 
 					fileHandler.setLevel(levelTemp);
 				} catch (java.io.IOException exception) {
 					logger
 							.severe("Impossible d'initialiser le fichier de log - "
 									+ exception.getMessage());
 				}
 
 				if (fileHandler != null) {
 					logger.addHandler(fileHandler);
 				}
 			}
 
 		}
 		logger.finest("Logger initialisé");
 		/*
 		 * java.util.logging.ConsoleHandler consoleHandler = null;
 		 * java.util.logging.FileHandler fileHandler = null;
 		 * 
 		 * logger.setUseParentHandlers(false); // ajout de la console /* if
 		 * (consoleHandler == null) { consoleHandler = new
 		 * java.util.logging.ConsoleHandler(); consoleHandler.setFormatter(new
 		 * AtgLogFormatter()); if (logger.getLevel() != null)
 		 * consoleHandler.setLevel(logger.getLevel()); else
 		 * consoleHandler.setLevel(java.util.logging.Level.FINEST); }
 		 * logger.addHandler(consoleHandler); // ajout du fichier if
 		 * (fileHandler == null) { try { // determination du nom du fichier
 		 * String file = AtgConstantesWF.getValue("PATH_LOG_FILE"); int posPoint =
 		 * file.lastIndexOf("."); String realFile = file.substring(0, posPoint) +
 		 * "-" + logName + file.substring(posPoint, file.length()); // 500000
 		 * nombre de bytes par défaut écrit dans les fichiers de logs if (
 		 * (AtgConstantesWF.getValue("LOG_NB_BYTES_MAX") != null) &&
 		 * (!AtgConstantesWF.getValue("LOG_NB_BYTES_MAX").equals(""))) {
 		 * fileHandler = new java.util.logging.FileHandler(realFile, (new
 		 * Integer(AtgConstantesWF.getValue("LOG_NB_BYTES_MAX"))). intValue(),
 		 * 2); } else { fileHandler = new
 		 * java.util.logging.FileHandler(realFile, 500000, 2); }
 		 * fileHandler.setFormatter(new AtgLogFormatter()); if
 		 * (logger.getLevel() != null) {
 		 * fileHandler.setLevel(logger.getLevel()); } else {
 		 * fileHandler.setLevel(java.util.logging.Level.FINEST); } } catch
 		 * (java.io.IOException exception) { logger.severe("Impossible
 		 * d'initialiser le fichier de log - " + exception.getMessage()); }
 		 * 
 		 * if (fileHandler != null) { logger.addHandler(fileHandler); } } }
 		 */
 	}
 }