MeshNetwork.mpp

export module CppUtils.Container.MeshNetwork;

import std;
import CppUtils.Container.NetworkPtr;
import CppUtils.Container.SafeShared;
import CppUtils.Thread.UniqueLocker;
import CppUtils.Thread.SharedLocker;
import CppUtils.Thread.SharedPtr;

export namespace CppUtils::Container
{
	template<class Key, class Value>
	class MeshNodePtr final
	{
	private:
		struct MeshNode final
		{
			using WeakPtr = SafeWeak<NetworkPtr<MeshNode>>;
			using VectorLocker = Thread::SharedLocker<std::vector<WeakPtr>>;
			using Branches = std::unordered_map<Key, SafeShared<std::vector<WeakPtr>>>;

			Thread::SharedLocker<Value> value;
			Thread::SharedLocker<Branches> branches;

			explicit inline MeshNode(auto&&... args):
				value{std::forward<decltype(args)>(args)...}
			{}
		};

		using SharedPtr = SafeShared<NetworkPtr<MeshNode>>;
		using WeakPtr = MeshNode::WeakPtr;
		using VectorLocker = MeshNode::VectorLocker;
		using Branches = MeshNode::Branches;

	private:
		static auto attach(
			const MeshNodePtr& parent,
			const Key& key,
			const MeshNodePtr& child,
			SafeShared<std::vector<WeakPtr>> existingPersistenceGuard = nullptr) -> void
		{
			auto accessor = Thread::MultipleAccessor{*parent.m_node, *child.m_node};
			auto& parentNetworkPtr = std::get<0>(accessor.values);
			auto& childNetworkPtr = std::get<1>(accessor.values);

			auto persistenceGuard = SafeShared<std::vector<WeakPtr>>{};
			{
				auto branchesAccessor = parentNetworkPtr.value.branches.uniqueAccess();
				auto& entry = branchesAccessor.value()[key];
				if (not entry)
					entry = existingPersistenceGuard ? existingPersistenceGuard : makeSafeShared<std::vector<WeakPtr>>();
				persistenceGuard = entry;
			}

			{
				auto vectorAccessor = persistenceGuard->uniqueAccess();
				if (std::ranges::none_of(vectorAccessor.value(), [&](const auto& weak) {
					return Thread::SharedPtr::ownerEqual(weak, child.m_node);
				}))
					vectorAccessor->push_back(child.m_node);
			}
			parentNetworkPtr.attachChild(childNetworkPtr);
		}

		static auto detach(const MeshNodePtr& parent, const Key& key, const MeshNodePtr& child) -> void
		{
			auto accessor = Thread::MultipleAccessor{*parent.m_node, *child.m_node};
			auto& parentNetworkPtr = std::get<0>(accessor.values);
			auto& childNetworkPtr = std::get<1>(accessor.values);

			auto branchesAccessor = parentNetworkPtr.value.branches.uniqueAccess();
			if (auto branchIterator = branchesAccessor->find(key); branchIterator != std::cend(branchesAccessor.value()))
			{
				auto persistenceGuard = branchIterator->second;
				auto vectorAccessor = persistenceGuard->uniqueAccess();
				auto& vector = vectorAccessor.value();
				if (auto it = std::ranges::find_if(vector, [&](auto& weak) { return Thread::SharedPtr::ownerEqual(weak, child.m_node); }); it != std::cend(vector))
				{
					vector.erase(it);
					parentNetworkPtr.detachChild(childNetworkPtr);
				}

				if (std::empty(vector))
					branchesAccessor->erase(branchIterator);
			}
		}

		static auto detach(const MeshNodePtr& parent, const Key& key) -> void
		{
			auto children = std::vector<MeshNodePtr>{};
			{
				auto nodeAccessor = parent.m_node->sharedAccess();
				auto branchesAccessor = nodeAccessor->value.branches.sharedAccess();
				if (auto branchIterator = branchesAccessor->find(key); branchIterator != std::cend(branchesAccessor.value()))
					for (auto vectorAccessor = branchIterator->second->sharedAccess(); auto& weak : vectorAccessor.value())
						if (auto shared = weak.lock())
							children.push_back(MeshNodePtr{shared});
			}
			for (auto& child : children)
				detach(parent, key, child);
		}

		static auto attach(
			const Key& firstKey,
			const MeshNodePtr& firstNode,
			const Key& secondKey,
			const MeshNodePtr& secondNode,
			SafeShared<std::vector<WeakPtr>> firstNodePersistenceGuard = nullptr,
			SafeShared<std::vector<WeakPtr>> secondNodePersistenceGuard = nullptr) -> void
		{
			if (firstNode.m_node->sharedAccess()->getDistanceFromRoot() == std::numeric_limits<std::size_t>::max())
			{
				attach(secondNode, firstKey, firstNode, secondNodePersistenceGuard);
				attach(firstNode, secondKey, secondNode, firstNodePersistenceGuard);
			}
			else
			{
				attach(firstNode, secondKey, secondNode, firstNodePersistenceGuard);
				attach(secondNode, firstKey, firstNode, secondNodePersistenceGuard);
			}
		}

		static auto detach(const Key& firstKey, const MeshNodePtr& firstNode, const Key& secondKey, const MeshNodePtr& secondNode) -> void
		{
			detach(firstNode, secondKey, secondNode);
			detach(secondNode, firstKey, firstNode);
		}

	public:
		template<bool IsConst>
		class Branch final
		{
		public:
			using VectorAccessor = std::conditional_t<IsConst,
				Thread::ReadOnlyAccessor<std::vector<WeakPtr>>,
				Thread::Accessor<std::vector<WeakPtr>, std::shared_mutex>>;

			Branch() = default;
			Branch(MeshNodePtr parent, Key key, SafeShared<std::vector<WeakPtr>> persistenceGuard, VectorAccessor vectorAccessor):
				m_parent{std::move(parent)}, m_key{std::move(key)},
				m_persistenceGuard{std::move(persistenceGuard)},
				m_vectorAccessor{std::move(vectorAccessor)}
			{}

		private:
			[[nodiscard]] auto getVectorAccessor(this auto&& self) -> auto&
			{
				if (not self.m_vectorAccessor) [[unlikely]]
				{
					if constexpr (IsConst)
						self.m_vectorAccessor = self.m_persistenceGuard->sharedAccess();
					else
						self.m_vectorAccessor = self.m_persistenceGuard->uniqueAccess();
				}
				return self.m_vectorAccessor.value();
			}

		public:
			[[nodiscard]] auto size() const noexcept -> std::size_t
			{
				if (not m_persistenceGuard) [[unlikely]]
					return 0uz;
				return std::size(getVectorAccessor().value());
			}

			[[nodiscard]] auto empty() const noexcept -> bool { return size() == 0uz; }

			[[nodiscard]] auto contains(const MeshNodePtr& node) const -> bool
			{
				if (not m_persistenceGuard) [[unlikely]]
					return false;
				return std::ranges::any_of(getVectorAccessor().value(), [&](const auto& weak) {
					return Thread::SharedPtr::ownerEqual(weak, node.m_node);
				});
			}

			auto clear() -> void
			requires (not IsConst)
			{
				m_vectorAccessor.reset();
				MeshNodePtr::detach(m_parent, m_key);
			}

			[[nodiscard]] auto operator[](std::size_t index) const -> std::expected<MeshNodePtr, std::string_view>
			{
				using namespace std::literals;
				if (not m_persistenceGuard) [[unlikely]]
					return std::unexpected{"Branch is no longer valid"sv};
				auto& vectorAccessor = getVectorAccessor();
				if (index >= std::size(vectorAccessor.value())) [[unlikely]]
					return std::unexpected{"Branch index out of bounds"sv};
				if (auto sharedNode = vectorAccessor.value()[index].lock()) [[likely]]
					return MeshNodePtr{sharedNode};
				return std::unexpected{"Failed to lock weak pointer for branch. Node might have been deleted"sv};
			}

			auto operator>>(const MeshNodePtr& other) -> const MeshNodePtr&
			requires (not IsConst)
			{
				auto persistenceGuard = m_persistenceGuard;
				m_vectorAccessor.reset();
				MeshNodePtr::attach(m_parent, m_key, other, persistenceGuard);
				return other;
			}

			auto operator>>(Branch<false>&& other) -> Branch<false>&&
			requires (not IsConst)
			{
				auto persistenceGuard = m_persistenceGuard;
				m_vectorAccessor.reset();
				MeshNodePtr::attach(m_parent, m_key, other.m_parent, persistenceGuard);
				return std::move(other);
			}

			auto operator-(const MeshNodePtr& other) -> void
			requires (not IsConst)
			{
				m_vectorAccessor.reset();
				MeshNodePtr::detach(m_parent, m_key, other);
			}

			template<bool OtherIsConst>
			auto operator&(const Branch<OtherIsConst>& other) -> void
			requires (not IsConst)
			{
				auto persistenceGuard = m_persistenceGuard;
				auto otherPersistenceGuard = other.m_persistenceGuard;
				m_vectorAccessor.reset();
				other.m_vectorAccessor.reset();
				MeshNodePtr::attach(other.m_key, m_parent, m_key, other.m_parent, otherPersistenceGuard, persistenceGuard);
			}

			template<bool OtherIsConst>
			auto operator/(const Branch<OtherIsConst>& other) -> void
			requires (not IsConst)
			{
				m_vectorAccessor.reset();
				other.m_vectorAccessor.reset();
				MeshNodePtr::detach(other.m_key, m_parent, m_key, other.m_parent);
			}

			[[nodiscard]] auto front() const { return (*this)[0]; }
			[[nodiscard]] auto back() const { return (*this)[size() - 1]; }

			struct Iterator final
			{
				using iterator_category = std::random_access_iterator_tag;
				using value_type = MeshNodePtr;
				using difference_type = std::ptrdiff_t;
				using pointer = void;
				using reference = MeshNodePtr;

				const Branch* branch = nullptr;
				std::size_t index = 0uz;

				[[nodiscard]] auto operator*() const -> MeshNodePtr { return (*branch)[index].value_or(MeshNodePtr{}); }

				auto operator++() -> Iterator&
				{
					++index;
					return *this;
				}
				auto operator++(int) -> Iterator
				{
					auto oldValue = *this;
					++index;
					return oldValue;
				}
				auto operator--() -> Iterator&
				{
					--index;
					return *this;
				}
				auto operator--(int) -> Iterator
				{
					auto oldValue = *this;
					--index;
					return oldValue;
				}

				auto operator+=(difference_type n) -> Iterator&
				{
					index = static_cast<std::size_t>(static_cast<difference_type>(index) + n);
					return *this;
				}
				auto operator-=(difference_type n) -> Iterator&
				{
					index = static_cast<std::size_t>(static_cast<difference_type>(index) - n);
					return *this;
				}

				[[nodiscard]] friend auto operator+(Iterator it, difference_type n) -> Iterator
				{
					it += n;
					return it;
				}
				[[nodiscard]] friend auto operator+(difference_type n, Iterator it) -> Iterator
				{
					it += n;
					return it;
				}
				[[nodiscard]] friend auto operator-(Iterator it, difference_type n) -> Iterator
				{
					it -= n;
					return it;
				}
				[[nodiscard]] friend auto operator-(const Iterator& lhs, const Iterator& rhs) -> difference_type
				{
					return static_cast<difference_type>(lhs.index) - static_cast<difference_type>(rhs.index);
				}

				[[nodiscard]] auto operator[](difference_type n) const -> MeshNodePtr { return *(*this + n); }

				[[nodiscard]] auto operator<=>(const Iterator& other) const = default;
			};

			static_assert(std::random_access_iterator<Iterator>);

			[[nodiscard]] auto begin() const { return Iterator{this, 0uz}; }
			[[nodiscard]] auto end() const { return Iterator{this, size()}; }

		private:
			MeshNodePtr m_parent;
			Key m_key;
			SafeShared<std::vector<WeakPtr>> m_persistenceGuard;
			mutable std::optional<VectorAccessor> m_vectorAccessor;

			friend class MeshNodePtr;
		};

		using MutableBranch = Branch<false>;
		using ConstBranch = Branch<true>;

		[[nodiscard]] static auto makeRoot(auto&&... args) -> MeshNodePtr
		{
			return MeshNodePtr{NetworkPtr<MeshNode>::makeRoot(std::forward<decltype(args)>(args)...)};
		}

		[[nodiscard]] static auto make(auto&&... args) -> MeshNodePtr
		{
			return MeshNodePtr{NetworkPtr<MeshNode>::make(std::forward<decltype(args)>(args)...)};
		}

		MeshNodePtr() = default;
		explicit MeshNodePtr(SharedPtr node): m_node{std::move(node)} {}

		[[nodiscard]] auto operator==(const MeshNodePtr& other) const noexcept -> bool
		{
			return Thread::SharedPtr::ownerEqual(m_node, other.m_node);
		}

		explicit operator bool() const noexcept { return m_node != nullptr; }

		[[nodiscard]] auto operator[](this auto&& self, const Key& key)
		{
			using SelfType = std::remove_reference_t<decltype(self)>;
			if (not self.m_node)
				throw std::runtime_error{"MeshNodePtr::operator[]: Invalid MeshNodePtr"};

			if constexpr (std::is_const_v<SelfType>)
			{
				auto mapAccessor = self.m_node->sharedAccess()->value.branches.sharedAccess();
				auto persistenceGuardPtr = mapAccessor->at(key);
				return Branch<true>{self, key, persistenceGuardPtr, persistenceGuardPtr->sharedAccess()};
			}
			auto persistenceGuardPtr = SafeShared<std::vector<WeakPtr>>{};
			{
				auto nodeAccessor = self.m_node->uniqueAccess();
				auto mapAccessor = nodeAccessor->value.branches.uniqueAccess();
				auto& entry = mapAccessor.value()[key];
				if (not entry)
					entry = makeSafeShared<std::vector<WeakPtr>>();
				persistenceGuardPtr = entry;
			}
			return Branch<false>{self, key, persistenceGuardPtr, persistenceGuardPtr->uniqueAccess()};
		}

		[[nodiscard]] auto at(const Key& key) const -> std::expected<Branch<true>, std::string_view>
		{
			using namespace std::literals;

			if (not m_node)
				return std::unexpected{"MeshNodePtr::at(): Invalid MeshNodePtr"sv};

			auto branchesAccessor = m_node->sharedAccess()->value.branches.sharedAccess();
			if (auto branchIterator = branchesAccessor->find(key); branchIterator != std::cend(branchesAccessor.value())) [[likely]]
			{
				auto persistenceGuardPtr = branchIterator->second;
				return Branch<true>{*this, key, persistenceGuardPtr, persistenceGuardPtr->sharedAccess()};
			}

			return std::unexpected{"MeshNodePtr::at(): Key not found"sv};
		}

		[[nodiscard]] auto contains(const Key& key) const -> bool
		{
			if (not m_node)
				return false;
			auto nodeAccessor = m_node->sharedAccess();
			return nodeAccessor->value.branches.sharedAccess()->contains(key);
		}

		[[nodiscard]] auto count(const Key& key) const -> std::size_t
		{
			if (not m_node)
				return 0uz;
			auto nodeAccessor = m_node->sharedAccess();
			return nodeAccessor->value.branches.sharedAccess()->count(key);
		}

		[[nodiscard]] auto getDistanceFromRoot() const -> std::size_t
		{
			if (not m_node)
				return std::numeric_limits<std::size_t>::max();
			return m_node->sharedAccess()->getDistanceFromRoot();
		}

		[[nodiscard]] auto operator->(this auto&& self)
		{
			return std::addressof(std::forward_like<decltype(self)>(*self.m_node));
		}

		[[nodiscard]] auto operator*(this auto&& self) -> decltype(auto)
		{
			return std::forward_like<decltype(self)>(*self.m_node);
		}

		auto setValue(auto&& newValue) -> void
		{
			auto nodeAccessor = m_node->uniqueAccess();
			auto& meshNode = nodeAccessor->value;
			meshNode.value.uniqueAccess().value() = std::forward<decltype(newValue)>(newValue);
		}

		[[nodiscard]] auto getValue() const -> Thread::ReadOnlyAccessor<Value>
		{
			auto nodeAccessor = m_node->sharedAccess();
			return nodeAccessor->value.value.sharedAccess();
		}

		[[nodiscard]] auto getBranches() const -> Thread::ReadOnlyAccessor<Branches>
		{
			auto nodeAccessor = m_node->sharedAccess();
			return nodeAccessor->value.branches.sharedAccess();
		}

	private:
		SharedPtr m_node = nullptr;
	};
}