#pragma once
// The adapter's engine: what the client draws with. Everything goes to the client's own Direct3D renderer, which
// still draws the whole 3D view, and is recorded for the renderer process, which draws its part on top (the right
// half for now, to compare). If the renderer process fails, the client's renderer carries on alone.

#include <cstdint>
#include <memory>

#include "recorder.hpp"
#include "t5de/imvu/render_engine.hpp"

namespace t5de {

class Engine final : public imvu::PiRenderEngine {
public:
    // recorder may be inactive (no renderer process).
    Engine(imvu::SharedPtr<imvu::PiRenderEngine> inner, std::shared_ptr<Recorder> recorder);
    ~Engine() override;

    void resizeFrameBuffer(imvu::Vec2i size) override;
    void enable2dFrameBuffer() override;
    void clear(std::uint32_t flags, imvu::Color color) override;
    void setProjection(imvu::Vec2i viewport, const imvu::Mat4f& projection) override;
    void setModelSpace(const imvu::Transform& model) override;
    void setViewSpace(const imvu::Transform& view) override;
    void setTextures(imvu::PiRenderTexture* texture0, imvu::PiRenderTexture* texture1) override;
    void setDepthTestingOn(bool on) override;
    void setDepthWritingOn(bool on) override;
    void setBlendMode(imvu::RenderBlendMode mode) override;
    void setAlphaTestingOn(bool on) override;
    void setAlphaTestValue(float value) override;
    void setBlendingOn(bool on) override;
    void setBackFaceCullingOn(bool on) override;
    void setNormalInvertingOn(bool on) override;
    void setLightingOn(bool on) override;
    void setLightProperties(std::uint32_t index, const imvu::LightProperties& light) override;
    void setFogOn(bool on) override;
    void setFogAttributes(float start, float end, imvu::Color color) override;
    void setTextureTransformMatrixIdentity(std::uint32_t stage) override;
    void setTextureTransformMatrix(std::uint32_t stage, const imvu::TextureTransform& transform) override;
    void setEnvironmentAmbient(imvu::Color color) override;
    imvu::PiRenderTexture* newRenderTexture(const imvu::Pixmap& pixmap, std::uint32_t flags) override;
    imvu::PiInternalIndexBuffer* newIndexBuffer(std::uint32_t count, const std::uint16_t* indices) override;
    imvu::PiInternalVertexBuffer* newStaticVertexBuffer(const void* data, std::uint32_t stride,
                                                        std::uint32_t elementSize,
                                                        std::uint32_t elementCount) override;
    imvu::PiInternalVertexBuffer* newDynamicVertexBuffer(std::uint32_t elementSize,
                                                         std::uint32_t elementCount) override;
    imvu::SharedPtr<imvu::PiPixmapRenderTarget> newPixmapRenderTarget(imvu::Vec2i size) override;
    imvu::SharedPtr<imvu::PiTextureRenderTarget> newTextureRenderTarget(imvu::Vec2i size) override;
    void beginRendering(imvu::PiRenderTarget* target) override;
    void endRendering() override;
    void drawTriangles(imvu::PiInternalIndexBuffer* indices, imvu::PiInternalVertexBuffer* positions,
                       imvu::PiInternalVertexBuffer* normals, imvu::PiInternalVertexBuffer* texCoords,
                       imvu::PiInternalVertexBuffer* colors) override;
    void drawLine(imvu::Vec3f from, imvu::Vec3f to, imvu::Color color) override;
    void drawPointSprites(const imvu::PointSpriteVector& sprites) override;
    void drawTrianglesFromMemory(std::uint32_t vertexCount, std::uint32_t indexCount, const std::uint16_t* indices,
                                 const imvu::VertexAttributeArray<imvu::Vec3f>& positions,
                                 const imvu::VertexAttributeArray<imvu::Vec3f>& normals,
                                 const imvu::VertexAttributeArray<imvu::Vec2f>& texCoords,
                                 const imvu::VertexAttributeArray<imvu::Color>& colors) override;

private:
    void setState(protocol::State state, std::uint32_t value);

    imvu::SharedPtr<imvu::PiRenderEngine> inner_;
    std::shared_ptr<Recorder> recorder_;
    std::uint64_t frames_ = 0;
    int foreignLogged_ = 0; // diagnostics: textures the client renderer made, render targets

};

} // namespace t5de