#pragma region CPL License
/*
Nuclex Native Framework
Copyright (C) 2002-2013 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
*/
#pragma endregion // CPL License

#ifndef NUCLEX_GRAPHICS_RASTERIZATION_DIRECT3D11RASTERIZERRESOURCES_H
#define NUCLEX_GRAPHICS_RASTERIZATION_DIRECT3D11RASTERIZERRESOURCES_H

#include "Nuclex/Graphics/Config.h"
#include "Nuclex/Graphics/Rasterization/RasterizerResources.h"

#include "Direct3D11Api.h"
#include "Direct3D11ObserverManager.h"

#include <set>

namespace Nuclex { namespace Graphics { namespace Rasterization {

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

  class GenericVertexBuffer;
  class GenericIndexBuffer;
  class GenericConstantBuffer;
  class VertexShader;
  class PixelShader;
  class Texture2;
  class RenderTarget2;
  class PolygonOptions;
  class SamplerOptions;

  class Direct3D11VertexBufferObserver;
  class Direct3D11IndexBufferObserver;
  class Direct3D11ConstantBufferObserver;
  class Direct3D11VertexShaderObserver;
  class Direct3D11PixelShaderObserver;
  class Direct3D11Texture2Observer;
  class Direct3D11RenderTarget2Observer;
  class Direct3D11PolygonOptionsObserver;
  class Direct3D11SamplerOptionsObserver;

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

}}} // namespace Nuclex::Graphics::Rasterization

namespace Nuclex { namespace Graphics { namespace Rasterization {

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

  ///<summary>Controls various settings the rasterizer can be configured with</summary>
  class Direct3D11RasterizerResources : public RasterizerResources {

    #pragma region class ResourceHolder

    /// <summary>Manages the observers for a specific resource type</summary>
    /// <typeparam name="TAgnostic">
    ///   API-neutral class for which observers are managed
    /// </typeparam>
    /// <typeparam name="TObserver">
    ///   Observers that will be attached to the neutral objects
    /// </typeparam>
    private: template<typename TAgnostic, typename TObserver> class ResourceHolder :
      public Direct3D11ObserverManager<TAgnostic, TObserver> {

      /// <summary>Initializes a new holder for the resource</summary>
      /// <param name="resources">Resource manager the resource holder belongs to</param>
      public: ResourceHolder(Direct3D11RasterizerResources *resources) :
        Direct3D11ObserverManager(resources) {}

      /// <summary>Frees all resources owned by the resource holder</summary>
      public: ~ResourceHolder() {}

      /// <summary>Kills all observers of the resource holder</summary>
      public: void EvictAll() {
        std::lock_guard<std::mutex> lock(this->mutex);
        Direct3D11ObserverManager::EvictAll();
      }

      /// <summary>Retrieves the resource's attached observer</summary>
      /// <param name="resource">
      ///   Resource whose currently attached observer will be returned
      /// </param>
      /// <returns>The observer currently attached to the specified resource</returns>
      /// <remarks>
      ///   This method does not lock the mutex and must only be called from the rendering
      ///   thread for resources that are known to be pinned and therefore cannot be
      ///   evicted by another thread while this method executes.
      /// </remarks>
      public: TObserver *Get(TAgnostic *resource) {
        return Direct3D11ObserverManager::Get(resource);
      }

      /// <summary>Attaches an observer to the resource or returns its current one</summary>
      /// <param name="resource">
      ///   Resource an observer will be attached to or whose current observer will be returned
      /// </param>
      /// <returns>The observer for the specified resource</returns>
      public: TObserver *Prepare(TAgnostic *resource) {
        std::lock_guard<std::mutex> lock(this->mutex);
        return Direct3D11ObserverManager::Prepare(resource);
      }

      /// <summary>Prepares a resource and pins it so it cannot be evicted</summary>
      /// <param name="resource">Resource that will be prepared and pinned</param>
      /// <returns>The observer that has been created for the specified resource</returns>
      public: TObserver *PrepareAndPin(TAgnostic *resource) {
        std::lock_guard<std::mutex> lock(this->mutex);

        TObserver *observer = Direct3D11ObserverManager::Prepare(resource);
        this->pinnedResources.insert(resource);
        return observer;
      }

      /// <summary>Unpins a resource, allowing it to be evicted</summary>
      /// <param name="resource">Resource that will be unpinned</param>
      public: void Unpin(TAgnostic *resource) {
        std::lock_guard<std::mutex> lock(this->mutex);

        std::set<TAgnostic *>::iterator iterator = this->pinnedResources.find(resource);
        this->pinnedResources.erase(iterator);
      }

      /// <summary>Kills the observer for the specified resource</summary>
      /// <param name="resource">Resource whose observer will be killed</param>
      /// <param name="observer">Observer that will be killed, if known</param>
      public: void Evict(TAgnostic *resource, TObserver *observer = nullptr) {
        std::lock_guard<std::mutex> lock(this->mutex);

        // Never evict a pinned resource
        if(this->pinnedResources.find(resource) != this->pinnedResources.end()) {
          return;
        }

        Direct3D11ObserverManager::Evict(resource, observer);
      }

      /// <summary>Retrieves the mutex used to synchronize accesses to the resource</summary>
      public: std::mutex &GetMutex() const { return this->mutex; }

      /// <summary>Resources that must not be evicted because they're in use</summary>
      private: std::set<TAgnostic *> pinnedResources;
      /// <summary>Mutex that has to be used to synchronize acccess to the resource</summary>
      private: mutable std::mutex mutex;

    };

    #pragma endregion // class ResourceHolder

    /// <summary>Initializes a new Direct3D 11 resource controller</summary>
    public: Direct3D11RasterizerResources();

    /// <summary>Frees all resources owned by the rasterizer resource manager</summary>
    public: virtual ~Direct3D11RasterizerResources();

    /// <summary>Sets the Direct3D device for which resources will be managed</summary>
    /// <param name="device">Direct3D 11 device resources will be managed for</param>
    public: void SetDirect3DDevice(const ID3D11DeviceNPtr &device) {
      this->device = device;
    }
 
    /// <summary>Sets the Direct3D device context for which settings will be managed</summary>
    /// <param name="context">Direct3D 11 device context settings will be managed for</param>
    public: void SetDirect3DDeviceContext(const ID3D11DeviceContextNPtr &context) {
      this->context = context;
    }

    /// <summary>Prepares a resource for usage by this rasterizer</summary>
    /// <param name="resource">Resource the rasterizer will prepare to use</param>
    public: void Prepare(const std::shared_ptr<Resource> &resource);

    /// <summary>Evicts the resource from the rasterizer</summary>
    /// <param name="resource">Resource that will be evicted from the rasterizer</param>
    public: void Evict(const std::shared_ptr<Resource> &resource);

    /// <summary>Retrieves the Direct3D device the resources are created on</summary>
    /// <returns>The Direct3D device used to create the resources</returns>
    public: const ID3D11DeviceNPtr &GetDevice() const {
      return this->device;
    }

    /// <summary>Retrieves the Direct3D device context managing the device's state</summary>
    /// <returns>The Direct3D device context managing the device's state</returns>
    public: const ID3D11DeviceContextNPtr &GetDeviceContext() const {
      return this->context;
    }

    /// <summary>Manages the observers for index buffers</summary>
    public: ResourceHolder<GenericIndexBuffer, Direct3D11IndexBufferObserver> IndexBufferHolder;

    /// <summary>Manages the observers for vertex buffers</summary>
    public: ResourceHolder<
      GenericVertexBuffer, Direct3D11VertexBufferObserver
    > VertexBufferHolder;

    /// <summary>Manages the observers for constant buffers</summary>
    public: ResourceHolder<
      GenericConstantBuffer, Direct3D11ConstantBufferObserver
    > ConstantBufferHolder;

    /// <summary>Manages the observers for vertex shaders</summary>
    public: ResourceHolder<VertexShader, Direct3D11VertexShaderObserver> VertexShaderHolder;

    /// <summary>Manages the observers for pixel shaders</summary>
    public: ResourceHolder<PixelShader, Direct3D11PixelShaderObserver> PixelShaderHolder;

    /// <summary>Manages the observers for 2D textures</summary>
    public: ResourceHolder<Texture2, Direct3D11Texture2Observer> Texture2Holder;

    /// <summary>Manages the observers for render targets</summary>
    public: ResourceHolder<RenderTarget2, Direct3D11RenderTarget2Observer> RenderTarget2Holder;

    /// <summary>Manages the observers for polygon options</summary>
    public: ResourceHolder<
      PolygonOptions, Direct3D11PolygonOptionsObserver
    > PolygonOptionsHolder;

    /// <summary>Manages the observers for sampler options</summary>
    public: ResourceHolder<
      SamplerOptions, Direct3D11SamplerOptionsObserver
    > SamplerOptionsHolder;

    /// <summary>Direct3D device the resources will be managed for</summary>
    private: ID3D11DeviceNPtr device;
    /// <summary>Direct3D device context that contains the device's state</summary>
    private: ID3D11DeviceContextNPtr context;

  };

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

}}} // namespace Nuclex::Graphics::Rasterization

#endif // NUCLEX_GRAPHICS_RASTERIZATION_DIRECT3D11RASTERIZERRESOURCES_H