#pragma once

#include <XCEngine/Core/Types.h>

#include <cstddef>
#include <limits>
#include <vector>

namespace XCEngine {
namespace Rendering {

enum class RendererListType : Core::uint32 {
    AllVisible = 0,
    Opaque = 1,
    Transparent = 2,
    ShadowCaster = 3,
    ObjectId = 4
};

enum class RendererSortMode : Core::uint32 {
    None = 0,
    FrontToBack = 1,
    BackToFront = 2
};

struct FilteringSettings {
    Core::int32 renderQueueMin = std::numeric_limits<Core::int32>::lowest();
    Core::int32 renderQueueMax = std::numeric_limits<Core::int32>::max();
    Core::uint32 renderLayerMask = std::numeric_limits<Core::uint32>::max();
    bool requireShadowCasting = false;
    bool requireRenderObjectId = false;

    bool operator==(const FilteringSettings& other) const {
        return renderQueueMin == other.renderQueueMin &&
               renderQueueMax == other.renderQueueMax &&
               renderLayerMask == other.renderLayerMask &&
               requireShadowCasting == other.requireShadowCasting &&
               requireRenderObjectId == other.requireRenderObjectId;
    }
};

struct SortingSettings {
    RendererSortMode sortMode = RendererSortMode::None;

    bool operator==(const SortingSettings& other) const {
        return sortMode == other.sortMode;
    }
};

struct RendererListDesc {
    RendererListType type = RendererListType::AllVisible;
    FilteringSettings filtering = {};
    SortingSettings sorting = {};

    bool operator==(const RendererListDesc& other) const {
        return type == other.type &&
               filtering == other.filtering &&
               sorting == other.sorting;
    }
};

struct RendererList {
    RendererListDesc desc = {};
    std::vector<Core::uint32> visibleRenderItemIndices;

    bool Empty() const {
        return visibleRenderItemIndices.empty();
    }

    size_t Size() const {
        return visibleRenderItemIndices.size();
    }
};

struct CullingResults {
    std::vector<RendererList> rendererLists;

    void Clear() {
        rendererLists.clear();
    }

    RendererList* FindRendererList(RendererListType type) {
        for (RendererList& rendererList : rendererLists) {
            if (rendererList.desc.type == type) {
                return &rendererList;
            }
        }

        return nullptr;
    }

    const RendererList* FindRendererList(RendererListType type) const {
        for (const RendererList& rendererList : rendererLists) {
            if (rendererList.desc.type == type) {
                return &rendererList;
            }
        }

        return nullptr;
    }
};

} // namespace Rendering
} // namespace XCEngine