#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_VERTEXBUFFER_H
#define NUCLEX_GRAPHICS_RASTERIZATION_VERTEXBUFFER_H

#include "GenericVertexBuffer.h"

#include <cassert>

namespace Nuclex { namespace Graphics { namespace Rasterization {

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

  ///<summary>Stores strongly typed vertices used to define geometric features</summary>
  template<typename TVertex, typename TDescriptor = TVertex>
  class VertexBuffer : public GenericVertexBuffer {

    /// <summary>Initializes a vertex buffer with the specified capacity</summary>
    /// <param name="capacityInVertices">Number of vertices the vertex buffer will hold</param>
    /// <param name="usage">How the vertex buffer will be accessed</param>
    public: VertexBuffer(
      std::size_t capacityInVertices, Usage::Enum usage = Usage::Immutable
    ) : GenericVertexBuffer(capacityInVertices * sizeof(TVertex), usage) {}

    /// <summary>Initializes a vertex buffer by copying an existing vertex buffer</summary>
    /// <param name="other">Vertex buffer that will be copied</param>
    public: VertexBuffer(const VertexBuffer &other) :
      GenericVertexBuffer(other) {}

    /// <summary>Called when the vertex buffer is being destroyed</summary>
    public: virtual ~VertexBuffer() {
      OnDestroying();
    }

    /// <summary>Retrieves the stride to get from one vertex to the next</summary>
    /// <returns>The stride of the vertex buffer in bytes</returns>
    public: virtual std::size_t GetStride() const {
      //TVertex *vertices = nullptr;
      //return reinterpret_cast<std::size_t>(vertices[1]);
      return sizeof(TVertex);
    }

    /// <summary>Retrieves the total capacity of the vertex buffer in vertices</summary>
    /// <returns>The capacity of the vertex buffer in vertices</returns>
    public: std::size_t GetCapacityInVertices() const {
      return this->CapacityBytes / sizeof(TVertex);
    }

    /// <summary>Retrieves the number of vertices that have been used</summary>
    /// <returns>The number of used vertices in the vertex buffer</returns>
    public: std::size_t CountUsedVertices() const {
      return CountUsedBytes() / sizeof(TVertex);
    }

    /// <summary>Retrieves the number of elements a vertex consists of</summary>
    /// <returns>The number of elements in a vertex</returns>
    public: std::size_t CountVertexElements() const {
      return TDescriptor::Describe().size();
    }

    /// <summary>Retrieves an array describing the elements a vertex consists of</summary>
    /// <returns>An array describing the elements a vertices are made up from</returns>
    public: virtual const VertexElement *GetVertexElements() const {
      return TDescriptor::Describe().data();
    }

    /// <summary>Reads vertices from the vertex buffer</summary>
    /// <param name="offset">Offset, in vertices, from which on data will be read</param>
    /// <param name="vertices">Address at which the vertices read will be deposited</param>
    /// <param name="count">Number of vertices that will be read</param>
    public: void Read(
      std::size_t offset, TVertex *vertices, std::size_t count
    ) const {
      enforceRangeStaysWithinBuffer(offset, count);

      const TVertex *contentVertices = reinterpret_cast<const TVertex *>(this->Contents);

      count = std::min(count, CountUsedVertices() - offset);
      std::copy_n(contentVertices + offset, count, vertices);
    }

    /// <summary>Writes vertices into the vertex buffer</summary>
    /// <param name="offset">Offset, in vertices, at which data will be written</param>
    /// <param name="vertices">Vertices that will be written into the vertex buffer</param>
    /// <param name="count">Number of vertices that will be written</param>
    public: void Write(
      std::size_t offset, const TVertex *vertices, std::size_t count
    ) {
      std::size_t lastVertex = offset + count;
      if((offset >= this->CapacityBytes) || (lastVertex > this->CapacityBytes)) {
        throw std::out_of_range("Buffer write outside valid buffer range");
      }

      TVertex *contentVertices = reinterpret_cast<TVertex *>(this->Contents);

      std::copy_n(vertices, count, contentVertices + offset);
      OnChanged(offset * sizeof(TVertex), count * sizeof(TVertex));
    }

    /// <summary>Appends the specified vertex to the end of the vertex buffer</summary>
    /// <param name="vertex">Vertex that will be appended</param>
    /// <returns>The vertex buffer itself to allow for method chaining</returns>
    public: VertexBuffer &Append(const TVertex &vertex) {
      if(sizeof(TVertex) > this->CapacityBytes - CountUsedBytes()) {
        throw std::runtime_error("No more space in vertex buffer");
      }

      Write(CountUsedVertices(), &vertex, 1);
      return *this;
    }

    /// <summary>Causes an exception if the specified range leaves the buffer</summary>
    /// <param name="firstVertex">Vertex at which the range starts</param>
    /// <param name="count">Number of vertices that will be considered</param>
    private: void enforceRangeStaysWithinBuffer(
      std::size_t firstVertex, std::size_t count
    ) const {
      std::size_t lastVertex = firstVertex + count;

      {
        std::size_t capacityInVertices = GetCapacityInVertices();
        if((firstVertex >= capacityInVertices) || (lastVertex > capacityInVertices)) {
          throw std::out_of_range("Requested range leaves the vertex buffer");
        }
      }

      #if _DEBUG
      {
        using namespace std;

        std::size_t usedVertexCount = CountUsedVertices();
        assert(
          (firstVertex < usedVertexCount) && (lastVertex <= usedVertexCount) &&
          "Vertex range should stay within the used area of the vertex buffer"
        );
      }
      #endif
    }

  };

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

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

#endif // NUCLEX_GRAPHICS_RASTERIZATION_VERTEXBUFFER_H