#pragma once

#include <vector>
#include <mutex>
#include "IDrawable.h"

#include <DirectXMath.h>

namespace eg3d {

    template<typename vertex_t>
    class Geometry : public IDrawable {
    private:
        ComPtr<ID3D12Device> mDevice; // device

        std::vector<vertex_t> mVertices; // vertexek
        std::vector<uint32_t> mIndices; // indexek

        std::mutex mModifMtx; // ...

        // topológia
        D3D_PRIMITIVE_TOPOLOGY mTopology;

        // bufferek
        ComPtr<ID3D12Resource> mVertexBuffer;
        ComPtr<ID3D12Resource> mIndexBuffer;

        // leírók
        D3D12_VERTEX_BUFFER_VIEW mVertexBufferView;
        D3D12_INDEX_BUFFER_VIEW mIndexBufferView;
    public:
        explicit Geometry(ComPtr<ID3D12Device> device) : mDevice(device) {
            // topológia beállítása
            setTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
        }

        // másolókonstruktor
        Geometry(const Geometry& other) : mDevice(other.mDevice) {
            setTopology(other.getTopology());
            setVertices(other.getVertices());
            setIndices(other.getIndices());
        }

        // vertexek beállítása
        void setVertices(const std::vector<vertex_t> &vertices) {
            mVertices = vertices;

            size_t bufferSize = mVertices.size() * sizeof(vertex_t); // buffer mérete

            mVertexBuffer.Reset(); // buffer törlése
            mVertexBuffer = createBuffer_UH(mDevice, bufferSize); // buffer létrehozása
            bufferMapCopy(mVertexBuffer, (void *) mVertices.data(), bufferSize); // buffer feltöltése

            // vertex buffer view beállítása
            mVertexBufferView.BufferLocation = mVertexBuffer->GetGPUVirtualAddress();
            mVertexBufferView.StrideInBytes = sizeof(vertex_t);
            mVertexBufferView.SizeInBytes = bufferSize;
        }

        // vertexek lekérése
        std::vector<vertex_t> getVertices() const {
            return mVertices;
        }

        // indexek beállítása
        void setIndices(const std::vector<uint32_t> &indices) {
            mIndices = indices;

            size_t bufferSize = mIndices.size() * sizeof(uint32_t); // buffer mérete

            mIndexBuffer.Reset(); // buffer törlése
            mIndexBuffer = createBuffer_UH(mDevice, bufferSize); // buffer létrehozása
            bufferMapCopy(mIndexBuffer, (void *) mIndices.data(), bufferSize); // buffer feltöltése

            // index buffer view beállítása
            mIndexBufferView.Format = /*(sizeof(IT) == 2) ? DXGI_FORMAT_R16_UINT :*/ DXGI_FORMAT_R32_UINT;
            mIndexBufferView.BufferLocation = mIndexBuffer->GetGPUVirtualAddress();
            mIndexBufferView.SizeInBytes = bufferSize;
        }

        // indexek lekérése
        std::vector<uint32_t> getIndices() const {
            return mIndices;
        }

        // topológia beállítása
        void setTopology(D3D_PRIMITIVE_TOPOLOGY topology) {
            mTopology = topology;
        }

        // topológia beállítása
        D3D_PRIMITIVE_TOPOLOGY getTopology() const {
            return mTopology;
        }

        // input assembler beállítása
        void setupInputAssembler(ComPtr<ID3D12GraphicsCommandList> commandList) const {
            commandList->IASetVertexBuffers(0, 1, &mVertexBufferView);
            commandList->IASetIndexBuffer(&mIndexBufferView);
            commandList->IASetPrimitiveTopology(mTopology);
        }

        // kirajzolás
        void draw(ComPtr<ID3D12GraphicsCommandList> commandList) const override {
            setupInputAssembler(commandList); // input assembler beállítása
            commandList->DrawIndexedInstanced(mIndices.size(), 1, 0, 0, 0); // rajzolás
        }
    };

    // geometriatároló típusa
    template <typename vertex_t>
    using GeometryPool = std::vector<std::shared_ptr<Geometry<vertex_t>>>;
}