#region CPL License
/*
Nuclex Framework
Copyright (C) 2002-2010 Nuclex Development Labs

This library is free software; you can redistribute it and/or
modify it under the terms of the IBM Common Public License as
published by the IBM Corporation; either version 1.0 of the
License, or (at your option) any later version.

This library 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
IBM Common Public License for more details.

You should have received a copy of the IBM Common Public
License along with this library
*/
#endregion

using System;
using System.Collections.Generic;
using System.Diagnostics;

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;

using Ninject;
using Ninject.Activation;
using Ninject.Modules;

using SynapseGaming.LightingSystem.Core;
using SynapseGaming.LightingSystem.Editor;
using SynapseGaming.LightingSystem.Lights;
using SynapseGaming.LightingSystem.Rendering;
using SynapseGaming.LightingSystem.Rendering.Forward;
using SynapseGaming.LightingSystem.Shadows;
using SynapseGaming.LightingSystem.Audio;
using SynapseGaming.LightingSystem.Collision;

namespace Nuclex.Ninject.Sunburn {

  /// <summary>Sets up service bindings for the IslandWar game</summary>
  public class SunburnModule : NinjectModule {

    /// <summary>Called when the module is loaded into the kernel</summary>
    public override void Load() {
      Kernel.Bind<LightingSystemManager>().ToSelf().InSingletonScope();
      Kernel.Bind<RenderManager>().ToSelf().InSingletonScope();
      Kernel.Bind<SceneState>().ToSelf().InSingletonScope();
      Kernel.Bind<SceneEnvironment>().ToSelf().InSingletonScope();

      Kernel.Bind<SceneInterface>().ToMethod(getSceneInterface).InSingletonScope();
      Kernel.Bind<IManagerServiceProvider>().ToMethod(getSceneInterface).InSingletonScope();
      Kernel.Bind<ISceneEnvironment>().To<SceneEnvironment>().InSingletonScope();

      Kernel.Bind<IAudioManager>().ToMethod(getAudioManager).InSingletonScope();
#if !WINDOWS_PHONE
      Kernel.Bind<IAvatarManager>().ToMethod(getAvatarManager).InSingletonScope();
      Kernel.Bind<IShadowMapManager>().ToMethod(getShadowMapManager).InSingletonScope();
#endif
      Kernel.Bind<ICollisionManager>().ToMethod(getCollisionManager).InSingletonScope();
      Kernel.Bind<ILightManager>().ToMethod(getLightManager).InSingletonScope();
      Kernel.Bind<IObjectManager>().ToMethod(getObjectManager).InSingletonScope();
      Kernel.Bind<IPostProcessManager>().ToMethod(getPostProcessManager).InSingletonScope();
      Kernel.Bind<IRenderManager>().ToMethod(getRenderManager).InSingletonScope();
      Kernel.Bind<IResourceManager>().ToMethod(getResourceManager).InSingletonScope();
      Kernel.Bind<FrameBuffers>().ToMethod(getFrameBuffers).InSingletonScope();

      setupSplashScreenComponent();

#if DEBUG
      Kernel.Bind<LightingSystemEditor>().ToSelf().InSingletonScope();
      setupLightingSystemEditor();
#endif
    }

    /// <summary>Gets the scene interface of the Sunburn system</summary>
    /// <param name="context">
    ///   Context containing the kernel and informations about the request
    /// </param>
    /// <returns>The scene interface</returns>
    private static SceneInterface getSceneInterface(IContext context) {
      var sceneInterface = new SceneInterface(
        context.Kernel.Get<IGraphicsDeviceService>()
      );

      // This will create a default instance if none has been registered by the user
      var sceneOptions = context.Kernel.Get<SceneOptions>();

      sceneInterface.CreateDefaultManagers(
        sceneOptions.UseDeferredRendering
      );

      return sceneInterface;
    }

#if !WINDOWS_PHONE
    /// <summary>Gets the scene interface's avatar manager</summary>
    /// <param name="context">
    ///   Context containing the kernel and informations about the request
    /// </param>
    /// <returns>The avatar manager</returns>
    private static IAvatarManager getAvatarManager(IContext context) {
      var sceneInterface = context.Kernel.Get<SceneInterface>();
      return sceneInterface.AvatarManager;
    }

    /// <summary>Gets the scene interface's shadow map manager</summary>
    /// <param name="context">
    ///   Context containing the kernel and informations about the request
    /// </param>
    /// <returns>The shadow map manager</returns>
    private static IShadowMapManager getShadowMapManager(IContext context) {
      var sceneInterface = context.Kernel.Get<SceneInterface>();
      return sceneInterface.ShadowMapManager;
    }
#endif

    /// <summary>Gets the scene interface's audio manager</summary>
    /// <param name="context">
    ///   Context containing the kernel and informations about the request
    /// </param>
    /// <returns>The audio manager</returns>
    private static IAudioManager getAudioManager(IContext context) {
      var sceneInterface = context.Kernel.Get<SceneInterface>();
      return sceneInterface.AudioManager;
    }

    /// <summary>Gets the scene interface's collision manager</summary>
    /// <param name="context">
    ///   Context containing the kernel and informations about the request
    /// </param>
    /// <returns>The collision manager</returns>
    private static ICollisionManager getCollisionManager(IContext context) {
      var sceneInterface = context.Kernel.Get<SceneInterface>();
      return sceneInterface.CollisionManager;
    }

    /// <summary>Gets the scene interface's light manager</summary>
    /// <param name="context">
    ///   Context containing the kernel and informations about the request
    /// </param>
    /// <returns>The light manager</returns>
    private static ILightManager getLightManager(IContext context) {
      var sceneInterface = context.Kernel.Get<SceneInterface>();
      return sceneInterface.LightManager;
    }

    /// <summary>Gets the scene interface's object manager</summary>
    /// <param name="context">
    ///   Context containing the kernel and informations about the request
    /// </param>
    /// <returns>The object manager</returns>
    private static IObjectManager getObjectManager(IContext context) {
      var sceneInterface = context.Kernel.Get<SceneInterface>();
      return sceneInterface.ObjectManager;
    }

    /// <summary>Gets the scene interface's post processing effect manager</summary>
    /// <param name="context">
    ///   Context containing the kernel and informations about the request
    /// </param>
    /// <returns>The post processing effect manager</returns>
    private static IPostProcessManager getPostProcessManager(IContext context) {
      var sceneInterface = context.Kernel.Get<SceneInterface>();
      return sceneInterface.PostProcessManager;
    }

    /// <summary>Gets the scene interface's rendering manager</summary>
    /// <param name="context">
    ///   Context containing the kernel and informations about the request
    /// </param>
    /// <returns>The rendering manager</returns>
    private static IRenderManager getRenderManager(IContext context) {
      var sceneInterface = context.Kernel.Get<SceneInterface>();
      return sceneInterface.RenderManager;
    }

    /// <summary>Gets the scene interface's resource manager</summary>
    /// <param name="context">
    ///   Context containing the kernel and informations about the request
    /// </param>
    /// <returns>The resource manager</returns>
    private static IResourceManager getResourceManager(IContext context) {
      var sceneInterface = context.Kernel.Get<SceneInterface>();
      return sceneInterface.ResourceManager;
    }

    /// <summary>Gets the frame buffers used for rendering</summary>
    /// <param name="context">
    ///   Context containing the kernel and informations about the request
    /// </param>
    /// <returns>The new frame buffers</returns>
    private static FrameBuffers getFrameBuffers(IContext context) {
      var graphicsDeviceService = context.Kernel.Get<IGraphicsDeviceService>();

      // This will create a default instance if none has been registered by the user
      var sceneOptions = context.Kernel.Get<SceneOptions>();

      return new FrameBuffers(
        graphicsDeviceService, sceneOptions.Precision, sceneOptions.Lighting
      );
    }

    /// <summary>Adds the splash screen component to the game</summary>
    private void setupSplashScreenComponent() {
      var gameComponents = Kernel.Get<GameComponentCollection>();

      var splashScreen = Kernel.Get<SplashScreenComponent>();
      Kernel.Bind<ISplashScreenService>().ToConstant(splashScreen);

      gameComponents.Add(splashScreen);
    }

    /// <summary>Adds the lighting system editor to the scene</summary>
    /// <remarks>
    ///   With the lighting system editor added, the scene's lighting settings can be
    ///   configured visually using the Sunburn 
    /// </remarks>
    private void setupLightingSystemEditor() {
      var lightingSystemEditor = Kernel.Get<LightingSystemEditor>();

      var sceneInterface = Kernel.Get<SceneInterface>();
      sceneInterface.AddManager(lightingSystemEditor);

      var gameComponents = Kernel.Get<GameComponentCollection>();
      var lightingSystemEditorComponent = Kernel.Get<LightingSystemEditorComponent>();
      gameComponents.Add(lightingSystemEditorComponent);
    }

  }

} // namespace Nuclex.Ninject.Sunburn