#include "stdafx.h"
#include "ModelImporter.h"

#define TINYOBJLOADER_IMPLEMENTATION
#include "tiny_obj_loader.h"

#include <fstream>

using namespace std;
using namespace wiGraphicsTypes;
using namespace wiSceneComponents;

Model* ImportModel_OBJ(const std::string& fileName)
{
	string directory, name;
	wiHelper::SplitPath(fileName, directory, name);
	wiHelper::RemoveExtensionFromFileName(name);



	tinyobj::attrib_t obj_attrib;
	vector<tinyobj::shape_t> obj_shapes;
	vector<tinyobj::material_t> obj_materials;
	string obj_errors;

	bool success = tinyobj::LoadObj(&obj_attrib, &obj_shapes, &obj_materials, &obj_errors, fileName.c_str(), directory.c_str(), true);

	if (success)
	{
		Model* model = new Model;
		model->name = name;

		// Load material library:
		vector<Material*> materialLibrary = {};
		for (auto& obj_material : obj_materials)
		{
			Material* material = new Material(obj_material.name);

			material->diffuseColor = XMFLOAT3(obj_material.diffuse[0], obj_material.diffuse[1], obj_material.diffuse[2]);
			material->textureName = obj_material.diffuse_texname;
			material->displacementMapName = obj_material.displacement_texname;
			if (material->displacementMapName.empty())
			{
				material->displacementMapName = obj_material.bump_texname;
			}
			material->emissive = max(obj_material.emission[0], max(obj_material.emission[1], obj_material.emission[2]));
			//obj_material.emissive_texname;
			material->refractionIndex = obj_material.ior;
			material->metalness = obj_material.metallic;
			//obj_material.metallic_texname;
			material->normalMapName = obj_material.normal_texname;
			material->surfaceMapName = obj_material.reflection_texname;
			material->roughness = obj_material.roughness;
			//obj_material.roughness_texname;
			material->specular_power = (int)obj_material.shininess;
			material->specular = XMFLOAT4(obj_material.specular[0], obj_material.specular[1], obj_material.specular[2], 1);
			material->specularMapName = obj_material.specular_texname;

			if (!material->surfaceMapName.empty())
			{
				material->surfaceMapName = directory + material->surfaceMapName;
				material->surfaceMap = (Texture2D*)wiResourceManager::GetGlobal()->add(material->surfaceMapName);
			}
			if (!material->textureName.empty())
			{
				material->textureName = directory + material->textureName;
				material->texture = (Texture2D*)wiResourceManager::GetGlobal()->add(material->textureName);
			}
			if (!material->normalMapName.empty())
			{
				material->normalMapName = directory + material->normalMapName;
				material->normalMap = (Texture2D*)wiResourceManager::GetGlobal()->add(material->normalMapName);
			}
			if (!material->displacementMapName.empty())
			{
				material->displacementMapName = directory + material->displacementMapName;
				material->displacementMap = (Texture2D*)wiResourceManager::GetGlobal()->add(material->displacementMapName);
			}
			if (!material->specularMapName.empty())
			{
				material->specularMapName = directory + material->specularMapName;
				material->specularMap = (Texture2D*)wiResourceManager::GetGlobal()->add(material->specularMapName);
			}

			material->ConvertToPhysicallyBasedMaterial();

			materialLibrary.push_back(material); // for subset-indexing...
			model->materials.insert(make_pair(material->name, material));
		}

		if (materialLibrary.empty())
		{
			// Create default material if nothing was found:
			Material* material = new Material("OBJImport_defaultMaterial");
			materialLibrary.push_back(material);
			model->materials.insert(make_pair(material->name, material));
		}

		// Load objects, meshes:
		for (auto& shape : obj_shapes)
		{
			Object* object = new Object(shape.name);
			Mesh* mesh = new Mesh(shape.name + "_mesh");

			object->mesh = mesh;
			mesh->renderable = true;

			XMFLOAT3 min = XMFLOAT3(FLT_MAX, FLT_MAX, FLT_MAX);
			XMFLOAT3 max = XMFLOAT3(-FLT_MAX, -FLT_MAX, -FLT_MAX);

			unordered_map<int, int> registered_materialIndices = {};
			unordered_map<size_t, uint32_t> uniqueVertices = {};

			for (size_t i = 0; i < shape.mesh.indices.size(); i += 3)
			{
				tinyobj::index_t reordered_indices[] = {
					shape.mesh.indices[i + 0],
					shape.mesh.indices[i + 1],
					shape.mesh.indices[i + 2],
				};

				// todo: option param would be better
				bool flipCulling = false;
				if (flipCulling)
				{
					reordered_indices[1] = shape.mesh.indices[i + 2];
					reordered_indices[2] = shape.mesh.indices[i + 1];
				}

				for (auto& index : reordered_indices)
				{
					Mesh::Vertex_FULL vert;

					vert.pos = XMFLOAT4(
						obj_attrib.vertices[index.vertex_index * 3 + 0],
						obj_attrib.vertices[index.vertex_index * 3 + 1],
						obj_attrib.vertices[index.vertex_index * 3 + 2],
						0
					);

					if (!obj_attrib.normals.empty())
					{
						vert.nor = XMFLOAT4(
							obj_attrib.normals[index.normal_index * 3 + 0],
							obj_attrib.normals[index.normal_index * 3 + 1],
							obj_attrib.normals[index.normal_index * 3 + 2],
							0
						);
					}

					if (index.texcoord_index >= 0 && !obj_attrib.texcoords.empty())
					{
						vert.tex = XMFLOAT4(
							obj_attrib.texcoords[index.texcoord_index * 2 + 0],
							1 - obj_attrib.texcoords[index.texcoord_index * 2 + 1],
							0, 0
						);
					}

					int materialIndex = max(0, shape.mesh.material_ids[i / 3]); // this indexes the material library
					if (registered_materialIndices.count(materialIndex) == 0)
					{
						registered_materialIndices[materialIndex] = (int)mesh->subsets.size();
						mesh->subsets.push_back(MeshSubset());
						Material* material = materialLibrary[materialIndex];
						mesh->subsets.back().material = material;
						mesh->materialNames.push_back(material->name);
					}
					vert.tex.z = (float)registered_materialIndices[materialIndex]; // this indexes a mesh subset

																				   // todo: option parameter would be better
					const bool flipZ = true;
					if (flipZ)
					{
						vert.pos.z *= -1;
						vert.nor.z *= -1;
					}

					// eliminate duplicate vertices by means of hashing:
					size_t hashes[] = {
						hash<int>{}(index.vertex_index),
						hash<int>{}(index.normal_index),
						hash<int>{}(index.texcoord_index),
						hash<int>{}(materialIndex),
					};
					size_t vertexHash = (((hashes[0] ^ (hashes[1] << 1) >> 1) ^ (hashes[2] << 1)) >> 1) ^ (hashes[3] << 1);

					if (uniqueVertices.count(vertexHash) == 0)
					{
						uniqueVertices[vertexHash] = (uint32_t)mesh->vertices_FULL.size();
						mesh->vertices_FULL.push_back(vert);
					}
					mesh->indices.push_back(uniqueVertices[vertexHash]);

					min = wiMath::Min(min, XMFLOAT3(vert.pos.x, vert.pos.y, vert.pos.z));
					max = wiMath::Max(max, XMFLOAT3(vert.pos.x, vert.pos.y, vert.pos.z));
				}
			}
			mesh->aabb.create(min, max);

			// We need to eliminate colliding mesh names, because objects can reference them by names:
			//	Note: in engine, object is decoupled from mesh, for instancing support. OBJ file have only meshes and names can collide there.
			string meshName = mesh->name;
			uint32_t unique_counter = 0;
			bool meshNameCollision = model->meshes.count(meshName) != 0;
			while (meshNameCollision)
			{
				meshName = mesh->name + to_string(unique_counter);
				meshNameCollision = model->meshes.count(meshName) != 0;
				unique_counter++;
			}
			mesh->name = meshName;

			object->meshName = mesh->name;

			model->objects.insert(object);
			model->meshes.insert(make_pair(mesh->name, mesh));
		}

		model->FinishLoading();

		return model;
	}

	if (!obj_errors.empty())
	{
		wiBackLog::post(obj_errors.c_str());
		wiHelper::messageBox("OBJ import failed! Check backlog for errors!", "Error!");
	}

	return nullptr;
}