MortonKeyEventProxy.h

#pragma once

#include "ICallback.h"
#include "IMortonKeyBasedEventProvider.h"

#include <array>
#include <memory>

namespace Eegeo
{
    namespace Helpers
    {
        template <typename TEvent, int MortonKeyDepth>
        class MortonKeyEventProxy : public ICallback1<const Streaming::MortonKey>, public IMortonKeyBasedEventProvider<TEvent>
        {
        public:
            using EventType = TEvent;
            static constexpr int Depth = MortonKeyDepth;

            virtual TEvent& GetEventForMortonKey(Streaming::MortonKey mortonKey) override
            {
                return m_quadTree[mortonKey];
            }

            virtual void operator()(const Streaming::MortonKey& mortonKey) const override
            {
                m_quadTree(mortonKey);
            }

            virtual int GetPreferredDepth() const override
            {
                return MortonKeyDepth;
            }

        private:
            // For now, there's no TEvent2, so we don't need to deal with picking the right class.
            // Really, events should be variadic templates with perfect forwarding.
            struct QuadTreeNode : public TEvent1<TEvent>
            {
                QuadTreeNode(QuadTreeNode* parent)
                    : TEvent1<TEvent>()
                    , parent(parent)
                {}
                QuadTreeNode() = delete;

                virtual void RemoveChild(int quadrant) = 0;

                QuadTreeNode* parent;
            };

            struct QuadTreeRegularNode : public QuadTreeNode
            {
                QuadTreeRegularNode(Streaming::MortonKey nodeKey, QuadTreeNode* parent)
                    : QuadTreeNode(parent)
                    , nodeKey(nodeKey)
                    , children({nullptr, nullptr, nullptr, nullptr})
                {}
                QuadTreeRegularNode() = delete;

                Streaming::MortonKey nodeKey;
                std::array<std::unique_ptr<QuadTreeRegularNode>, 4> children;

                void Cleanup()
                {
                    if (this->m_callbacks.empty())
                    {
                        for (const auto& child : children)
                        {
                            if (child)
                            {
                                return;
                            }
                        }
                        this->parent->RemoveChild(nodeKey.Element(nodeKey.Depth() - 1));
                    }
                }

                void Unregister(typename TEvent1<TEvent>::CallbackType& callback) override
                {
                    TEvent1<TEvent>::Unregister(callback);
                    Cleanup();
                }

                void RemoveChild(int quadrant) override
                {
                    children[quadrant] = nullptr;
                    Cleanup();
                }

                TEvent& operator[] (const Streaming::MortonKey& mortonKey)
                {
                    if (nodeKey == mortonKey || nodeKey.Depth() == Depth)
                    {
                        return *this;
                    }
                    else
                    {
                        int childIndex = mortonKey.Element(nodeKey.Depth());
                        auto& child = children[childIndex];
                        if (!child)
                        {
                            // eww, no std::make_unique
                            child.reset(Eegeo_NEW(QuadTreeRegularNode)(nodeKey.Push(childIndex), this));
                        }
                        return (*child)[mortonKey];
                    }
                }

                void operator()(const Streaming::MortonKey& mortonKey) const
                {
                    this->Raise(mortonKey);
                    if (mortonKey.Depth() > nodeKey.Depth())
                    {
                        const auto& child = children[mortonKey.Element(nodeKey.Depth())];
                        if (child)
                        {
                            (*child)(mortonKey);
                        }
                    }
                    else
                    {
                        for (const auto& child : children)
                        {
                            if (child)
                            {
                                (*child)(mortonKey);
                            }
                        }
                    }
                }
            };

            struct QuadTreeRootNode : public QuadTreeNode
            {
                QuadTreeRootNode()
                    : QuadTreeNode(nullptr)
                    , children({nullptr, nullptr, nullptr, nullptr, nullptr, nullptr})
                {}
                std::array<std::unique_ptr<QuadTreeRegularNode>, 6> children;

                void RemoveChild(int face) override
                {
                    children[face] = nullptr;
                }

                TEvent& operator[] (const Streaming::MortonKey& mortonKey)
                {
                    if (Depth == 0)
                    {
                        return *this;
                    }
                    else
                    {
                        auto& child = children[mortonKey.Face()];
                        if (!child)
                        {
                            // eww, no std::make_unique
                            child.reset(Eegeo_NEW(QuadTreeRegularNode)(Streaming::MortonKey(mortonKey.Face()), this));
                        }
                        return (*child)[mortonKey];
                    }
                }

                void operator()(const Streaming::MortonKey& mortonKey) const
                {
                    this->Raise(mortonKey);
                    auto& child = children[mortonKey.Face()];
                    if (child)
                    {
                        (*child)(mortonKey);
                    }
                }
            };

            QuadTreeRootNode m_quadTree;
        };
    }
}