TiledGraphCell.h

#pragma once

#include "Graphs.h"
#include "Types.h"
#include "MortonKey.h"
#include "VectorMath.h"
#include "TiledGraphNode.h"
#include "TiledGraphEdge.h"

#include <vector>


#define EEGEO_GRAPHS_TILED_GRAPH_VALIDATION 0

namespace Eegeo
{
    namespace Graphs
    {
        class TiledGraphCell : private Eegeo::NonCopyable
        {
        public:
            static TiledGraphCell* CreateEmpty(
                const Eegeo::Streaming::MortonKey& key,
                const dv3& originEcef
            );

            static TiledGraphCell* Create(
                const Eegeo::Streaming::MortonKey& key,
                const dv3& originEcef,
                const std::vector<TiledGraphNode>& nodes,
                const std::vector<TiledGraphEdge>& edges,
                const std::vector<int>& incidentEdges,
                const std::vector<int>& edgesWithExternalNodesForward,
                const std::vector<int>& edgesWithExternalNodesReversed
            );

            const Eegeo::Streaming::MortonKey& GetKey() const { return m_key; }
            const dv3& GetOriginEcef() const { return m_originEcef; }

            bool ContainsNode(const TiledGraphNodeId& nodeId) const;
            bool ContainsEdge(const TiledGraphEdgeId& edgeId) const;

            const TiledGraphNode& GetNode(const TiledGraphNodeId& nodeId) const;
            const TiledGraphEdge& GetEdge(const TiledGraphEdgeId& edgeId) const;
            const std::vector<int>& GetIncidentEdges() const;

            TiledGraphNodeId BuildNodeId(int localIndex) const;
            TiledGraphEdgeId BuildEdgeId(int localIndex) const;

            dv3 GetNodePoint(const TiledGraphNodeId& nodeId) const;

            void GetIncidentEdgeIds(const TiledGraphNodeId& nodeId, std::vector<TiledGraphEdgeId>& out_incidentEdgeIds) const;

            bool FindEdgeId(const TiledGraphNodeId& nodeIdA, const TiledGraphNodeId& nodeIdB, TiledGraphEdgeId& out_edgeId) const;

            bool FindEdgeWithAttributes(const int attributesId, const bool attributesDirectionReversed, TiledGraphEdgeId& out_edgeId) const;

            bool FindExternalEdgeWithAttributes(const int attributesId, const bool attributesDirectionReversed, TiledGraphEdgeId& out_edgeId) const;

            void GetEdgeIdsToLink(std::vector<TiledGraphEdgeId>& out_edgeIds) const;

            void GetCellKeysToUnlink(std::vector<Streaming::MortonKey>& out_keys) const;

            bool ValidateAllUnlinked(const Streaming::MortonKey& cellKey) const;

            bool ValidateExternalNodesExist() const;

            bool ValidateAllExternalNodesUnlinked() const;

            const std::vector<TiledGraphNode>& GetNodes() const { return m_nodes; }

            const std::vector<TiledGraphEdge>& GetEdges() const { return m_edges; }

            const TiledGraph* GetGraphOrNull() const { return m_pTiledGraph; }


            // mutable
            void Link(const TiledGraph& tiledGraph);

            void Unlink(const TiledGraph& tiledGraph);

            void LinkEdge(const TiledGraphEdgeId& edgeId, const TiledGraphNodeId& externalNodeId);

            void UnlinkFromCellWithKey(const Streaming::MortonKey& key);

        private:
            TiledGraphCell(
                const Eegeo::Streaming::MortonKey& key,
                const dv3& originEcef);

            TiledGraphCell(
                const Eegeo::Streaming::MortonKey& key,
                const dv3& originEcef,
                const std::vector<TiledGraphNode>& nodes,
                const std::vector<TiledGraphEdge>& edges,
                const std::vector<int>& incidentEdges,
                const std::vector<int>& edgesWithExternalNodesForward,
                const std::vector<int>& edgesWithExternalNodesReversed
            );

            void AppendEdgeIdsToLink(const std::vector<int>& edgesWithExternalNodes, std::vector<TiledGraphEdgeId>& out_edgeIds) const;

            void AppendKeysToUnlink(const std::vector<int>& edgesWithExternalNodes, std::vector<Streaming::MortonKey>& out_keys) const;

            void UnlinkEdgeNodesWithKey(TiledGraphEdge& edge, const Streaming::MortonKey& key);

            void UnlinkExternalEdgeNode(TiledGraphEdge& edge);

            void UnlinkExternalEdgeNodes();

            bool ValidateNodeIsInternalOrUnlinked(const TiledGraphNodeId& nodeId) const;

            const TiledGraph* m_pTiledGraph;
            Eegeo::Streaming::MortonKey m_key;
            dv3 m_originEcef;
            std::vector<TiledGraphNode> m_nodes;
            std::vector<TiledGraphEdge> m_edges;
            std::vector<int> m_incidentEdges;
            std::vector<int> m_edgesWithExternalNodesForward;
            std::vector<int> m_edgesWithExternalNodesReversed;
        };

        struct TiledGraphCellEdgeOrderByAttributesId
        {
            TiledGraphCellEdgeOrderByAttributesId(
                const std::vector<TiledGraphEdge>& edges
            )
                : m_edges(edges)
            {}

            bool operator() (const int edgeIndexA, const int edgeIndexB) const
            {
                const auto& edgeA = m_edges.at(edgeIndexA);
                const auto& edgeB = m_edges.at(edgeIndexB);
                return edgeA.AttributesId < edgeB.AttributesId;
            }

        private:
            const std::vector<TiledGraphEdge>& m_edges;
        };

        struct TiledGraphCellEdgeCompareByAttributesId
        {
            TiledGraphCellEdgeCompareByAttributesId(
                const std::vector<TiledGraphEdge>& edges
            )
                : m_edges(edges)
            {}

            bool operator() (const int edgeIndexA, const int edgeIndexB) const
            {
                const auto& edgeA = m_edges.at(edgeIndexA);
                const auto& edgeB = m_edges.at(edgeIndexB);
                return edgeA.AttributesId == edgeB.AttributesId;
            }

        private:
            const std::vector<TiledGraphEdge>& m_edges;
        };
    }
}