#include "OctreeBuilder.h"
#include <regex>

#include "TreeTypeParser.h"
#include "SettingsParser.h"
#include "../PathHelper.h"
#include "../StringHelper.h"

#include "../../scene/Material/Color.h"
#include "../../scene/Material/SmallNormal.h"
#include "../../scene/Material/ColorAndOpacity.h"
#include "../../scene/Material/ColorAndNormal.h"
#include "../../scene/Material/ColorAndNormalAndValue.h"

#include "../../scene/Octree/BaseTree.h"
#include "../../scene/Octree/ColorChannelMultiRootTree.h"
#include "../../scene/Octree/MultiRootBitsTree.h"
#include "../../scene/Octree/MaterialLibraryTree.h"

#include "ColorQuantizerFactory.h"
#include "NormalQuantizerFactory.h"
#include "ColorAndValueQuantizerFactory.h"
#include "CompressedTextureFactory.h"

#include "../Voxelizer/TriangleMeshVoxelizer.h"
#include "../Voxelizer/PVMVoxelizer.h"

#include "StandardOctreeBuilder.h"
#include "MultiRootOctreeBuilder.h"
#include "ColorChannelMultiRootOctreeBuilder.h"
#include "MultiBitsMultiRootOctreeBuilder.h"
#include "HierarchicalMaterialOctreeBuilder.h"
#include "UniqueIndexMaterialOctreeBuilder.h"
#include "UniqueIndexShiftColoredOctreeBuilder.h"
#include "RandomOctreeBuilder.h"
#include "MaterialLibraryMultiRootOctreeBuilder.h"

#include "../../PropertyLoader.h"
#include "../Util/Stopwatch.h"

std::string OctreeBuilder::mTreeType = "s";

OctreeBuilder::OctreeBuilder() {}


OctreeBuilder::~OctreeBuilder() {}

BaseOctreeBuilder* OctreeBuilder::mInstance = NULL;
BaseQuantizer<Color, ColorCompare>* OctreeBuilder::mColorQuantizer = NULL;
BaseQuantizer<SmallNormal, NormalCompare>* OctreeBuilder::mNormalQuantizer = NULL;
BaseQuantizer<ColorAndNormal, ColorAndNormalCompare>* OctreeBuilder::mColorAndNormalQuantizer = NULL;
BaseQuantizer<ColorAndOpacity, ColorAndOpacityCompare>* OctreeBuilder::mColorAndOpacityQuantizer = NULL;
BaseQuantizer<ColorAndNormalAndValue, ColorAndNormalAndValueCompare>* OctreeBuilder::mColorAndNormalAndValueQuantizer = NULL;

BaseOctreeBuilder* OctreeBuilder::Instance() {
	return mInstance;
}

void OctreeBuilder::SetTreeType(std::string type)
{
	if (mInstance != NULL && type != mTreeType)
	{
		Destroy();
		Create(type);
	}
}
std::string OctreeBuilder::GetTreeType()
{
	return mTreeType;
}

void OctreeBuilder::Create()
{
	// Destroy any old octree builders (to prevent memory leaks)
	Destroy();

	// Create the new octree builder
	Create(SettingsParser::GetTreeTypeFromSettings());
}

void OctreeBuilder::Destroy()
{
	if (mInstance != NULL)
		delete mInstance;
	mInstance = NULL;
	if (mColorQuantizer != NULL)
		delete mColorQuantizer;
	mColorQuantizer = NULL;
	if (mColorAndNormalQuantizer != NULL) delete mColorAndNormalQuantizer;
	mColorAndNormalQuantizer = NULL;
}

OctreeBuilderStatistics OctreeBuilder::BuildOctree()
{
	PropertyLoader::Create();
	return BuildOctree(SettingsParser::GetMaxLevelFromSettings(), PropertyLoader::Instance()->GetProperty("obj_to_dag"), PropertyLoader::Instance()->GetProperty("dag_file"));
}

OctreeBuilderStatistics OctreeBuilder::BuildOctree(unsigned8 depth)
{
	PropertyLoader::Create();
	return BuildOctree(depth, PropertyLoader::Instance()->GetProperty("obj_to_dag"), PropertyLoader::Instance()->GetProperty("dag_file"));
}

OctreeBuilderStatistics OctreeBuilder::BuildOctree(unsigned8 depth, std::string sceneFile, std::string dagFile)
{
	mInstance->SetOutputFile(dagFile);
	mInstance->SetVerbose(SettingsParser::GetVerboseFromSettings());
	mInstance->SetForceRebuild(SettingsParser::GetForceRebuildFromSettings());
	std::string filetype = PathHelper::GetExtension(sceneFile);
	StringHelper::ToUpper(filetype);
	BaseVoxelizer* voxelizer;
	if (filetype == "PVM" || filetype == "DAT")
		voxelizer = new PVMVoxelizer();
	else
		voxelizer = new TriangleMeshVoxelizer();
	voxelizer->Initialize();
	voxelizer->LoadScene(sceneFile);
	OctreeBuilderStatistics res = mInstance->BuildOctree(*voxelizer, depth, (unsigned8)PropertyLoader::Instance()->GetIntProperty("octreebuilder_max_single_pass_layers"));
	voxelizer->UnloadScene();
	delete voxelizer;
	return res;
}

void OctreeBuilder::Create(std::string type)
{
	TreeTypeDescriptor descr = TreeTypeParser::GetTreeTypeDescriptor(type);
	if (descr.material == "c")
		mColorQuantizer = ColorQuantizerFactory::Create(descr.quantizer);
	else if (descr.material == "n")
		mNormalQuantizer = NormalQuantizerFactory::Create(descr.quantizer);
	else if (descr.material == "cn")
		mColorAndNormalQuantizer = ColorAndNormalQuantizerFactory::Create(descr.quantizer);
	else if (descr.material == "cnr")
		mColorAndNormalAndValueQuantizer = ColorAndNormalAndValueQuantizerFactory::Create(descr.quantizer);
	else if (descr.material == "co")
		mColorAndOpacityQuantizer = ColorAndOpacityQuantizerFactory::Create(descr.quantizer);

	

	if (descr.globalType == UNIQUEINDEX)
	{
		// Parse the number of levels without material information (LOD) if it isn't empty.
		unsigned8 levelsWithoutMaterial = TreeTypeParser::GetLevelsWithoutMaterials(descr);
		if (descr.additionalTypeInfo != "" && descr.additionalTypeInfo[0] == 's')
		{
			assert(descr.material == "c");
			mInstance = new UniqueIndexShiftColoredOctreeBuilder(descr.textureCompressor, mColorQuantizer, levelsWithoutMaterial);
		}
		else
		{
			if (descr.material == "c")
				mInstance = new UniqueIndexMaterialOctreeBuilder<Color, ColorCompare>(descr.textureCompressor, mColorQuantizer, levelsWithoutMaterial);
			else if (descr.material == "n")
				mInstance = new UniqueIndexMaterialOctreeBuilder<SmallNormal, NormalCompare>(descr.textureCompressor, mNormalQuantizer, levelsWithoutMaterial);
			else if (descr.material == "cn")
				mInstance = new UniqueIndexMaterialOctreeBuilder<ColorAndNormal, ColorAndNormalCompare>(descr.textureCompressor, mColorAndNormalQuantizer, levelsWithoutMaterial);
			else if (descr.material == "cnr")
				mInstance = new UniqueIndexMaterialOctreeBuilder<ColorAndNormalAndValue, ColorAndNormalAndValueCompare>(descr.textureCompressor, mColorAndNormalAndValueQuantizer, levelsWithoutMaterial);
			else if (descr.material == "co")
				mInstance = new UniqueIndexMaterialOctreeBuilder<ColorAndOpacity, ColorAndOpacityCompare>(descr.textureCompressor, mColorAndOpacityQuantizer, levelsWithoutMaterial);
		}
	}
	else if (descr.globalType == HIERARCHICAL && descr.additionalTypeInfo == "")
	{
		if (descr.material == "c")
			mInstance = new HierarchicalMaterialOctreeBuilder<Color, ColorCompare>(mColorQuantizer);
		else if (descr.material == "n")
			mInstance = new HierarchicalMaterialOctreeBuilder<SmallNormal, NormalCompare>(mNormalQuantizer);
		else if (descr.material == "cn")
			mInstance = new HierarchicalMaterialOctreeBuilder<ColorAndNormal, ColorAndNormalCompare>(mColorAndNormalQuantizer);
		else if (descr.material == "cnr")
			mInstance = new HierarchicalMaterialOctreeBuilder<ColorAndNormalAndValue, ColorAndNormalAndValueCompare>(mColorAndNormalAndValueQuantizer);
		else if (descr.material == "co")
			mInstance = new HierarchicalMaterialOctreeBuilder<ColorAndOpacity, ColorAndOpacityCompare>(mColorAndOpacityQuantizer);
	}
	else if (descr.globalType == MULTIROOT)
	{
		if (descr.additionalTypeInfo == "cc")
			mInstance = new MaterialMultiRootOctreeBuilder<ColorChannel>(type);
		else if (descr.additionalTypeInfo == "" || (descr.additionalTypeInfo.size() == 1 && descr.additionalTypeInfo[0] >= 49 && descr.additionalTypeInfo[0] <= 56))
		{
			unsigned8 bitsPerChannel = TreeTypeParser::GetBitsPerChannel(descr);
			mInstance = new MultiRootOctreeBuilder(bitsPerChannel);
		}
		else
		{
			unsigned8 bitsPerChannel = TreeTypeParser::GetBitsPerChannel(descr);
			unsigned8 bitsPerTree = TreeTypeParser::GetBitsPerTree(descr);
			switch (bitsPerTree)
			{
			case 1: mInstance = new MaterialMultiRootOctreeBuilder<BitsMaterial<1>>(type, bitsPerChannel); break;
			case 2: mInstance = new MaterialMultiRootOctreeBuilder<BitsMaterial<2>>(type, bitsPerChannel); break;
			case 3: mInstance = new MaterialMultiRootOctreeBuilder<BitsMaterial<3>>(type, bitsPerChannel); break;
			case 4: mInstance = new MaterialMultiRootOctreeBuilder<BitsMaterial<4>>(type, bitsPerChannel); break;
			case 5: mInstance = new MaterialMultiRootOctreeBuilder<BitsMaterial<5>>(type, bitsPerChannel); break;
			case 6: mInstance = new MaterialMultiRootOctreeBuilder<BitsMaterial<6>>(type, bitsPerChannel); break;
			case 7: mInstance = new MaterialMultiRootOctreeBuilder<BitsMaterial<7>>(type, bitsPerChannel); break;
			case 8: mInstance = new MaterialMultiRootOctreeBuilder<BitsMaterial<8>>(type, bitsPerChannel); break;
			}
		}
	}
	else if (descr.globalType == RANDOM)
	{
		mInstance = new RandomOctreeBuilder();
	}
	else if (descr.globalType == BITTREES)
	{
		if (descr.additionalTypeInfo == "l" && descr.material == "c")
			mInstance = new MaterialLibraryMultiRootOctreeBuilder(mColorQuantizer);
	}
	else
	{
		mInstance = new StandardOctreeBuilder();
	}
	mTreeType = type;
}