#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_DIRECT3D11INPUTLAYOUTMANAGER_H
#define NUCLEX_GRAPHICS_RASTERIZATION_DIRECT3D11INPUTLAYOUTMANAGER_H

#include "Nuclex/Graphics/Config.h"
#include "Nuclex/Graphics/Rasterization/RasterizerSettings.h"
#include "../../Helpers/LruMap.h"
#include "Direct3D11Api.h"

#include <memory>
#include <cstddef>

namespace Nuclex { namespace Graphics {

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

  struct VertexElement;

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

}} // namespace Nuclex::Graphics

namespace Nuclex { namespace Graphics { namespace Rasterization {

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

  class GenericVertexBuffer;
  class Shader;

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

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

namespace Nuclex { namespace Graphics { namespace Rasterization {

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

  /// <summary>Creates and manages vertex input layout specifications</summary>
  /// <remarks>
  ///   <para>
  ///     One input layout must be created for each unique combination of shader input
  ///     signature and vertex element composition (= vertex elements in each vertex buffer
  ///     slot). Applications use only a limited number of these combinations (as the same
  ///     shader normally gets applied to the same vertex buffers over and over each frame),
  ///     so an LRU cache is a good match to store input layouts.
  ///   </para>
  ///   <para>
  ///     Such a cache could aggressively try to avoid redundant input layouts (for example,
  ///     if a shader is used with multiple vertex buffers sharing the same vertex layout),
  ///     but this would add a lot of complexity to the implementation, so currently this
  ///     manager will simply use two LRU caches, one for looking up the input layout of
  ///     vertex buffer combinations and one two match these to input layouts (multiple
  ///     shaders with identical input layouts are not considered).
  ///   </para>
  /// </remarks>
  class Direct3D11InputLayoutManager {

    /// <summary>Number of unique vertex element list combinations that can be cached</summary>
    /// <remarks>
    ///   <para>
    ///     This is the number of unique combinations of vertex buffer types that can be
    ///     cached. If an application, for example, used one vertex buffer type for rendering
    ///     its GUI and two vertex buffers to render a terrain, this would be two unique
    ///     combinations. Such combinations typically recur from frame to frame and even
    ///     complex scenes only have a dozen or so unique combinations.
    ///   </para>
    ///   <para>
    ///     If an application kept reusing some combinations but cycled through a large list
    ///     of other combinations that defeats this LRU cache, we would (after the std::size_t
    ///     exploded) eventually have an id collision, causing broken graphics or even
    ///     a crash. That's why this cache is sized so ridiculously huge.
    ///   </para>
    /// </remarks>
    private: const static std::size_t VertexCombinationCacheSize = 1024;

    /// <summary>Maximum number of input layouts active at the same time</summary>
    private: const static std::size_t InputLayoutCacheSize = 64;

    #pragma region struct VertexElementListSet

    /// <summary>A set of vertex element lists</summary>
    private: struct VertexElementListSet {

      #pragma region struct Hash

      /// <summary>Hash functor for storing the set in a hashed container</summary>
      public: struct Hash {

        /// <summary>Provides the hash value of the specified vertex element list set</summary>
        /// <param name="listSet">Set for which the hash value will be returned</param>
        /// <returns>The hash value for the specified vertex element list set</returns>
        public: std::size_t operator()(const VertexElementListSet &listSet) const {
          return listSet.hash;
        }

      };

      #pragma endregion // struct Hash

      /// <summary>Adds a vertex element list to the set</summary>
      /// <param name="elements">List that will be added to the set</param>
      /// <remarks>
      ///   This method mutates the list set and must therefore not be used after
      ///   the list set has been added to a map. It also assumes that vertex element
      ///   lists and immutable (thus it is satisfied with a pointer to each list's
      ///   first element and does no checking of individual list elements).
      /// </remarks>
      public: void AddVertexElementList(const VertexElement *elements) {
        this->vertexElementLists.push_back(elements);
        this->hash ^= reinterpret_cast<const std::size_t>(elements) << this->vertexElementLists.size();
      }

      /// <summary>Removes all vertex element lists from the list set</summary>
      public: void Clear() {
        this->vertexElementLists.clear();
        this->hash = 0;
      }

      /// <summary>Checks if this list set is identical to another instance</summary>
      /// <param name="other">Other instance the list set will be compared against</param>
      /// <returns>True if the list sets are identical</returns>
      public: bool operator ==(const VertexElementListSet &other) const {
        std::size_t ownSize = this->vertexElementLists.size();
        if(other.vertexElementLists.size() != ownSize) {
          return false;
        }

        for(std::size_t index = 0; index < ownSize; ++index) {
          if(this->vertexElementLists[index] != other.vertexElementLists[index]) {
            return false;
          }
        }

        return true;
      }

      /// <summary>Checks if this list set is different from another instance</summary>
      /// <param name="other">Other instance the list set will be compared against</param>
      /// <returns>True if the list sets are different</returns>
      public: bool operator !=(const VertexElementListSet &other) const {
        std::size_t ownSize = this->vertexElementLists.size();
        if(other.vertexElementLists.size() != ownSize) {
          return true;
        }

        for(std::size_t index = 0; index < ownSize; ++index) {
          if(this->vertexElementLists[index] != other.vertexElementLists[index]) {
            return true;
          }
        }

        return false;
      }

      /// <summary>Vertex element lists stored in the list set</summary>
      private: std::vector<const VertexElement *> vertexElementLists;
      /// <summary>Hash code of this instance</summary>
      private: std::size_t hash;

    };

    #pragma endregion // struct VertexElementListSet

    #pragma region struct ShaderVertexCombinationIdMapping

    /// <summary>Shader to vertex buffer combination mapping</summary>
    private: struct ShaderVertexCombinationIdMapping {

      #pragma region struct Hash

      /// <summary>Hash functor for storing the set in a hashed container</summary>
      public: struct Hash {

        /// <summary>Calculates the hash value of the specified mapping</summary>
        /// <param name="mapping">Mapping for which a hash value will be generated</param>
        /// <returns>The hash value for the specified list set</returns>
        public: std::size_t operator()(const ShaderVertexCombinationIdMapping &mapping) const {
          return reinterpret_cast<const std::size_t>(mapping.shader) ^ mapping.combinationId;
        }

      };

      #pragma endregion // struct Hash

      /// <summary>Initializes a shader to </summary>
      /// <param name="shader">Shader that the combination will be for</param>
      /// <param name="combinationId">Unique id of the vertex element list combination</param>
      public: ShaderVertexCombinationIdMapping(
        const Shader *shader, std::size_t combinationId
      ) :
        shader(shader),
        combinationId(combinationId) {}

      /// <summary>Checks if this list set is identical to another instance</summary>
      /// <param name="other">Other instance the list set will be compared against</param>
      /// <returns>True if the list sets are identical</returns>
      public: bool operator ==(const ShaderVertexCombinationIdMapping &other) const {
        return (this->shader == other.shader) && (this->combinationId == other.combinationId);
      }

      /// <summary>Checks if this list set is different from another instance</summary>
      /// <param name="other">Other instance the list set will be compared against</param>
      /// <returns>True if the list sets are different</returns>
      public: bool operator !=(const ShaderVertexCombinationIdMapping &other) const {
        return (this->shader != other.shader) || (this->combinationId != other.combinationId);
      }

      /// <summary>Shader the combination was created for</summary>
      /// <remarks>
      ///   The pointer has to be considered opaque since the actual memory contents it points
      ///   to could be long gone by the time the combination checks up on it.
      /// </remarks>
      private: const Shader *shader;
      /// <summary>
      ///   Unique id of the vertex element list combination the shader is mapped to
      /// </summary>
      private: std::size_t combinationId;

    };

    #pragma endregion // struct ShaderVertexCombinationIdMapping

    /// <summary>Initializes a new Direct3D 11 input layout manager</summary>
    public: Direct3D11InputLayoutManager() {}

    /// <summary>Frees all resources owned by the input layout manager</summary>
    public: virtual ~Direct3D11InputLayoutManager() {}

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

    /// <summary>
    ///   Retrieves the input layout for the specified vertex buffer combination
    /// </summary>
    /// <param name="shader">Shader the input layout will be for</param>
    /// <param name="vertexBuffers">
    ///   Vertex buffers for which the input layout will be looked up or created
    /// </param>
    /// <param name="vertexBufferCount">Number of vertex buffers in the first argument</param>
    /// <returns>The input layout for the specified vertex buffers</returns>
    public: ID3D11InputLayoutPtr GetInputLayout(
      const Shader *shader,
      const std::shared_ptr<GenericVertexBuffer> *vertexBuffers,
      std::size_t vertexBufferCount
    );

    /// <summary>
    ///   Creates a new input layout for the specified shader and vertex combination
    /// </summary>
    /// <param name="shader">Shader the input layout will be for</param>
    /// <param name="vertexBuffers">
    ///   Vertex buffers for which the input layout will be looked up or created
    /// </param>
    /// <param name="vertexBufferCount">Number of vertex buffers in the first argument</param>
    /// <returns>A new input layout for the specified vertex and shader combination</returns>
    private: ID3D11InputLayoutPtr createInputLayout(
      const Shader *shader,
      const std::shared_ptr<GenericVertexBuffer> *vertexBuffers,
      std::size_t vertexBufferCount
    );

    /// <summary>
    ///   Looks up or creates a new unique id for a combination of vertex element lists
    /// </summary>
    /// <param name="vertexBuffers">Vertex buffers in the combination</param>
    /// <param name="vertexBufferCount">Number of vertex buffers in the combination</param>
    /// <returns>The unique combination id of the specified combination</returns>
    private: std::size_t getOrCreateCombinationID(
      const std::shared_ptr<GenericVertexBuffer> *vertexBuffers,
      std::size_t vertexBufferCount
    );

    /// <summary>Maps lists of vertex buffer element lists to unique identifiers</summary>
    private: typedef Helpers::LruMap<
      VertexElementListSet, // Key
      std::size_t, // Value
      VertexElementListSet::Hash // Hash functor
    > VertexCombinationMap;

    /// <summary>Maps sets of vertex elements to input layouts</summary>
    private: typedef Helpers::LruMap<
      ShaderVertexCombinationIdMapping, // Key
      ID3D11InputLayoutPtr, // Value
      ShaderVertexCombinationIdMapping::Hash // Hash functor
    > InputLayoutMap;

    /// <summary>Direct3D device the settings will be applied to</summary>
    private: ID3D11DeviceNPtr device;
    /// <summary>
    ///   Next unique identifier that will be generated for a vertex element list combination
    /// </summary>
    private: std::size_t nextVertexCombinationID;
    /// <summary>Helper used when looking up a combination id</summary>
    /// <remarks>
    ///   This could be a local variable, but by making the combination modifiable and
    ///   keeping it around, the element list vector will not have to be reallocated.
    /// </remarks>
    private: VertexElementListSet searchedCombination;
    /// <summary>Helpers used to store the sizes of the vertex element lists</summary>
    private: std::vector<std::size_t> elementListSizes;
    /// <summary>Ids for unique vertex element list combinations encountered</summary>
    private: VertexCombinationMap vertexCombinations;
    /// <summary>Input layouts created for the vertex combination to shader mappings</summary>
    private: InputLayoutMap inputLayouts;

  };

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

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

#endif // NUCLEX_GRAPHICS_RASTERIZATION_DIRECT3D11INPUTLAYOUTMANAGER_H