#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_SHADER_H
#define NUCLEX_GRAPHICS_RASTERIZATION_SHADER_H

#include "Resource.h"
#include "Usage.h"
#include "../Helpers/ConcurrentObserverSet.h"

#include <cstdint>
#include <memory>

namespace Nuclex { namespace Graphics { namespace Rasterization {

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

  class GenericConstantBuffer;
  class Texture;

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

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

namespace Nuclex { namespace Graphics { namespace Introspection {

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

  struct ShaderMetadata;

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

}}} // namespace Nuclex::Graphics::Introspection

namespace Nuclex { namespace Graphics { namespace Rasterization {

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

  ///<summary>Contains GPU program instructions</summary>
  class Shader : public Resource {

    #pragma region class Observer

    /// <summary>Receives notifications from the shader when it changes</summary>
    public: class Observer : public Resource::Observer {

      /// <summary>Frees the resources used by the observer</summary>
      public: virtual ~Observer() {}

      /// <summary>Called right before the shader is destroyed</summary>
      public: virtual void Destroying() = 0;

      /// <summary>Called when a constant buffer has been set</summary>
      /// <param name="constantBufferIndex">
      ///   Index of the constant buffer that has been assigned
      /// </param>
      /// <remarks>
      ///   This only indicates when a constant buffer is assigned, not if its contents
      ///   change (for this, the constant buffer itself needs to be observed)
      /// </remarks>
      public: virtual void ConstantBufferChanged(std::size_t constantBufferIndex) = 0;

      /// <summary>Called when a texture has been set</summary>
      /// <param name="textureIndex">Index of the texture that has been assigned</param>
      /// <remarks>
      ///   This only indicates when a texture is assigned, not if its contents
      ///   change (for this, the texture itself needs to be observed)
      /// </remarks>
      public: virtual void TextureChanged(std::size_t textureIndex) = 0;

    };

    #pragma endregion // class Observer

    /// <summary>Initializes a new shader containing the specified code</summary>
    /// <param name="bytecode">Compiled code that will be run by the GPU</param>
    /// <param name="length">Length of the code in bytes</param>
    protected: NUCLEX_GRAPHICS_API Shader(
      const std::uint8_t *const bytecode, std::size_t length
    );

    /// <summary>Creates a copy of an existing shader</summary>
    /// <param name="other">Existing shader that will be copied</param>
    /// <remarks>
    ///   The copy will not take over the existing shader's attached observers.
    /// </remarks>
    protected: NUCLEX_GRAPHICS_API Shader(const Shader &other);

    /// <summary>Destroys the shader</summary>
    public: NUCLEX_GRAPHICS_API virtual ~Shader();

    /// <summary>Informations about the shader</summary>
    /// <returns>Metadata describing the shader's inputs and constants</returns>
    public: NUCLEX_GRAPHICS_API const Introspection::ShaderMetadata &Metadata() const {
      return *this->metadata.get();
    }

    /// <summary>Returns the capacity of the buffer in bytes</summary>
    /// <returns>The number of  bytes that fit in the buffer</returns>
    public: NUCLEX_GRAPHICS_API std::size_t GetProgramLengthInBytes() const {
      return this->length;
    }

    /// <summary>Accesses the memory used by the buffer</summary>
    /// <returns>The memory storing the buffer contents</returns>
    public: NUCLEX_GRAPHICS_API const std::uint8_t *AccessMemory() const {
      return this->bytecode;
    }

    /// <summary>Counts the number of constant buffers that can be bound</summary>
    /// <returns>The number of constant buffers that can be bound to the shader</returns>
    public: NUCLEX_GRAPHICS_API std::size_t CountConstantBufferSlots() const;

    /// <summary>Retrieves the constant buffer with the specified slot index</summary>
    /// <param name="index">Index of the constant buffer that will be retrieved</param>
    /// <returns>The constant buffer in the specified slot</returns>
    public: NUCLEX_GRAPHICS_API const std::shared_ptr<GenericConstantBuffer> GetConstantBuffer(
      std::size_t index
    ) const;

    /// <summary>Selects the constant buffer for the specified slot index</summary>
    /// <param name="index">Index of the constant buffer that will be selected</param>
    /// <param name="constantBuffer">Constant buffer that will be selected</param>
    public: NUCLEX_GRAPHICS_API void SetConstantBuffer(
      std::size_t index, const std::shared_ptr<GenericConstantBuffer> &constantBuffer
    );

    /// <summary>Counts the number of textures that can be bound</summary>
    /// <returns>The number of textures that can be bound to the shader</returns>
    public: NUCLEX_GRAPHICS_API std::size_t CountTextureSlots() const;

    /// <summary>Retrieves the texture with the specified slot index</summary>
    /// <param name="index">Index of the texture that will be retrieved</param>
    /// <returns>The texture in the specified slot</returns>
    public: NUCLEX_GRAPHICS_API const std::shared_ptr<Texture> GetTexture(
      std::size_t index
    ) const;

    /// <summary>Selects the texture for the specified slot index</summary>
    /// <param name="index">Index of the texture that will be selected</param>
    /// <param name="texture">Constant buffer that will be selected</param>
    public: NUCLEX_GRAPHICS_API void SetTexture(
      std::size_t index, const std::shared_ptr<Texture> &texture
    );

    /// <summary>Retrieves the observer attached by the specified owner</summary>
    /// <param name="owner">Owner whose observer will be looked up</param>
    /// <returns>The observer registered by the specified owner or a nullptr</returns>
    public: NUCLEX_GRAPHICS_API Observer *GetObserver(const void *owner) const;

    /// <summary>Attaches an observer to the shader</summary>
    /// <param name="owner">The observer's owner, used as a unique key</param>
    /// <param name="observer">Observer that will be attached to the shader</param>
    public: NUCLEX_GRAPHICS_API void AttachObserver(const void *owner, Observer *observer);

    /// <summary>Detaches the specified owner's observer from the shader</summary>
    /// <param name="owner">Owner whose observer will be detached</param>
    public: NUCLEX_GRAPHICS_API void DetachObserver(const void *owner);

    /// <summary>Copies the contents of another shader into this shader</summary>
    /// <param name="other">Other shader whose contents will be copied</param>
    /// <returns>A reference to this shader</returns>
    protected: NUCLEX_GRAPHICS_API Shader &operator =(const Shader &other);

    /// <summary>Notifies all observers that the shader is about to be destroyed</summary>
    protected: NUCLEX_GRAPHICS_API void OnDestroying();

    /// <summary>Notifies all observers that a constant buffer has been assigned</summary>
    /// <param name="constantBufferIndex">
    ///   Index of the constant buffer that has been assigned
    /// </param>
    protected: NUCLEX_GRAPHICS_API void OnConstantBufferChanged(std::size_t constantBufferIndex);

    /// <summary>Notifies all observers that a texture has been assigned</summary>
    /// <param name="textureIndex">Index of the texture that has been assigned</param>
    protected: NUCLEX_GRAPHICS_API void OnTextureChanged(std::size_t textureIndex);

    /// <summary>The contents of the buffer</summary>
    /// <remarks>
    ///   The buffer pointer is constant (since a buffer is allocated once and cannot be
    ///   resized or replaced), but the data is not.
    /// </remarks>
    private: std::uint8_t *const bytecode;
    /// <summary>The buffer's capacity in bytes</summary>
    private: const std::size_t length;
    /// <summary>Observers to changes happening to the buffer</summary>
    private: Helpers::ConcurrentObserverSet<Observer> observers;
    /// <summary>Constant buffers the user has currently selected</summary>
    private: std::unique_ptr<std::shared_ptr<GenericConstantBuffer>[]> constantBuffers;
    /// <summary>Textures the user has currently selected</summary>
    private: std::unique_ptr<std::shared_ptr<Texture>[]> textures;
    /// <summary>Metadata describing the shader</summary>
    private: std::unique_ptr<Introspection::ShaderMetadata> metadata;

  };

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

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

#endif // NUCLEX_GRAPHICS_RASTERIZATION_SHADER_H