#pragma once

#include "DX12Buffer.h"
#include "GraphicsApi.h"

//! DirectX 12 Types
#define DEFAULT_MAX_TRANSPARENT_HITS 5

struct ID3D12Debug;
struct ID3D12Device5;
struct ID3D12InfoQueue;
struct ID3D12CommandQueue;
struct IDXGISwapChain4;
struct ID3D12DescriptorHeap;
struct ID3D12Resource;
struct ID3D12CommandAllocator;
struct ID3D12Fence;
struct D3D12_VIEWPORT;
struct D3D12_VERTEX_BUFFER_VIEW;
struct D3D12_INDEX_BUFFER_VIEW;
struct ID3D12RootSignature;
struct ID3D12PipelineState;
struct ID3D12GraphicsCommandList4;
struct D3D12_RAYTRACING_INSTANCE_DESC;

namespace Framework
{
    class DX12Buffer;
    class DX12DirectCommandQueue;
    class DX12CopyCommandQueue;
    class DX12ComputeCommandQueue;
    class DX12PixelShader;
    class DX12VertexShader;
    class DX12VertexBuffer;
    class DX12IndexBuffer;
    class DX12BLASModel;
    class TextureList;
    class TextureModel;
    class DX12TLAS;
    class DX12Texture;
    class DX12Pipeline;
    class DX12GlobalDescriptorHeap;
    class DX12ShaderBindingTable;
    class Model3D;
    class DX12ShaderHitGroup;
    class DX12ShaderFunction;
    class Cam3D;
    class DX12BLAS;
    class DX12SamplerState;
    class World3D;

    struct RayGenerationSettings
    {
        int renderGui;
        int useRays;
        float minDistance;
        float maxDistance;
        Mat4<float> inverseView;
        Mat4<float> inverseProjection;
    };

    class DirectX12 : public GraphicsApi
    {
    private:
        ID3D12Debug* debug;
        ID3D12InfoQueue* infoQueue;
        IDXGISwapChain4* swapChain;
        ID3D12Resource* backBuffer[2];
        int backBufferIndex;
        int tearing;
        ID3D12RootSignature* signature;
        Mat4<float> matrixBuffer[MAX_KNOCHEN_ANZ];
        Mat4<float> viewAndProj[2];
        Vec3<float> kamPos;
        Texture* uiTexture;
        TextureList* texturRegister;
        DX12BLASModel** blasModels;
        DX12TLAS** worldTLAS;
        DX12ShaderBindingTable** worldShaderBindingTables;
        int lastTLASId;
        int lastModelId;
        DX12Texture* defaultRenderTarget;
        Cam3D* defaultKamera;
        int cameraCount;
        Critical cs;

    protected:
        DX12Buffer* rayGenSettingsBuffer;
        RayGenerationSettings settings;
        ID3D12Device5* device;
        DX12DirectCommandQueue* directCommandQueue;
        PFN_D3D12_SERIALIZE_ROOT_SIGNATURE pfnD3D12SerializeRootSignature;
        DX12Pipeline* pipeline;
        DX12GlobalDescriptorHeap* globalDescriptorHeap;
        DX12GlobalDescriptorHeap* textureDescriptorHeap;
        DX12GlobalDescriptorHeap* samplerDescriptorHeap;
        DX12ShaderHitGroup* defaultHitGroup;
        DX12ShaderFunction* defaultRayGenerationShaderFunction;
        DX12SamplerState* defaultSamplerState;
        int* sbtTextureIdBufferOffset;
        int* sbtIndexBufferOffset;
        int* sbtVertexDataBufferOffset;
        int* sbtPolygonSizeBufferOffset;

    public:
        DLLEXPORT DirectX12();
        DLLEXPORT ~DirectX12();

    protected:
        DLLEXPORT void updateBottomLevelAccelerationStructure();
        DLLEXPORT void renderKamera(
            Cam3D* zKamera, DX12Texture* zTarget, bool guiVisible);
        DLLEXPORT virtual void renderWorld(World3D* zWorld,
            DX12TLAS* zTLAS,
            DX12ShaderBindingTable* zSBT,
            int& objectIndex);
        DLLEXPORT virtual void initializePipeline();
        DLLEXPORT virtual void initializeGlobalDescriptorHeap();
        DLLEXPORT virtual void initializeTextureDescriptorHeap();
        DLLEXPORT virtual void initializeSamplerDescriptorHeap();
        DLLEXPORT virtual void fillShaderBindingTable(
            DX12ShaderBindingTable* zShaderBindingTable,
            Model3D* zModel,
            int objectIndex,
            const DX12BLAS* zBLAS,
            int& lastHitGroupIndex);
        DLLEXPORT virtual int fillGlobalShaderParams(
            Cam3D* zCam, DX12TLAS* zTLAS, int startIndex = 0);

    public:
        DLLEXPORT void initialize(NativeWindow* fenster,
            Vec2<int> backBufferSize,
            bool fullScreen) override;
        DLLEXPORT void beginFrame(
            bool fill2D, bool fill3D, int fillColor) override;
        DLLEXPORT void renderKamera(Cam3D* zKamera) override;
        DLLEXPORT virtual void renderKamera(
            Cam3D* zKamera, Texture* zTarget) override;
        //! TODO: DLLEXPORT void renderKamera( Cam3D* zKamera, Texture* zTarget
        //! ) override;
        DLLEXPORT void presentFrame() override;
        DLLEXPORT Texture* createOrGetTexture(
            const char* name, Image* b, TextureDirection dir) override;
        DLLEXPORT Image* zUIRenderImage() const override;
        DLLEXPORT virtual DXBuffer* createStructuredBuffer(int eSize) override;
        DLLEXPORT virtual Model3DData* createModel(const char* name);
        DLLEXPORT void setPipeline(DX12Pipeline* pipeline);
        DLLEXPORT static bool isAvailable();
        DLLEXPORT bool renderGuiBefore3D() const override;
    };
} // namespace Framework