#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_SCENE_MESHES_MESH_H
#define NUCLEX_SCENE_MESHES_MESH_H

#include "Nuclex/Scene/Config.h"
#include "Nuclex/Scene/Position3.h"

#include <cstdint>
#include <memory>
#include <vector>

namespace Nuclex { namespace Scene { namespace Meshes {

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

  /// <summary>Mesh built from 3D vertices forming a triangle topology</summary>
  /// <remarks>
  ///   This class stores any number of arbitrary data streams in a non-interleaved format.
  ///   It is intended for interfacing with model importers and to feed (usually interleaved)
  ///   vertex buffers with the elements the shader actually processes.
  /// </remarks>
  class Mesh {

    #pragma region class GenericVertexContainer

    /// <summary>Generic interface to a vertex data stream</summary>
    private: class GenericVertexContainer {

      /// <summary>Frees all resources used by the vertex data stream</summar>
      public: virtual ~GenericVertexContainer() {}

      /// <summary>Retrieves the size of a vertex element of this type</summary>
      /// <returns>The size of a single vertex element of this type</returns>
      public: virtual std::size_t GetElementSize() const = 0;

      /// <summary>Accesses the contents of the vertex data stream</summary>
      /// <returns>A pointer to the beginning of the vertex data stream</summary>
      public: virtual void *Access() = 0;

      /// <summary>Creates a copy of the vertex data stream</summary>
      /// <param name="count">The size of the vertex data stream being cloned</param>
      /// <returns>A copy of the vertex data stream</returns>
      public: virtual GenericVertexContainer *Clone(std::size_t count) const = 0;

    };

    #pragma endregion // class GenericVertexContainer

    #pragma region class VertexContainer

    /// <summary>Stores the contents of a vertex data stream</summary>
    private: template<typename TVertexData>
    class VertexContainer : public GenericVertexContainer {

      /// <summary>Initializes a new vertex data stream</summary>
      /// <param name="count">Number of vertices in the vertex data stream</param>
      public: VertexContainer(std::size_t count) :
        data(new TVertexData[count]) {}
      
      /// <summary>Frees all resources used by the vertex data stream</summary>
      public: virtual ~VertexContainer() {}

      /// <summary>Retrieves the size of a vertex element of this type</summary>
      /// <returns>The size of a single vertex element of this type</returns>
      public: virtual std::size_t GetElementSize() const {
        // Alignment rules: elements in an array are always contiguous. If alignment
        // is performed, it is performed within the structure, so a sizeof on
        // a single element is guaranteed to be identical to the array's stride.
        return sizeof(TVertexData);
      }

      /// <summary>Accesses the contents of the vertex data stream</summary>
      /// <returns>A pointer to the beginning of the vertex data stream</summary>
      public: void *Access() { return static_cast<void *>(this->data.get()); }

      /// <summary>Creates a copy of the vertex data stream</summary>
      /// <param name="count">The size of the vertex data stream being cloned</param>
      /// <returns>A copy of the vertex data stream</returns>
      public: VertexContainer *Clone(std::size_t count) const {
        std::unique_ptr<VertexContainer> clone(new VertexContainer(count));
        std::copy_n(this->data.get(), count, clone->data.get());
        return clone.release();
      }

      /// <summary>Contents of the vertex data stream</summary>
      private: std::unique_ptr<TVertexData[]> data;

    };

    #pragma endregion // class VertexContainer

    /// <summary>Initializes a new mesh</summary>
    /// <param name="vertexCount">Number of vertices the mesh will store</param>
    /// <param name="indexCount">Number of indices used by the mesh</param>
    public: Mesh(std::size_t vertexCount, std::size_t indexCount) :
      indexCount(indexCount),
      indices(new std::uint16_t[indexCount]),
      vertexCount(vertexCount) {}

    /// <summary>Counts the number of vertices in the model</summary>
    public: std::size_t CountVertices() const {
      return this->vertexCount;
    }

    /// <summary>Counts the number of indices used to build polygons from the vertices</summary>
    public: std::size_t CountIndices() const {
      return this->indexCount;
    }

    /// <summary>Checks whether vertex data of the specified type is present</summary>
    /// <typeparam name="TVertexData">Type of vertex data that will be checked for</typeparam>
    /// <returns>True if vertex data of the specified type is present</returns>
    public: template<typename TVertexData> bool HasVertexData() const {
      return HasVertexData(typeid(TVertexData));
    }

    /// <summary>Checks whether vertex data of the specified type is present</summary>
    /// <param name="type">Type id of the vertex data stream that will be retrieved</param>
    /// <returns>True if vertex data of the specified type is present</returns>
    public: bool HasVertexData(std::uint32_t type) const {
      for(std::size_t index = 0; index < this->vertexData.size(); ++index) {
        if(type == this->vertexData[index].first) {
          return true;
        }
      }

      return false;
    }

    /// <summary>Accesses the vertex data of the specified type</summary>
    /// <typeparam name="TVertexData">Which type of vertex data will be accessed</typeparam>
    /// <param name="type">Type id of the vertex data stream that will be retrieved</param>
    /// <param name="create">Whether to create the data stream if it doesn't exist</param>
    /// <remarks>
    ///   <para>
    ///     Meshes store vertex data of any arbitrary type. Normally each vertex has at least
    ///     a set of 3D coordinates (<see cref="Position3" />) describing its location and
    ///     texture coordinates (<see cref="Position2" />) to indicate which point of
    ///     the texture should match up with the corner of the triangle the vertex represents.
    ///   </para>
    ///   <para>
    ///     The type ids of these any other standard vertex data streams can be found
    ///     in the VertexElementIds header.
    ///   </para>
    /// </remarks>
    public: template<typename TVertexData> TVertexData *AccessVertexData(
      std::uint32_t type, bool create = false
    ) {
      for(std::size_t index = 0; index < this->vertexData.size(); ++index) {
        if(type == this->vertexData[index].first) {
          return static_cast<TVertexData *>(this->vertexData[index].second->Access());
        }
      }

      if(create) {
        std::unique_ptr<VertexContainer<TVertexData>> vertexContainer(
          new VertexContainer<TVertexData>(this->vertexCount)
        );
        TVertexData *data = static_cast<TVertexData *>(vertexContainer->Access());
        this->vertexData.push_back(std::make_pair(type, std::move(vertexContainer)));
        return data;
      } else {
        throw std::exception("Mesh does not contain a stream of specified vertex data type");
      }
    }

    /// <summary>Accesses the vertex data of the specified type</summary>
    /// <typeparam name="TVertexData">Which type of vertex data will be accessed</typeparam>
    /// <param name="type">Type id of the vertex data stream that will be retrieved</param>
    /// <remarks>
    ///   Meshes store vertex data of any arbitrary type. Typically each vertex has at least
    ///   a set of 3D coordinates (<see cref="Position3" />) describing its location and
    ///   texture coordinates (<see cref="Position2" />) to indicate which point of the texture
    ///   should match up with the corner of the triangle the vertex represents.
    /// </remarks>
    public: template<typename TVertexData> const TVertexData *AccessVertexData(
      std::uint32_t type
    ) const {
      const std::type_info type = typeid(TVertexData);
      for(std::size_t index = 0; index < this->vertexData.size(); ++index) {
        if(type == this->vertexData[index].first) {
          return static_cast<TVertexData *>(this->vertexData[index].second->Access());
        }
      }

      throw std::exception("Mesh does not contain a stream of the specified vertex data type");
    }

    /// <summary>Accessess the indices used to connect vertices to triangles</summary>
    public: std::uint16_t *AccessIndices() {
      return this->indices.get();
    }

    /// <summary>Accessess the indices used to connect vertices to triangles</summary>
    public: const std::uint16_t *AccessIndices() const {
      return this->indices.get();
    }

    /// <summary>Pointer to a vertex data container</summary>
    private: typedef std::unique_ptr<GenericVertexContainer> VertexContainerPointer;
    /// <summary>Pairs the type of vertex data stroed with the vertex data container</summary>
    private: typedef std::pair<std::uint32_t, VertexContainerPointer> TypeVertexPair;
    /// <summary>Vertex data streams the mesh is equipped with</summary>
    private: typedef std::vector<TypeVertexPair> VertexDataVector;

    /// <summary>Number of indices used by the mesh</summary>
    private: std::size_t indexCount;
    /// <summary>Indices establishing how the vertices connect to a triangle topology</summary>
    private: std::unique_ptr<std::uint16_t[]> indices;
    /// <summary>Number of vertices used by the mesh</summary>
    private: std::size_t vertexCount;
    /// <summary>Stores the data attached to each of the mesh's vertices</summary>
    private: VertexDataVector vertexData;

  };

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

}}} // namespace Nuclex::Scene::Meshes

#endif // NUCLEX_SCENE_MESHES_MESH_H