#pragma once
#include "MultiRootTree.h"
#include "MaterialNode.h"

template<typename T, typename Comparer = std::less<T>>
class MultiRootMaterialNode : public MaterialNode<T, Comparer>
{
private:
	bool mIsGeometry;

public:
	MultiRootMaterialNode(BaseTree* root, unsigned8 level = 0) : MaterialNode<T, Comparer>(root, level) {}
	MultiRootMaterialNode(BaseTree* root, T material, unsigned8 level = 0) : MaterialNode<T, Comparer>(root, material, level) {}
	MultiRootMaterialNode(BaseTree* root, T material, bool isGeometry, unsigned8 level = 0) : MultiRootMaterialNode(root, material, level) { mIsGeometry = isGeometry; }
	MultiRootMaterialNode(MultiRootMaterialNode&& node) : MaterialNode<T, Comparer>(std::move(node)) // Move ctor
	{
		mIsGeometry = std::move(node.mIsGeometry);
	}

	~MultiRootMaterialNode() {}

	MultiRootMaterialNode& operator=(MultiRootMaterialNode&& node) // Move assignment operator
	{
		mIsGeometry = std::move(node.mIsGeometry);
		MaterialNode<T, Comparer>::operator=(std::move(node));
		return *this;
	}

	bool GetIsGeometry() const { return mIsGeometry; }
	void SetIsGeometry(bool value) { mIsGeometry = value; }

	bool Compare(const MultiRootMaterialNode<T, Comparer>& node) const
	{
		if (this->mIsGeometry != node.mIsGeometry) return !mIsGeometry;
		return MaterialNode<T, Comparer>::Compare(node);
	}

	bool Equals(const MultiRootMaterialNode<T, Comparer>& node) const
	{
		return node.mIsGeometry == this->mIsGeometry && MaterialNode<T, Comparer>::Equals(node);
	}

	void WriteProperties(std::ostream& file)
	{
		Serializer<bool>::Serialize(mIsGeometry, file);
		MaterialNode<T, Comparer>::WriteProperties(file);
	}
	void ReadProperties(std::istream& file)
	{
		Serializer<bool>::Deserialize(mIsGeometry, file);
		MaterialNode<T, Comparer>::ReadProperties(file);
	}

	void CopyProperties(MultiRootMaterialNode* node)
	{
		this->SetIsGeometry(node->GetIsGeometry());
		MaterialNode<T, Comparer>::CopyProperties(node);
	}
};

template<typename T, typename Comparer = std::less<T>>
class HierarchicalMaterialMultiRoot : public MultiRootTree<MultiRootMaterialNode<T, Comparer>>
{
private:
	T mMaterial; // Material for the root
public:
	HierarchicalMaterialMultiRoot(unsigned8 maxLevel, unsigned32 slaveRootCount) :
		MultiRootTree<MultiRootMaterialNode<T, Comparer>>(maxLevel, slaveRootCount) 
	{
		mLeafsAreEqual = false;
	}

	~HierarchicalMaterialMultiRoot() override {}
	
	T GetMaterial(unsigned32 nodeIndex) const
	{
		return GetTypedNode(nodeIndex)->GetMaterial();
	}

	virtual unsigned8 GetAdditionalBytesPerNode(unsigned8 level) const override { return sizeof(T); }
	virtual std::vector<unsigned8> GetAdditionalNodeBytes(const Node* node) const override { return GetMaterial(node->GetIndex()).Serialize(); }

	MultiRootMaterialNode<T, Comparer>* AddLeafNode(glm::uvec3 coordinate)
	{
		MultiRootMaterialNode<T, Comparer>* node = MultiRootTree<MultiRootMaterialNode<T, Comparer>>::AddLeafNode(coordinate);
		node->SetIsGeometry(true);
		return node;
		// TODO: Mark all nodes along the path as "IsGeometry" = True
	}

	MultiRootMaterialNode<T, Comparer>* AddLeafNode(glm::uvec3 coordinate, size_t slaveRootID, T material)
	{
		MultiRootMaterialNode<T, Comparer>* node = MultiRootTree<MultiRootMaterialNode<T, Comparer>>::AddLeafNode(coordinate, slaveRootID);
		node->SetMaterial(material);
		node->SetIsGeometry(false);
		return node;
		// TODO: Mark all nodes along the path as "IsGeometry" = False
	}
};