#pragma region Copyright
/*
Toxid Game
Copyright (C) 2002-2008 Nuclex Development Labs
*/
#pragma endregion

#ifndef TOXID_MAIN_H
#define TOXID_MAIN_H

#include "Toxid.h"

#include <Main/Main.h>
#include <Nuclex/Kernel.h>
#include <Nuclex/Video/VideoDriver.h>
#include <Nuclex/Audio/AudioDriver.h>
#include <Nuclex/Video/VideoDevice.h>
#include <Nuclex/Audio/AudioDevice.h>
#include <Nuclex/Storage/Serializer.h>
#include <Nuclex/Plugin.h>

#include <SigC++/SigC++.h>

#include <memory>
#include <map>

namespace Toxid {

  // ------------------------------------------------------------------------------------------- //

  class UIServer;
  class MapServer;
  class GameServer;

  // ------------------------------------------------------------------------------------------- //

  /// <summary>Main game class that manages the game's major subsystems</summary>
  class Main {
    
    /// <summary>Signature of an event used to signal that a new time frame started</summary>
    public: typedef SigC::Signal1<void, float> TimeFrameSignal;

    /// <summary>Signature of an event used to signal that a frame is being rendered</summary>
    public: typedef SigC::Signal2<
      void,
      const shared_ptr<Video::VideoDevice::RenderingContext> &,
      const shared_ptr<Audio::AudioDevice::RenderingContext> &
    > RenderFrameSignal;
    
    /// <summary>Event that is fired to update the game's state</summary>
    public: TimeFrameSignal onTimeFrame;
    /// <summary>Event that is fired to render a frame to the screen</summary>
    public: RenderFrameSignal onRenderFrame;
    
    /// <summary>Pseudo-Singleton accessor</summary>
    /// <returns>The global instance of the game's main class</returns>
    public: static Main &getInstance() { return *s_pInstance; }

    /// <summary>Initializes an instance of the main game class</summary>
    /// <param name="Environment">Informations about the application's environment</param>
    /// <remarks>
    ///   Reads the settings from the default configuration file and initializes the
    ///   game's subsystem servers
    /// </remarks>
    public: Main(const Nuclex::Environment &Environment);

    /// <summary>Terminates an instance of the main game class</summary>
    /// <remarks>
    ///   The current settings are saved into the default configuration file and all
    ///   subsystems are shut down
    /// </remarks>
    public: ~Main();
      
    //
    // Main implementation
    //
    
    /// <summary>Runs the game's main loop</summary>
    /// <remarks>
    ///   Responsible for keeping the entire application running, updating the game state
    ///   and rendering frames until it is terminated
    /// </remarks>
    public: void run();
      
    /// <summary>Accesses the UI server</summary>
    /// <returns>The game's UI server</returns>
    public: UIServer &getUIServer() { return *m_spUIServer.get(); }
    /// <summary>Accesses the map server</summary>
    /// <returns>The game's map server</returns>
    public: MapServer &getMapServer() { return *m_spMapServer.get(); }
    /// <summary>Accesses the gameplay server</summary>
    /// <returns>The game's gameplay server</returns>
    public: GameServer &getGameServer() { return *m_spGameServer.get(); }
      
    /// <summary>Accesses the game's active video driver</summary>
    /// <returns>The game's active video driver</returns>
    public: const shared_ptr<Video::VideoDriver> &getVideoDriver() { return m_spVideoDriver; }
    /// <summary>Accesses the game's active audio driver</summary>
    /// <returns>The game's active audio driver</returns>
    public: const shared_ptr<Audio::AudioDriver> &getAudioDriver() { return m_spAudioDriver; }
      
    /// <summary>Accesses the game's active video device</summary>
    /// <returns>The game's active video device</returns>
    public: const shared_ptr<Video::VideoDevice> &getVideoDevice() { return m_spVideoDevice; }
    /// <summary>Accesses the game's active audio device</summary>
    /// <returns>The game's active audio device</returns>
    /// <remarks>
    ///   Unlike the video device, the audio device can be NULL, indicating that
    ///   audio is not supported in the current system or the user decided not
    ///   to enable audio playback.
    /// </remarks>
    public: const shared_ptr<Audio::AudioDevice> &getAudioDevice() { return m_spAudioDevice; }

    /// <summary>Loads the application settings from a file</summary>
    /// <param name="sFilename">File to load the application settings from</param>
    public: void loadSettings(const string &sFilename = "toxid.settings.xml");
    /// <summary>Saves the application settings into a file</summary>
    /// <param name="sFilename">File to save the application settings into</param>
    public: void saveSettings(const string &sFilename = "toxid.settings.xml");

    /// <summary>Sets the display mode to use when the game starts up</summary>
    public: void setDefaultDisplayMode(const Video::VideoDriver::DisplayMode &DisplayMode) {
      m_DisplayMode = DisplayMode;
    }
    
    /// <summary>
    ///   Contains informations telling the plugin loader how a Toxid plugin looks like
    /// </summary>
    private: struct PluginSettings {

      /// <summary>The name of the exported version query function in plugins</summary>
      public: static string VersionFunctionName;
      /// <summary>The name of the exported register function in plugins</summary>
      public: static string RegisterFunctionName;
      /// <summary>The name of the exported unregister function in plugins</summary>
      public: static string UnregisterFunctionName;
      /// <summary>Filename prefix used by this kind of plugin</summary>
      public: static string FilePrefix;

    };

    /// <summary>Type of loadable a Toxid plugin</summary>
    private: typedef Plugin<Main, PluginSettings> ToxidPlugin;
    /// <summary>Map storing Toxid plugins by their file names</summary>
    private:  typedef std::map<string, shared_ptr<ToxidPlugin > > PluginMap;

    /// <summary>The global main game class instance</summary>
    private: static Main *s_pInstance;

    /// <summary>Informations about the environment the game is executing in</summary>
    private: const Environment &m_Environment;
    /// <summary>Currently loaded toxid plugins</summary>
    private: PluginMap m_Plugins;

    /// <summary>Currently selected video driver</summary>
    private: shared_ptr<Video::VideoDriver> m_spVideoDriver;
    /// <summary>Currently selected audio driver</summary>
    private: shared_ptr<Audio::AudioDriver> m_spAudioDriver;
    /// <summary>Selected video mode</summary>
    private: Video::VideoDriver::DisplayMode m_DisplayMode;

    /// <summary>UI subsystem server of the game</summary>
    private: std::auto_ptr<UIServer> m_spUIServer;
    /// <summary>Map subsystem server of the game</summary>
    private: std::auto_ptr<MapServer> m_spMapServer;
    /// <summary>Gameplay subsystem server of the game</summary>
    private: std::auto_ptr<GameServer> m_spGameServer;

    /// <summary>Video device being used for rendering</summary>
    private: shared_ptr<Video::VideoDevice> m_spVideoDevice;
    /// <summary>Audio device being used for audio playback</summary>
    private: shared_ptr<Audio::AudioDevice> m_spAudioDevice;
  };

} // namespace Toxid

#endif // TOXID_MAIN_H