#ifndef _DNACOMMON_VISIBUILDER_HPP_
#define _DNACOMMON_VISIBUILDER_HPP_

#include "VISIRenderer.hpp"
#include "zeus/CAABox.hpp"
#include "hecl/extern/xxhash/xxhash.h"
#include "athena/MemoryWriter.hpp"
#include "hecl/hecl.hpp"
#include <unordered_map>

namespace std
{
template <> struct hash<zeus::CVector3f>
{
    size_t operator()(const zeus::CVector3f& val) const noexcept
    {
        return XXH64(val.v, 12, 0);
    }
};
}

struct VISIBuilder
{
    struct Leaf
    {
        std::vector<uint8_t> bits;
        void setBit(size_t bit)
        {
            size_t byte = bit / 8;
            if (byte >= bits.size())
                bits.resize(byte + 1);
            bits[byte] |= 1 << (bit & 0x7);
        }
        void setLightEnum(size_t bit, EPVSVisSetState state)
        {
            size_t byte0 = bit / 8;
            size_t byte1 = (bit + 1) / 8;
            if (byte1 >= bits.size())
                bits.resize(byte1 + 1);

            if (byte0 == byte1)
            {
                bits[byte0] |= int(state) << (bit & 0x7);
            }
            else
            {
                bits[byte0] |= (int(state) << 7) & 0x1;
                bits[byte1] |= (int(state) >> 1) & 0x1;
            }
        }
        bool operator==(const Leaf& other) const
        {
            if (bits.size() != other.bits.size())
                return false;
            if (memcmp(bits.data(), other.bits.data(), bits.size()))
                return false;
            return true;
        }
        Leaf& operator|=(const Leaf& other)
        {
            if (bits.size() < other.bits.size())
                bits.resize(other.bits.size());
            for (int i=0 ; i<other.bits.size() ; ++i)
                bits[i] |= other.bits[i];
            return *this;
        }
        operator bool() const { return bits.size() != 0; }

        void write(athena::io::MemoryWriter& w, size_t leafBytes) const
        {
            for (size_t i=0 ; i<leafBytes ; ++i)
            {
                if (i < bits.size())
                    w.writeUByte(bits[i]);
                else
                    w.writeUByte(0);
            }
        }
    };

    class PVSRenderCache
    {
        friend struct VISIBuilder;
        VISIRenderer& m_renderer;
        std::unordered_map<zeus::CVector3f, std::unique_ptr<Leaf>> m_cache;
        size_t m_lightMetaBit;
    public:
        PVSRenderCache(VISIRenderer& renderer);
        const Leaf& GetLeaf(const zeus::CVector3f& vec);
    } renderCache;

    class Progress
    {
        float m_prog = 0.f;
        FPercent m_updatePercent;
    public:
        void report(int divisions);
        Progress(FPercent updatePercent) : m_updatePercent(updatePercent) {}
    };

    struct Node
    {
        std::vector<Node> childNodes;
        size_t childRelOffs[8] = {};
        Leaf leaf;
        uint8_t flags = 0;

        void buildChildren(int level, int divisions, const zeus::CAABox& curAabb,
                           PVSRenderCache& rc, Progress& prog, const bool& terminate);
        void calculateSizesAndOffs(size_t& cur, size_t leafSz);
        void writeNodes(athena::io::MemoryWriter& w, size_t leafBytes) const;

        bool operator==(const Node& other) const
        {
            if ((flags & 0x7) || (other.flags & 0x7))
                return false;
            return leaf == other.leaf;
        }
    } rootNode;

    std::vector<uint8_t> build(const zeus::CAABox& fullAabb,
                               size_t modelCount,
                               const std::vector<VISIRenderer::Entity>& entities,
                               const std::vector<VISIRenderer::Light>& lights,
                               FPercent updatePercent);

    VISIBuilder(VISIRenderer& renderer) : renderCache(renderer) {}
};

#endif // _DNACOMMON_VISIBUILDER_HPP_