/*
    * This file is part of AceLogger.
    * 
    * AceLogger is free software: you can redistribute it and/or modify it under the terms of the GNU
    * Lesser General Public License as published by the Free Software Foundation, either version 3 of
    * the License, or (at your option) any later version.
    * 
    * AceLogger is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
    * even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
   * Lesser General Public License for more details.
   * 
   * You should have received a copy of the GNU Lesser General Public License along with AceLogger.
   * If not, see <http://www.gnu.org/licenses/lgpl-3.0.html>.
   */
  package net.sourceforge.acelogger.factory;
  
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.concurrent.CountDownLatch;
  import java.util.concurrent.TimeUnit;
  
  import net.sourceforge.acelogger.constants.ExecutorManagerConstants;
  import net.sourceforge.acelogger.execution.LogController;
  import net.sourceforge.acelogger.execution.TerminationException;
  import net.sourceforge.acelogger.execution.manager.ExecutorManager;
  
  /**
   * Factory for managing instances of configured executor managers.
   * 
   * @author Zardi (https://sourceforge.net/users/daniel_zardi)
   * @version 1.0.0
   * @since 1.0.0
   */
  public final class ExecutorManagerFactory {
  
  	/**
  	 * A instance of this class (the only one).
  	 */
  	private static final ExecutorManagerFactory INSTANCE = new ExecutorManagerFactory();
  
  	/**
  	 * Used when no configured manager is found for a given identifier.
  	 */
  	private ExecutorManager defaultExecutorManager;
  
  	/**
  	 * Maps each configured manager to a unique identifier.
  	 */
  	private final Map<String, ExecutorManager> registeredExecutors;
  
  	/**
  	 * Indicates if this factory has ordered all of its managers a shutdown or not.
  	 */
  	private boolean shutdown = false;
  
  	/**
  	 * Creates a new ExecutorManagerFactory (This class is a singleton).
  	 * 
  	 * @since 1.0.0
  	 */
  	private ExecutorManagerFactory() {
  		registeredExecutors = new HashMap<String, ExecutorManager>();
  		defaultExecutorManager = ExecutorManagerConstants.EMPTY;
  	}
  
  	/**
  	 * Obtains a properly configured manager for the given identifier.
  	 * 
  	 * @param identifier
  	 *            The identifier of the intended manager.
  	 * @return A properly configured manager for the given identifier. If the identifier is not
  	 *         found, then the default manager is returned.
  	 * @see ExecutorManagerFactory#getDefaultExecutorManager()
  	 * @since 1.0.0
  	 */
  	public static ExecutorManager getExecutorManager(String identifier) {
  		LogController.ensureInitialization();
  		ExecutorManager intendedExecutor = INSTANCE.registeredExecutors.get(identifier);
  		if (intendedExecutor == null) {
  			int lastDotIndex = identifier.lastIndexOf('.');
  			if (lastDotIndex > 0) {
  				intendedExecutor = getExecutorManager(identifier.substring(0, lastDotIndex));
  			} else {
  				intendedExecutor = INSTANCE.defaultExecutorManager;
  			}
  		}
  		return intendedExecutor;
  	}
  
  	/**
  	 * Sets the default manager of this factory, the one used when no manager is found for a given
  	 * identifier.
  	 * 
  	 * @param manager
  	 *            The manager that will be used as the default one from now.
  	 * @return The previous default manager.
  	 * @since 1.0.0
 	 */
 	public static ExecutorManager setDefaultExecutorManager(ExecutorManager manager) {
 		LogController.ensureInitialization();
 		ExecutorManager previous = INSTANCE.defaultExecutorManager;
 		if (manager != null) {
 			INSTANCE.defaultExecutorManager = manager;
 		}
 		return previous;
 	}
 
 	/**
 	 * Returns the default manager of this factory, the one used when no manager is found for a
 	 * given identifier.
 	 * 
 	 * @return The default manager.
 	 * @since 1.0.0
 	 */
 	public static ExecutorManager getDefaultExecutorManager() {
 		LogController.ensureInitialization();
 		return INSTANCE.defaultExecutorManager;
 	}
 
 	/**
 	 * Registers an appender within this factory. The mapped identifier will be the managers
 	 * identifier.
 	 * 
 	 * @param manager
 	 *            The manager to be registered.
 	 * @return The default manager if there was no previous mapping for the identifier or the
 	 *         previous configured manager otherwise.
 	 * @see ExecutorManagerFactory#getDefaultExecutorManager()
 	 * @since 1.0.0
 	 */
 	public static ExecutorManager registerExecutorManager(ExecutorManager manager) {
 		LogController.ensureInitialization();
 		ExecutorManager intendedExecutor = null;
 		if (manager != null) {
 			intendedExecutor = INSTANCE.registeredExecutors.put(manager.getIdentifier(), manager);
 		}
 		if (intendedExecutor == null) {
 			intendedExecutor = INSTANCE.defaultExecutorManager;
 		}
 		return intendedExecutor;
 	}
 
 	/**
 	 * Returns a list of all managers registered in this factory.
 	 * 
 	 * @return A list of managers.
 	 * @since 1.0.0
 	 */
 	public static List<ExecutorManager> getRegisteredExecutorManagers() {
 		LogController.ensureInitialization();
 		List<ExecutorManager> allExecutorManagers = new ArrayList<ExecutorManager>(
 				INSTANCE.registeredExecutors.values());
 		return allExecutorManagers;
 	}
 
 	/**
 	 * Indicates if this factory has ordered all of its managers a shutdown or not. If this factory
 	 * has ordered shutdown, it is not safe to execute any task.
 	 * 
 	 * @return True id the shutdown was previously ordered, false otherwise.
 	 * @since 1.0.0
 	 */
 	public static boolean isShutdown() {
 		LogController.ensureInitialization();
 		return INSTANCE.shutdown;
 	}
 
 	/**
 	 * Shuts down each of the registered executor managers, this should be called to guarantee that
 	 * all tasks submitted will be run before termination.
 	 * 
 	 * @return True if all executors finished their tasks properly, false if there are tasks under
 	 * or awaiting execution.
 	 * @since 1.0.0
 	 */
 	public static boolean doProperExecutorManagersShutdown() {
 		if (INSTANCE.shutdown) {
 			throw new IllegalStateException("");
 		} else {
 			LogController.ensureInitialization();
 			INSTANCE.shutdown = true;
 			boolean properShutdown = true;
 			List<ExecutorManager> allExecutorManagers = getRegisteredExecutorManagers();
 			for (ExecutorManager currentExecutorManager : allExecutorManagers) {
 				currentExecutorManager.orderProperShutdown();
 				properShutdown &= currentExecutorManager.isTerminated();
 			}
 			return properShutdown;
 		}
 	}
 
 	/**
 	 * Awaits for the execution of the remaining tasks in executor managers registered in this
 	 * factory. This method should be called after ordering a proper shutdown of the executors.
 	 * 
 	 * @param terminationTimeout
 	 *            The maximum time (in ms) to wait while executing the remaining tasks.
 	 * @return True if all executor managers terminated execution of its tasks before the supplied
 	 *         timeout; False otherwise.
 	 * @throws TerminationException
 	 *             if interrupted while waiting for managers to shutdown.
 	 * @since 1.0.0
 	 * @see ExecutorManagerFactory#doProperExecutorManagersShutdown()
 	 */
 	public static boolean awaitExecutorManagersShutdown(final long terminationTimeout)
 			throws TerminationException {
 		boolean allDone = false;
 		if (INSTANCE.shutdown) {
 			List<ExecutorManager> remainingExecutorManagers = getRegisteredExecutorManagers();
 			final CountDownLatch synchronizer =
 					new CountDownLatch(remainingExecutorManagers.size());
 			for (final ExecutorManager currentManager : remainingExecutorManagers) {
 				LogController.submitBackgroundTask(new Runnable() {
 					/**
 					 * Orders the termination of each manager under a given timeout.
 					 */
 					public void run() {
 						currentManager.awaitTermination(terminationTimeout);
 						synchronizer.countDown();
 					}
 				});
 			}
 			try {
 				allDone = synchronizer.await(terminationTimeout, TimeUnit.MILLISECONDS);
 			} catch (InterruptedException e) {
 				throw new TerminationException("Interrupted while waiting executor to finish", e);
 			}
 		} else {
 			throw new IllegalStateException(
 					"Can only await executor managers shutdown after calling"
 					+ " doProperExecutorManagersShutdown");
 		}
 		return allDone;
 	}
 
 }