#pragma once

#include "Array.h"
#include "DX12Buffer.h"

struct ID3D12Device5;
struct ID3D12GraphicsCommandList;
struct D3D12_INPUT_ELEMENT_DESC;
struct D3D12_ROOT_PARAMETER1;
struct D3D12_CONSTANT_BUFFER_VIEW_DESC;

namespace Framework
{
    enum DX12ShaderRegister
    {
        DX12_SHADER_REGISTER_B_CONST_BUFFER = 0,
        DX12_SHADER_REGISTER_T_SHADER_RESOURCE = 1,
        DX12_SHADER_REGISTER_U_UNORDERED_ACCESS = 2,
        // TODO: Do we need Sampler?
    };

    struct DX12ShaderRegisterUsage
    {
        DX12ShaderRegister registerType;
        int registerIndex;
        int spaceIndex;
    };

    class DX12ShaderSignature : public ReferenceCounter
    {
    private:
        ID3D12RootSignature* signature;
        ID3D12Device5* zDevice;
        Array<DX12ShaderRegisterUsage> registerUsages;
        PFN_D3D12_SERIALIZE_ROOT_SIGNATURE pfnD3D12SerializeRootSignature;

    public:
        DX12ShaderSignature(ID3D12Device5* zDevice,
            PFN_D3D12_SERIALIZE_ROOT_SIGNATURE pfnD3D12SerializeRootSignature);
        ~DX12ShaderSignature();
        /**
         * needs to be called for each datastructure with : register(...)
         *
         * \param registerType the register type e.g.
         * DX12_SHADER_REGISTER_B_CONST_BUFFER for : register(b0)
         * \param registerIndex the register index e.g. 1 for : register(b1)
         */
        void addRegisterUsage(
            DX12ShaderRegister registerType, int registerIndex);
        /**
         * needs to be called for each datastructure with : register(...)
         *
         * \param registerType the register type e.g.
         * DX12_SHADER_REGISTER_B_CONST_BUFFER for : register(b0, space1)
         * \param registerIndex the register index e.g. 1 for : register(b1,
         * space2)
         * \param spaceIndex the space index e.g. 3 for : register(b1, space3)
         */
        void addRegisterUsage(
            DX12ShaderRegister registerType, int registerIndex, int spaceIndex);
        /**
         * Creates the root signature.
         */
        void createSignature();
        ID3D12RootSignature* zSignature() const;
    };

    class DX12ShaderFunction : public ReferenceCounter
    {
    private:
        Text functionName;
        DX12ShaderSignature* signature;
    };

    class DX12Shader : public ReferenceCounter
    {
    private:
        RCArray<DX12ShaderFunction> functions;
        const char* shaderBytes;
        int shaderBytesSize;
    };

    class ShaderHitGroup : public ReferenceCounter
    {
    private:
        Text name;
        DX12ShaderFunction* closestHitShaderFunctionName;
        DX12ShaderFunction* anyHitShaderFunctionName;
        DX12ShaderFunction* intersectionShaderFunctionName;
        int payloadSize;
        int attributeSize;
    };

    class DX12Pipeline : public ReferenceCounter
    {
    private:
        RCArray<DX12Shader> shaders;
        RCArray<ShaderHitGroup> hitGroups;
        int maxRecursionDepth;
    }; // namespace Framework
} // namespace Framework