/*
 * Copyright 2022 Rive
 */

#pragma once

#include "rive/renderer/render_context_helper_impl.hpp"
#include "rive/gpu_texture_format.hpp"

#ifdef RIVE_CANVAS
#include "rive/renderer/ore/ore_context.hpp"
#endif

class RenderContextNULL : public rive::gpu::RenderContextHelperImpl
{
public:
    static std::unique_ptr<rive::gpu::RenderContext> MakeContext();

    RenderContextNULL();

#ifdef RIVE_CANVAS
    std::unique_ptr<rive::ore::Context> makeOreContext() override
    {
        return nullptr;
    }

    // Backs an offscreen canvas with null-device pixels so replay actually
    // opens its frame instead of dropping the content. Without this a canvas
    // recorded against this context stays unbacked and its draws are
    // discarded, which would make an offscreen render look free.
    void ensureCanvasBacking(rive::gpu::RenderCanvas*) override;
#endif

    rive::rcp<rive::gpu::RenderTarget> makeRenderTarget(uint32_t width,
                                                        uint32_t height);

private:
    rive::rcp<rive::RenderBuffer> makeRenderBuffer(rive::RenderBufferType,
                                                   rive::RenderBufferFlags,
                                                   size_t) override;

    rive::rcp<rive::gpu::Texture> makeImageTexture(
        uint32_t width,
        uint32_t height,
        uint32_t mipLevelCount,
        rive::GPUTextureFormat format,
        const uint8_t imageData[],
        uint8_t blockWidth = 1,
        uint8_t blockHeight = 1,
        bool srgb = false,
        bool generateRemainingMips = false) override;

    std::unique_ptr<rive::gpu::BufferRing> makeUniformBufferRing(
        size_t capacityInBytes) override;
    std::unique_ptr<rive::gpu::BufferRing> makeStorageBufferRing(
        size_t capacityInBytes,
        rive::gpu::StorageBufferStructure) override;
    std::unique_ptr<rive::gpu::BufferRing> makeVertexBufferRing(
        size_t capacityInBytes) override;

    void resizeGradientTexture(uint32_t width, uint32_t height) override {}
    void resizeTessellationTexture(uint32_t width, uint32_t height) override {}
    void resizeFeatherAtlasTexture(uint32_t width, uint32_t height) override {}
    void resizeCoverageBuffer(size_t) override {}

    void flush(const rive::gpu::FlushDescriptor&) override {}
};