#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_INDEXBUFFER_H
#define NUCLEX_GRAPHICS_RASTERIZATION_INDEXBUFFER_H

#include "GenericIndexBuffer.h"

namespace Nuclex { namespace Graphics { namespace Rasterization {

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

  /// <summary>Stores strongly typed indices used to connect vertices to primitives</summary>
  template<typename TIndex> class IndexBuffer;

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

  /// <summary>Stores 16 bit indices used to connect vertices to primitives</summary>
  template<>
  class IndexBuffer<std::uint16_t> : public GenericIndexBuffer {

    /// <summary>
    ///   Defines a range of vertices by the starting index and one past the last index
    /// </summary>
    typedef std::pair<std::uint16_t, std::uint16_t> VertexRange;

    /// <summary>Initializes a new index buffer with the specified capacity</summary>
    /// <param name="capacityInIndices">Number of indices the buffer will store</param>
    /// <param name="usage">How the index buffer is going to be accessed</param>
    public: NUCLEX_GRAPHICS_API IndexBuffer(
      std::size_t capacityInIndices, Usage::Enum usage = Usage::Immutable
    ) : GenericIndexBuffer(capacityInIndices * 2, usage) {}

    /// <summary>Initializes an index buffer by copying an existing index buffer</summary>
    /// <param name="other">Existing index buffer that will be copied</param>
    public: NUCLEX_GRAPHICS_API IndexBuffer(const IndexBuffer &other) :
      GenericIndexBuffer(other) {}

    /// <summary>Frees all resources owned by the index buffer</summary>
    public: NUCLEX_GRAPHICS_API virtual ~IndexBuffer() {
      OnDestroying();
    }

    /// <summary>Always returns false since this is a 16 bit index buffer</summary>
    /// <returns>False</returns>
    public: NUCLEX_GRAPHICS_API virtual bool Is32BitIndexBuffer() const { return false; }

    /// <summary>Retrieves the total capacity of the index buffer in indices</summary>
    /// <returns>The capacity of the index buffer in indices</returns>
    public: NUCLEX_GRAPHICS_API std::size_t GetCapacityInIndices() const {
      return this->CapacityBytes / 2;
    }

    /// <summary>Retrieves the number of indices that have been used</summary>
    /// <returns>The number of used indices in the index buffer</returns>
    public: NUCLEX_GRAPHICS_API std::size_t CountUsedIndices() const {
      return CountUsedBytes() / 2;
    }

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

    /// <summary>Writes indices into the index buffer</summary>
    /// <param name="offset">Offset, in indices, at which data will be written</param>
    /// <param name="indices">Indices that will be written into the index buffer</param>
    /// <param name="count">Number of indices that will be written</param>
    public: NUCLEX_GRAPHICS_API void Write(
      std::size_t offset, const std::uint16_t *indices, std::size_t count
    );

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

      Write(CountUsedIndices(), &index, 1);
      return *this;
    }

    /// <summary>
    ///   Determines the lowest and the highest vertex index present in the indices
    /// </summary>
    /// <param name="firstIndex">First index that will be taken into consideration</param>
    /// <param name="count">Number of indices that will be checked</param>
    public: NUCLEX_GRAPHICS_API VertexRange GetLowestAndHighestVertexIndex(
      std::size_t firstIndex = 0, std::size_t count = static_cast<std::size_t>(-1)
    ) const;

    /// <summary>Copies the contents of another buffer into this buffer</summary>
    /// <param name="other">Other buffer whose contents will be copied</param>
    /// <returns>A reference to this buffer</returns>
    public: NUCLEX_GRAPHICS_API IndexBuffer &operator =(const IndexBuffer &other) {
      GenericIndexBuffer::operator=(other);
      OnChanged(0, CountUsedBytes());
      return *this;
    }

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

  };

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

  /// <summary>Stores 32 bit indices used to connect vertices to primitives</summary>
  template<>
  class IndexBuffer<std::uint32_t> : public GenericIndexBuffer {

    /// <summary>
    ///   Defines a range of vertices by the starting index and one past the last index
    /// </summary>
    typedef std::pair<std::uint32_t, std::uint32_t> VertexRange;

    /// <summary>Initializes a new index buffer with the specified capacity</summary>
    /// <param name="capacityInIndices">Number of indices the buffer will store</param>
    /// <param name="usage">How the index buffer is going to be accessed</param>
    public: NUCLEX_GRAPHICS_API IndexBuffer(
      std::size_t capacityInIndices, Usage::Enum usage = Usage::Immutable
    ) : GenericIndexBuffer(capacityInIndices * 4, usage) {}

    /// <summary>Initializes an index buffer by copying an existing index buffer</summary>
    /// <param name="other">Existing index buffer that will be copied</param>
    public: NUCLEX_GRAPHICS_API IndexBuffer(const IndexBuffer &other) :
      GenericIndexBuffer(other) {}

    /// <summary>Frees all resources owned by the index buffer</summary>
    public: NUCLEX_GRAPHICS_API virtual ~IndexBuffer() {
      OnDestroying();
    }

    /// <summary>Always returns true since this is a 32 bit index buffer</summary>
    /// <returns>True</returns>
    public: NUCLEX_GRAPHICS_API virtual bool Is32BitIndexBuffer() const { return false; }

    /// <summary>Retrieves the total capacity of the index buffer in indices</summary>
    /// <returns>The capacity of the index buffer in indices</returns>
    public: NUCLEX_GRAPHICS_API std::size_t GetCapacityInIndices() const {
      return this->CapacityBytes / 4;
    }

    /// <summary>Retrieves the number of indices that have been used</summary>
    /// <returns>The number of used indices in the index buffer</returns>
    public: NUCLEX_GRAPHICS_API std::size_t CountUsedIndices() const {
      return CountUsedBytes() / 4;
    }

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

    /// <summary>Writes indices into the index buffer</summary>
    /// <param name="offset">Offset, in indices, at which data will be written</param>
    /// <param name="indices">Indices that will be written into the index buffer</param>
    /// <param name="count">Number of indices that will be written</param>
    public: NUCLEX_GRAPHICS_API void Write(
      std::size_t offset, const std::uint32_t *indices, std::size_t count
    );

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

      Write(CountUsedIndices(), &index, 1);
      return *this;
    }

    /// <summary>
    ///   Determines the lowest and the highest vertex index present in the indices
    /// </summary>
    /// <param name="firstIndex">First index that will be taken into consideration</param>
    /// <param name="count">Number of indices that will be checked</param>
    public: NUCLEX_GRAPHICS_API VertexRange GetLowestAndHighestVertexIndex(
      std::size_t firstIndex = 0, std::size_t count = static_cast<std::size_t>(-1)
    ) const;

    /// <summary>Copies the contents of another buffer into this buffer</summary>
    /// <param name="other">Other buffer whose contents will be copied</param>
    /// <returns>A reference to this buffer</returns>
    public: NUCLEX_GRAPHICS_API IndexBuffer &operator =(const IndexBuffer &other) {
      GenericIndexBuffer::operator=(other);
      OnChanged(0, CountUsedBytes());
      return *this;
    }

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

  };

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

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

#endif // NUCLEX_GRAPHICS_RASTERIZATION_INDEXBUFFER_H