/*

  * 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.execution;

 import java.lang.Thread.UncaughtExceptionHandler;

 import java.util.ArrayList;

 import java.util.List;

 import java.util.concurrent.atomic.AtomicBoolean;

 import net.sourceforge.acelogger.GenericLogger;

 import net.sourceforge.acelogger.Logger;

 import net.sourceforge.acelogger.appender.Appender;

 import net.sourceforge.acelogger.appender.SystemErrAppender;

 import net.sourceforge.acelogger.constants.LevelFilterConstants;

 import net.sourceforge.acelogger.execution.manager.ExecutorManager;

 import net.sourceforge.acelogger.execution.manager.PooledExecutorManager;

 import net.sourceforge.acelogger.execution.manager.QueuedExecutorManager;

 import net.sourceforge.acelogger.execution.task.MonitorableTask;

 import net.sourceforge.acelogger.execution.task.NotifiableTask;

 import net.sourceforge.acelogger.factory.ExecutorManagerFactory;

 import net.sourceforge.acelogger.factory.LoggerFactory;

 import net.sourceforge.acelogger.formatter.Formatter;

 import net.sourceforge.acelogger.formatter.SimpleFormatter;

 import net.sourceforge.acelogger.level.filter.LevelFilter;

 import net.sourceforge.acelogger.location.gatherer.FullLocationGatherer;

 import net.sourceforge.acelogger.location.gatherer.LocationGatherer;

 import net.sourceforge.acelogger.location.resolver.InternalCodeFrameResolver;

 // FIXME: Holy Crap... Design this properly. It started as a workaround, but looks promising now.

 /**

  * TODO: Create Doc.

  * 

  * @author Zardi (https://sourceforge.net/users/daniel_zardi)

  * @version 1.0.0

  * @since 1.0.0

  */

 public final class LogController {

         private static final int DEFAULT_POOL_SIZE = 3;

         private static final long SETUP_TIMEOUT = 10000;

         private static final long TERMINATION_TIMEOUT = 10000;

         private static final LogController INSTANCE = new LogController();

         private List<Runnable> commandsBeforeShutdown;

         private ExecutorManager backgroundExecutor;

         private ExecutorManager shutdownExecutor;

         private Logger internalLogger;

         private AtomicBoolean initialized;

         private AtomicBoolean waitingBootstrap;

         private Thread shutdownHook = new Thread(new Runnable() {

                 public void run() {

                         internalLogger = new InternalLogger();

                         shutdownExecutor.executeAll(commandsBeforeShutdown);

                         shutdownExecutor.orderProperShutdown();

                         shutdownExecutor.awaitTermination(TERMINATION_TIMEOUT);

                         boolean terminatedAllTasks = ExecutorManagerFactory.doProperExecutorManagersShutdown();

                         if (!terminatedAllTasks) {

                                 try {

                                         terminatedAllTasks = ExecutorManagerFactory

                                                         .awaitExecutorManagersShutdown(TERMINATION_TIMEOUT);

                                 } catch (TerminationException e) {

                                         e.printStackTrace(System.err);

                                 }

                                 if (!terminatedAllTasks) {

                                         // FIXME: What should we do? wait forever? or just drop the tasks?

                                 }

                         }

                         backgroundExecutor.orderProperShutdown();

                         backgroundExecutor.awaitTermination(TERMINATION_TIMEOUT);

                 }

         });

         private MonitorableTask finalizeBootstrap = new MonitorableTask(new Runnable() {

                 public void run() {

                         try {

                                 submitBackgroundTask(new Runnable() {

                                         public void run() {

                                                 internalLogger = LoggerFactory.getLogger("net.sourceforge.acelogger");

                                                 initialized.set(true);

                                         }

                                 });

                         } catch (Exception e) {

                                 // FIXME: Should we do this? If there's an exception the framework is compromised by now

                                 shutdownHook.start();

                         }

                 }

         });

         private Runnable setup = new NotifiableTask(new Runnable() {

                 public void run() {

                         LoggerFactory.registerLogger(internalLogger);

                         internalLogger.info("LogControlle.setupComplete");

                 }

         }, finalizeBootstrap);

         private LogController() {

                 internalLogger = new InternalLogger();

                 Thread.setDefaultUncaughtExceptionHandler(UncaughtExceptionLogger.getInstance());

                 Runtime.getRuntime().addShutdownHook(shutdownHook);

                 backgroundExecutor = new QueuedExecutorManager("background");

                 shutdownExecutor = new PooledExecutorManager("commandsBeforeShutdown", DEFAULT_POOL_SIZE);

                 commandsBeforeShutdown = new ArrayList<Runnable>();

                 initialized = new AtomicBoolean(false);

                 waitingBootstrap = new AtomicBoolean(true);

                 backgroundExecutor.execute(setup);

         }

         public static void submitBackgroundTask(Runnable command) {

                 INSTANCE.backgroundExecutor.execute(command);

         }

         public static void submitBackgroundTask(final Runnable command, final ExecutorManager executor) {

                 final Runnable process = new Runnable() {

                         public void run() {

                                 executor.execute(command);

                         }

                 };

                 submitBackgroundTask(process);

         }

         public static void submitShutdownTask(Runnable command) {

                 INSTANCE.commandsBeforeShutdown.add(command);

         }

         public static void submitShutdownTask(final Runnable command, final ExecutorManager executor) {

                 final Runnable process = new Runnable() {

                         public void run() {

                                 executor.execute(command);

                         }

                 };

                 submitShutdownTask(process);

         }

         public static void ensureInitialization() {

                 if (!INSTANCE.initialized.get() && INSTANCE.waitingBootstrap.get()) {

                         try {

                                 if (INSTANCE.waitingBootstrap.compareAndSet(true, false)) {

                                         INSTANCE.finalizeBootstrap.awaitTermination(SETUP_TIMEOUT);

                                 }

                         } catch (final InterruptedException e) {

                                 INSTANCE.internalLogger.fatal("Could not initialize after {0} ms", SETUP_TIMEOUT);

                         }

                 }

         }

         public static Logger getInternalLogger() {

                 return INSTANCE.internalLogger;

         }

 }