/* LICENSE BLOCK
Part of mde: a Modular D game-oriented Engine
Copyright © 2007-2008 Diggory Hardy

This program is free software: you can redistribute it and/or modify it under the terms
of the GNU General Public License as published by the Free Software Foundation, either
version 2 of the License, or (at your option) any later version.

This program 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>. */

/**************************************************************************************************
 * Initialisation setup and exit cleanup module.
 *
 * This module provides an infrastructure for handling much of the initialisation and
 * deinitialisation of the program. It does not, however, provide much of the (de)initialisation
 * code; with the exception of that for the logger.
 *************************************************************************************************/
module mde.setup.Init;

import mde.setup.init2;     // This module is responsible for setting up some init functions.
import mde.setup.initFunctions;
import mde.setup.exception;

import mde.lookup.Options;
import paths = mde.setup.paths;
import mde.exception;

// tango imports
import tango.core.Thread;
import tango.core.Exception;
import tango.stdc.stringz : fromStringz;
import tango.io.Console;	// for printing command-line usage
import TimeStamp = tango.text.convert.TimeStamp, tango.time.WallClock;	// output date in log file
import tango.util.Arguments;
import tango.util.log.Log : Log, Logger;
import tango.util.log.ConsoleAppender : ConsoleAppender;

//version = SwitchAppender;
version (SwitchAppender) {  // My own variation, currently just a test
    import tango.util.log.SwitchingFileAppender : SwitchingFileAppender;
} else {
    import tango.util.log.RollingFileAppender : RollingFileAppender;
}

// Derelict imports
import derelict.opengl.gl;
import derelict.sdl.sdl;
//import derelict.sdl.image;	Was to be used... for now isn't
import derelict.freetype.ft;
import derelict.util.exception;

/**
 * Static CTOR
 *
 * This should handle a minimal amount of functionality where useful. For instance, configuring the
 * logger here and not in Init allows unittests to use the logger.
 */
static this()
{
    Logger root = Log.getRootLogger();
    // Set the level here, but set it again once options have been loaded:
    debug root.setLevel(root.Level.Trace);
    else root.setLevel(root.Level.Info);
    // Temporarily log to the console (until we've found paths and loaded options):
    root.addAppender(new ConsoleAppender);
}
static ~this()
{
}

/**
 * Init class
 *
 * A scope class created at beginning of the program and destroyed at the end; thus the CTOR
 * handles program initialisation and the DTOR handles program cleanup.
 */
scope class Init
{
    //private bool failure = false;       // set true on failure during init, so that clean
    private static Logger logger;
    static this() {
        logger = Log.getLogger ("mde.setup.Init");
    }
    
    /** this() − initialisation
    *
    * Runs general initialisation code, in a threaded manner where this isn't difficult.
    * If any init fails, cleanup is still handled by ~this().
    *
    * Init order: 1. Pre-init (loads components needed by most init functions). 2. Dynamic library
    * loading (load any dynamic libraries first, so that if loading fails nothing else need be
    * done). 3. Init functions (threaded functions handling the rest of initialisation).
    */
    /* In a single-threaded function this could be done with:
    * scope(failure) cleanup;
    * This won't work with a threaded init function since any threads completing succesfully will
    * not clean-up, and a fixed list of clean-up functions cannot be used since clean-up functions
    * must not run where the initialisation functions have failed.
    * Hence a list of clean-up functions is built similarly to scope(failure) --- see addCleanupFct.
    */
    this(char[][] cmdArgs)
    {
        debug logger.trace ("Init: starting");
        
        //BEGIN Pre-init (stage init0)
        //FIXME: warn on invalid arguments, including base-path on non-Windows
        // But Arguments doesn't support this (in tango 0.99.6 and in r3563).
        Arguments args;
        try {
            args = new Arguments();
            args.define("base-path").parameters(1);
            args.define("data-path").parameters(1,-1);
            args.define("conf-path").parameters(1,-1);
            args.define("paths");
            args.define("q").aliases(["quick-exit"]);
            args.define("help").aliases(["h"]);
            args.parse(cmdArgs);
            if (args.contains("help"))	// lazy way to print help
                throw new InitException ("Help requested");	// and stop
        } catch (Exception e) {
            printUsage(cmdArgs[0]);
            throw new InitException ("Parsing arguments failed: "~e.msg);
        }
        
	// Find/create paths:
	try {
            if (args.contains("data-path"))
                paths.extraDataPath = args["data-path"];
            if (args.contains("conf-path"))
                paths.extraConfPath = args["conf-path"];
            if (args.contains("base-path"))
                paths.resolvePaths (args["base-path"]);
            else
                paths.resolvePaths();
	} catch (Exception e) {
            throw new InitException ("Resolving paths failed: " ~ e.msg);
	}
        if (args.contains("paths")) {
            paths.mdeDirectory.printPaths;
            throw new InitException ("Paths requested");	// lazy way to stop
        }
        debug logger.trace ("Init: resolved paths successfully");
    
        /* Load options now. Don't load in a thread since:
        *   Loading should be fast & most work is probably disk access
        *   It enables logging to be controlled by options
        *   It's a really good idea to let the options apply to all other loading */
        try {
            Options.load();
        } catch (optionsLoadException e) {
            throw new InitException ("Loading options failed: " ~ e.msg);
        }
        debug logger.trace ("Init: loaded options successfully");
        
	// Set up the logger:
        Logger root;
	try {
            enum LOG {
                LEVEL	= 0xF,		// mask for log level
                CONSOLE	= 0x1000,	// log to console?
                ROLLFILE= 0x2000	// use Rolling/Switching File Appender?
            }
            
	    // Where logging is done to is determined at compile-time, currently just via static ifs.
            root = Log.getRootLogger();
	    root.clearAppenders;	// we may no longer want to log to the console
	    
            // Now re-set the logging level, using the value from the config file:
            root.setLevel (cast(Log.Level) (miscOpts.logOptions & LOG.LEVEL), true);
            
            // Log to a file (first appender so root seperator messages don't show on console):
            if (miscOpts.logOptions & LOG.ROLLFILE) {
                version (SwitchAppender) {
                    root.addAppender (new SwitchingFileAppender (paths.logDir~"/log-.txt", 5));
                } else {
                // Use 2 log files with a maximum size of 1 MB:
                    root.addAppender (new RollingFileAppender (paths.logDir~"/log-.txt", 2, 1024*1024));
                    root.info (""); // some kind of separation between runs
                    root.info ("");
                }
            } else if (!(miscOpts.logOptions & LOG.CONSOLE)) {
                // make sure at least one logger is enabled
                Options.setInt ("misc", "logOptions", miscOpts.logOptions | LOG.CONSOLE);
            }
            if (miscOpts.logOptions & LOG.CONSOLE) {	// Log to the console
                root.addAppender(new ConsoleAppender);
            }
            logger.info ("Starting mde [no version] on " ~ TimeStamp.toString(WallClock.now));
        } catch (Exception e) {
            // Presumably it was only adding a file appender which failed; set up a new console
            // logger and if that fails let the exception kill the program.
            root.clearAppenders;
            root.addAppender (new ConsoleAppender);
            logger.warn ("Exception while setting up the logger; logging to the console instead.");
        }
        
        // a debugging option:
        imde.run = !args.contains("q") && !miscOpts.exitImmediately;
        debug logger.trace ("Init: applied pre-init options");
        
        //BEGIN Load dynamic libraries
        /* Can be done by init functions but much neater to do here.
        * Also means that init functions aren't run if a library fails to load. */
        try {
            DerelictSDL.load();
            // SDLImage was going to be used... for now it isn't because of gl texturing problems
            //DerelictSDLImage.load();
            DerelictGL.load();
            DerelictFT.load();
        } catch (DerelictException de) {
            logger.fatal ("Loading dynamic library failed:");
            logger.fatal (de.msg);
            
            throw new InitException ("Loading dynamic libraries failed (see above).");
        }
        debug logger.trace ("Init: dynamic libraries loaded");
        //END Load dynamic libraries
        //END Pre-init
        
        
        //BEGIN Init (stages init2, init4)
        /* Call init functions.
        *
        * Current method is to try using threads, and on failure assume no threads were actually
        * created and run functions in a non-threaded manner. */
        
        try {
            if (runStageThreaded (init)) runStageForward (init);
        }
        catch (InitStageException) {    // This init stage failed.
            // FIXME: check DTOR still runs
            throw new InitException ("An init function failed (see above message(s))");
        }
        //END Init
        
        debug logger.trace ("Init: done");
    }
    
    /** DTOR - runs cleanup functions. */
    ~this()
    {
        debug logger.trace ("Cleanup: starting");
        
        Options.save(); // save options... do so here for now
        
        // General cleanup:
        try {
            if (runStageThreaded (cleanup)) runStageReverse (cleanup);
        }
        catch (InitStageException) {
            // Nothing else to do but report:
            logger.error ("One or more cleanup functions failed!");
        }
        
        debug logger.trace ("Cleanup: done");
    }
    
    
    //BEGIN runStage...
    private static {
        /* The following three functions, runStage*, each run all functions in a stage in some order,
        * catching any exceptions thrown by the functions (although this isn't guaranteed for threads),
        * and throw an InitStageException on initFailure. */
    
        const LOG_IF_MSG = "Init function ";
        const LOG_CF_MSG = "Cleanup function ";
        const LOG_F_START = " - running";
        const LOG_F_END = " - completed";
        const LOG_F_BAD = " - failed";
        const LOG_F_FAIL = " - failed: ";
        /* Runs all functions consecutively, first-to-last.
        * If any function fails, halts immediately. */
        void runStageForward (InitStage s) {
            foreach (func; s.funcs) {
                if (initFailure) break;
                try {
                    debug logger.trace (LOG_IF_MSG ~ func.name ~ LOG_F_START);
                    func.func();
                    debug logger.trace (LOG_IF_MSG ~ func.name ~ (initFailure ? LOG_F_BAD : LOG_F_END));
                } catch (Exception e) {
                    logger.fatal (LOG_IF_MSG ~ func.name ~ LOG_F_FAIL ~
                            ((e.msg is null || e.msg == "") ? "(no failure message)" : e.msg) );
                
                    setInitFailure();
                }
            }
            
            if (initFailure) throw new InitStageException;    // Problem running; abort and cleanup from here.
        }
        /* Runs all functions consecutively, last-to-first.
        * If any function fails, continue until all have been run. */
        void runStageReverse (InitStage s) {
            foreach_reverse (func; s.funcs) {
                try {
                    debug logger.trace (LOG_CF_MSG ~ func.name ~ LOG_F_START);
                    func.func();
                    debug logger.trace (LOG_CF_MSG ~ func.name ~ (initFailure ? LOG_F_BAD : LOG_F_END));
                } catch (Exception e) {
                    logger.fatal (LOG_CF_MSG ~ func.name ~ LOG_F_FAIL ~
                            ((e.msg is null || e.msg == "") ? "(no failure message)" : e.msg) );
                
                    setInitFailure();
                }
            }
            if (initFailure) throw new InitStageException;    // Problem running; abort and cleanup from here.
        }
        /* Tries running functions in a threaded way. Returns false if successful, true if not but
        * functions should be run without threads. */
        bool runStageThreaded (InitStage s) {
            if (!miscOpts.useThreads) return true;  // Use unthreaded route instead
        
            ThreadGroup tg;
            try {                           // creating/starting threads could fail
                tg = new ThreadGroup;
                foreach (func; s.funcs) {   // Start all threads
                    debug logger.trace (LOG_IF_MSG ~ func.name ~ LOG_F_START);
                    tg.create(func.func);
                    debug logger.trace (LOG_IF_MSG ~ func.name ~ (initFailure ? LOG_F_BAD : LOG_F_END));
                }
            } catch (ThreadException e) {   // Problem with threading; try without threads
                logger.error ("Caught ThreadException while trying to create threads:");
                logger.error (e.msg);
                logger.info ("Will disable threads and continue, assuming no threads were created.");
            
                Options.setBool("misc", "useThreads", false);   // Disable threads entirely
                return true;                // Try again without threads
            }
        
            /* Wait for all threads to complete.
            *
            * If something went wrong, we still need to do this before cleaning up.
            */
            foreach (t; tg) {
                try {
                    t.join (true);
                } catch (Exception e) {
                    // Relying on catching exceptions thrown by other threads is a bad idea.
                    // Hence all threads should catch their own exceptions and return safely.
                
                    logger.fatal ("Unhandled exception from Init function:");
                    logger.fatal (e.msg);
                
                    setInitFailure ();        // abort (but join other threads first)
                }
            }
            
            if (initFailure) throw new InitStageException;    // Problem running; abort and cleanup from here.
            return false;                   // Done successfully
        }
    //END runStage...
        
        void printUsage (char[] progName) {
            Cout ("mde [no version]").newline;
            Cout ("Usage:").newline;
            Cout (progName ~ ` [options]`).newline;
            version(Windows)
                    Cout (
`  --base-path path	Use path as the base (install) path (Windows only). It
			should contain the "data" directory.`).newline;
            Cout (
`  --data-path path(s)	Add path(s) as a potential location for data files.
			First path argument becomes the preffered location to
			load data files from.
  --conf-path path(s)	Add path(s) as a potential location for config files.
			Configuration in the first path given take highest
			priority.
  --paths		Print all paths found and exit.
  --quick-exit, -q	Exit immediately, without entering main loop.
  --help, -h		Print this message.`).newline;
        }
    }
    
    debug (mdeUnitTest) unittest {
        /* Fake init and cleanup. Use unittest-specific init and cleanup InitStages to avoid
        * messing other init/cleanup up. */
        static InitStage initUT, cleanupUT;
        
        static bool initialised = false;
        static void cleanupFunc1 () {
            initialised = false;
        }
        static void cleanupFunc2 () {
            assert (initialised == true);
        }
                
        static void initFunc () {
            initialised = true;
            cleanupUT.addFunc (&cleanupFunc1, "UT cleanup 1");
            cleanupUT.addFunc (&cleanupFunc2, "UT cleanup 2");
        }
        
        initUT.addFunc (&initFunc, "UT init");
        
        runStageForward (initUT);
        assert (initialised);
        
        runStageReverse (cleanupUT);
        assert (!initialised);

        logger.info ("Unittest complete.");
    }
}