#ifndef MESH_CLASS
#define MESH_CLASS

#include <iostream>
#include <random>
#include <vector>
#include <map>
#include <algorithm>

#include<glad/glad.h>
#include<GLFW/glfw3.h>
#include<glm/glm.hpp>
#include<glm/gtc/matrix_transform.hpp>
#include<glm/gtc/type_ptr.hpp>

#include "common.h"
#include "Engine.h"
#include "RenderSystem.h"
#include "Object.h"
#include "VAO.h"
#include "VBO.h"
#include "EBO.h"
#include "shaderClass.h"
#include "t.h"
#include "tFunctions.h"
#include "Vertex.h"
#include "texture.h"
#include "MeshData.h"

struct IntersectionData {
	glm::vec3 intersection;
	int face;
};

class Mesh : public Object , public Renderable, public t_package , public MeshData {
	friend class Model;
protected:
public:
	Texture* meshTexture = nullptr;

	VAO vao;
	VBO vbo;
	EBO ebo;

	Mesh() {

	};

	Mesh(const std::vector<Vertex>& meshvertices, const std::vector<GLuint>& meshindices/*, std::vector<Texture> textures*/)
	{
		InitializeMesh(meshvertices,meshindices);
	};

	void InitializeMesh(const std::vector<Vertex>& meshvertices, const std::vector<GLuint>& meshindices) {
		vertices = meshvertices;
		indices = meshindices;
		this->shadertype = ShaderType::MeshShader;
		GenerateRenderData();
		NormalizeVertices();
		UpdateVertices();
	}

	void GenerateRenderData() {
		vbo.GenerateID();
		vao.GenerateID();
		ebo.GenerateID();

		if (vertices.size() <= 0 or indices.size() <= 0) {
			std::cout << "NO VERTICES OR INDICES DURING RENDER DATA INTIALIZATION\n";

		}
		else {

			vao.Bind();
			vbo.BufferData(&vertices[0], vertices.size() * sizeof(Vertex));
			ebo.BufferData(&indices[0], indices.size() * sizeof(GLuint));

			vbo.Bind();
			ebo.Bind();

			vao.LinkVBO(vbo, 0, 3, GL_FLOAT, sizeof(Vertex), (void*)0);
			vao.LinkVBO(vbo, 1, 3, GL_FLOAT, sizeof(Vertex), (void*)offsetof(Vertex, Normal));
			vao.LinkVBO(vbo, 2, 2, GL_FLOAT, sizeof(Vertex), (void*)offsetof(Vertex, TexCoords));

			vao.Unbind();
			vbo.Unbind();
			ebo.Unbind();
		}
	}

	virtual ~Mesh() {
		vao.Delete();
		vbo.Delete();
		ebo.Delete();
		//delete this;
	}

	float GetVolume() const {
		float runningtotal = 0.0f;

		for (int i = 0; i < indices.size() / 3; i++) {
			runningtotal += VolumeOfTriangle(vertices[indices[i * 3]].Position, vertices[indices[i * 3 + 1]].Position, vertices[indices[i * 3 + 2]].Position);
		}
		
		return runningtotal * t.GetScale().x * t.GetScale().y * t.GetScale().z;
	}

	void Slice(glm::vec3 origin, glm::quat slicequat) {
		
		glm::vec3 pos = glm::conjugate(slicequat) * (t.GetTranslation() - origin);
		float relativeslicepos = -pos.y;
		std::vector<glm::vec3> rotatedvertices;
		std::vector<bool> vstates;

		if (pos.y * pos.y <= t.ScaleMagnitude2()) {
			bool posfound = false;
			bool negfound = false;
			for (int i = 0; i < vertices.size(); i++) {
				glm::vec3 vpos = glm::conjugate(slicequat) * (vertices[i].Position * t.GetScale());
				rotatedvertices.push_back(vpos);

				if (vpos.y> relativeslicepos) {
					posfound = true;
					vstates.push_back(true);
				}
				else {
					negfound = true;
					vstates.push_back(false);
				}
			}

			if (posfound and negfound) {
				std::vector<Vertex> posvertices;
				std::vector<Vertex> negvertices;
				std::vector<GLuint> posindices;
				std::vector<GLuint> negindices;

				std::vector<int> posnewvertices;
				std::vector<int> negnewvertices;

				glm::vec3 center;
				glm::vec3 negnormal = slicequat * glm::vec3(0.0f,1.0f,0.0f);
				glm::vec3 posnormal = -negnormal;

				for (int i = 0; i < indices.size()/3; i++) {
					//I IS THE CURRENT TRIANGLE

					//CONVERT TO VERTICES BY MULTI 3 + whatever

					int ind1 = indices[i * 3 + 0];
					int ind2 = indices[i * 3 + 1];
					int ind3 = indices[i * 3 + 2];

					bool vstate1 = vstates[ind1];
					bool vstate2 = vstates[ind2];
					bool vstate3 = vstates[ind3];

					if (vstate1 and vstate2 and vstate3) {

						posvertices.push_back(vertices[ind1]);
						posvertices.push_back(vertices[ind2]);
						posvertices.push_back(vertices[ind3]);

						posindices.push_back(posvertices.size() -3);
						posindices.push_back(posvertices.size() - 2);
						posindices.push_back(posvertices.size() - 1);
					}
					else if (not vstate1 and not vstate2 and not vstate3) {
						negvertices.push_back(vertices[ind1]);
						negvertices.push_back(vertices[ind2]);
						negvertices.push_back(vertices[ind3]);

						negindices.push_back(negvertices.size() - 3);
						negindices.push_back(negvertices.size() - 2);
						negindices.push_back(negvertices.size() - 1);
					}
					else {
						/**/
						int niso1;
						int niso2;
						int iso;
						Vertex v1;
						Vertex v2;

						bool isopos = false;
						if (vstate1 != vstate2 and vstate1 != vstate3) {
							//STATE1 IS THE ISO
							niso1 = ind2;
							niso2 = ind3;
							iso = ind1;
							isopos = vstate1;
						}
						else if (vstate2 != vstate1 and vstate2 != vstate3) {
							//STATE 2 IS THE ISO
							niso1 = ind3;
							niso2 = ind1;
							iso = ind2;
							isopos = vstate2;
						}
						else {
							//STATE 3 IS THE ISO
							niso1 = ind1;
							niso2 = ind2;
							iso = ind3;
							isopos = vstate3;
						}

						float v1factor = (rotatedvertices[niso1].y - relativeslicepos) / (rotatedvertices[niso1].y - rotatedvertices[iso].y);
						float v2factor = (rotatedvertices[niso2].y - relativeslicepos) / (rotatedvertices[niso2].y - rotatedvertices[iso].y);

						glm::vec3 v1pos = glm::mix(rotatedvertices[niso1], rotatedvertices[iso], v1factor);
						glm::vec3 v2pos = glm::mix(rotatedvertices[niso2], rotatedvertices[iso], v2factor);
						v1.Position = (slicequat * v1pos) / t.GetScale();
						v2.Position = (slicequat * v2pos) / t.GetScale();
						v1.Normal = glm::mix(vertices[niso1].Normal, vertices[iso].Normal, v1factor);
						v2.Normal = glm::mix(vertices[niso2].Normal, vertices[iso].Normal, v2factor);
						v1.TexCoords = glm::mix(vertices[niso1].TexCoords, vertices[iso].TexCoords, v1factor);
						v2.TexCoords = glm::mix(vertices[niso2].TexCoords, vertices[iso].TexCoords, v2factor);

						if (isopos) {
							//THE ISOLATED VERTEX IS IN THE POS MESH
							posvertices.push_back(v1);
							posvertices.push_back(v2);
							posvertices.push_back(vertices[iso]);
							posnewvertices.push_back(posvertices.size() - 3);
							posnewvertices.push_back(posvertices.size() - 2);

							posindices.push_back(posvertices.size() - 3);
							posindices.push_back(posvertices.size() - 2);
							posindices.push_back(posvertices.size() - 1);

							negvertices.push_back(vertices[niso1]);
							negvertices.push_back(vertices[niso2]);
							negvertices.push_back(v1);
							negvertices.push_back(v2);

							negindices.push_back(negvertices.size() - 4);
							negindices.push_back(negvertices.size() - 3);
							negindices.push_back(negvertices.size() - 1);

							negindices.push_back(negvertices.size() - 1);
							negindices.push_back(negvertices.size() - 2);
							negindices.push_back(negvertices.size() - 4);

							negnewvertices.push_back(negvertices.size() - 2);
							negnewvertices.push_back(negvertices.size() - 1);
						}
						else {
							//THE ISOLATED VERTEX IS IN THE NEG MESH
							negvertices.push_back(v1);
							negvertices.push_back(v2);
							negvertices.push_back(vertices[iso]);

							negindices.push_back(negvertices.size() - 3);
							negindices.push_back(negvertices.size() - 2);
							negindices.push_back(negvertices.size() - 1);

							negnewvertices.push_back(negvertices.size() - 3);
							negnewvertices.push_back(negvertices.size() - 2);

							posvertices.push_back(vertices[niso1]);
							posvertices.push_back(vertices[niso2]);
							posvertices.push_back(v1);
							posvertices.push_back(v2);

							posindices.push_back(posvertices.size() - 4);
							posindices.push_back(posvertices.size() - 3);
							posindices.push_back(posvertices.size() - 1);

							posindices.push_back(posvertices.size() - 1);
							posindices.push_back(posvertices.size() - 2);
							posindices.push_back(posvertices.size() - 4);

							posnewvertices.push_back(posvertices.size() - 2);
							posnewvertices.push_back(posvertices.size() - 1);
						}
					}
				}

				if (negnewvertices.size() >= 3) {

					std::sort(negnewvertices.begin(), negnewvertices.end(), [&negvertices](int& a, int& b) {
						return negvertices[a].Position.x > negvertices[b].Position.x;
					});

					for (int i = 2; i < negnewvertices.size(); i++)
					{
						int index0 = negnewvertices[i];
						int index1 = negnewvertices[i - 1];
						int index2 = negnewvertices[i - 2];
						
						negvertices.push_back(negvertices[index0]);
						if ((i+1) % 2 == 0) {
							negvertices.push_back(negvertices[index2]);
							
							negvertices.push_back(negvertices[index1]);
						}
						else {
							negvertices.push_back(negvertices[index1]);
							negvertices.push_back(negvertices[index2]);
						}
						
						negindices.push_back(negvertices.size()-3);
						negindices.push_back(negvertices.size() - 2);
						negindices.push_back(negvertices.size() - 1);
					}
				}
				if (posnewvertices.size() >= 3) {

					for (int i = 2; i < posnewvertices.size(); i++)
					{
						int index0 = posnewvertices[i];
						int index1 = posnewvertices[i - 1];
						int index2 = posnewvertices[i - 2];
						posvertices.push_back(posvertices[index0]);
						if (i% 2 == 0) {
							posvertices.push_back(posvertices[index2]);
							posvertices.push_back(posvertices[index1]);
						}
						else {
							posvertices.push_back(posvertices[index1]);
							posvertices.push_back(posvertices[index2]);
						}

						posindices.push_back(posvertices.size() - 3);
						posindices.push_back(posvertices.size() - 2);
						posindices.push_back(posvertices.size() - 1);
					}
				}

				if (posindices.size() > 0) {
					Mesh* posmesh = Clone();
					posmesh->vertices = posvertices;
					posmesh->indices = posindices;
					posmesh->t.TranslateBy(slicequat* glm::vec3(0.0f, 0.1f, 0.0f));
					posmesh->NormalizeVertices();
					posmesh->UpdateVertices();
					posmesh->UpdateIndices();
					GetParent()->AddChild(posmesh);
				}
				if (negindices.size() > 0) {
					Mesh* negmesh = Clone();
					negmesh->indices = negindices;
					negmesh->vertices = negvertices;
					negmesh->t.TranslateBy(slicequat* glm::vec3(0.0f, -0.1f, 0.0f));
					negmesh->NormalizeVertices();
					negmesh->UpdateVertices();
					negmesh->UpdateIndices();
					GetParent()->AddChild(negmesh);
				}
				
				Delete();
			}
		}
	}

	virtual Mesh* Clone() override {
		Mesh* tr = new Mesh(*this);
		tr->GenerateRenderData();
		return tr;
	};

	void Clear() {
		vertices = std::vector<Vertex>();
		indices = std::vector<GLuint>();
	}

	void SetVertices(std::vector<Vertex>& e) {
		glBufferSubData(GL_ARRAY_BUFFER, NULL, sizeof(e), &e[0]);

		glBindBuffer(GL_ARRAY_BUFFER, vbo.ID);
		glBufferData(GL_ARRAY_BUFFER, sizeof(e), &e[0], GL_DYNAMIC_DRAW);
		glBindBuffer(GL_ARRAY_BUFFER, 0);
	}

	void UpdateVertices() {
		if (vertices.size() > 0) {

			glBufferSubData(GL_ARRAY_BUFFER, NULL, sizeof(vertices), &vertices[0]);
			glBindBuffer(GL_ARRAY_BUFFER, vbo.ID);
			glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), &vertices[0], GL_STATIC_DRAW);
			glBindBuffer(GL_ARRAY_BUFFER, 0);
		}
		else std::cout << "NO VERTICES IN THIS MESH!!!!\n";
	}

	void UpdateIndices() {
		if (ebo.ID == 0) {
			std::cout << "EBO NOT INITIALIZED\m";
			return;
		}
		if (indices.size() > 0) {
		glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, NULL, sizeof(indices), &indices[0]);
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo.ID);
		glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(GLuint), &indices[0], GL_STATIC_DRAW);
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
	}
		else std::cout << "NO INDICES IN THIS MESH!!!!\n";
	}

	void NormalizeVertices() {
		if (vertices.size() == 0) {
			std::cout << "TRIED TO NORMALIZED ZERO VERTICES???\n";
		}
		float biggestx = -FLT_MAX;
		float smallestx = FLT_MAX;
		float biggesty = -FLT_MAX;
		float smallesty = FLT_MAX;
		float biggestz = -FLT_MAX;
		float smallestz = FLT_MAX;
		for (Vertex& vertex : vertices) {
			biggestx = glm::max(biggestx, vertex.Position.x);
			smallestx = glm::min(smallestx, vertex.Position.x);
			biggesty = glm::max(biggesty, vertex.Position.y);
			smallesty = glm::min(smallesty, vertex.Position.y);
			biggestz = glm::max(biggestz, vertex.Position.z);
			smallestz = glm::min(smallestz, vertex.Position.z);
		}

		float xf = biggestx - smallestx;
		float yf = biggesty - smallesty;
		float zf = biggestz - smallestz;

		float midx = (biggestx + smallestx) / 2.0f;
		float midy = (biggesty + smallesty) / 2.0f;
		float midz = (biggestz + smallestz) / 2.0f;
		t.TranslateBy(glm::vec3(midx, midy, midz) * t.GetScale());

		t.ScaleBy(glm::vec3(xf,yf,zf));
		glm::vec3 scale = t.GetScale();
		if (scale.x == 0.0f) {
			t.ScaleToX(xf);
		}
		if (scale.y == 0.0f) {
			t.ScaleToY(yf);
		}
		if (scale.z == 0.0f) {
			t.ScaleToZ(zf);
		}

		for (Vertex& vertex : vertices) {
			vertex.Position = glm::vec3(
				(vertex.Position.x - midx) / xf,
				(vertex.Position.y - midy) / yf,
				(vertex.Position.z - midz) / zf
			);

			if (xf == 0.0f) {
				vertex.Position.x = 0.0f;
			}
			if (yf == 0.0f) {
				vertex.Position.y = 0.0f;
			}
			if (zf == 0.0f) {
				vertex.Position.z = 0.0f;
			}
		}
	}

	void Render(Shader& ShaderProgram) override {
		glm::mat4 topass = t.GetMatrix();

		ShaderProgram.Activate();
		glActiveTexture(GL_TEXTURE1);
		if (meshTexture != nullptr) {
			glBindTexture(GL_TEXTURE_2D, meshTexture->ID);
			ShaderProgram.SetInt("tex", 1);
		}
		else glBindTexture(GL_TEXTURE_2D, 0);

		ShaderProgram.SetMat4("modl",  topass);
		vao.Bind();
		glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
		vao.Unbind();
	};

	virtual void RenderWireframe(Shader& ShaderProgram) {
		glDisable(GL_CULL_FACE);
		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
		Render(ShaderProgram);
		glEnable(GL_CULL_FACE);
		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

	};

	void DeleteRenderData() {
		vbo.Delete();
		ebo.Delete();
		vao.Delete();
	}

	virtual void Delete() override {
		DeleteRenderData();
		Object::Delete();
	}
public:
	//random ass functions
	void DivideFace(int face, glm::vec3 centerlocalspace) {

		int v1 = indices[face * 3];
		int v2 = indices[face * 3 + 1];
		int v3 = indices[face * 3 + 2];

		Vertex newvertex;
		newvertex.Position = centerlocalspace;
		newvertex.TexCoords = { 0.0f,0.0f };
		newvertex.Normal = CalculateTriangleNormal({ vertices[v1].Position ,vertices[v2].Position ,vertices[v3].Position });
		vertices.push_back(newvertex);
		int nvp = vertices.size() - 1;

		indices.erase(indices.begin() + face * 3, indices.begin() + face * 3 + 3);



		indices.push_back(v1);
		indices.push_back(v2);
		indices.push_back(nvp);

		indices.push_back(v2);
		indices.push_back(v3);
		indices.push_back(nvp);

		indices.push_back(v3);
		indices.push_back(v1);
		indices.push_back(nvp);

		UpdateIndices();
		UpdateVertices();
	}

	bool RayIntersectsMeshNoInfo(const Ray& ray)
	{
		glm::mat4 inverse = glm::inverse(t.GetMatrix());
		glm::vec3 ray_origin = glm::vec3(inverse * glm::vec4(ray.origin, 1.0f));
		glm::vec3 ray_direction = glm::vec3(inverse * glm::vec4(ray.direction, 0.0f));

		for (int i = 0; i < indices.size() / 3; i++) {
			std::optional<glm::vec3> intersection = RayIntersectsTriangle({ ray_origin,ray_direction }, { vertices[indices[i * 3]].Position, vertices[indices[i * 3 + 1]].Position,vertices[indices[i * 3 + 2]].Position });
			if (intersection.has_value()) {
				return true;
			}
		}
		return false;
	}

	std::optional<std::vector<glm::vec3>> RayIntersectsMesh(const Ray& ray, Mesh* mesh)
	{
		//USE THIS AFTER A CHEAPER CHECK
		std::vector<glm::vec3> intersections = {};

		glm::mat4 inverse = glm::inverse(t.GetMatrix());
		glm::vec3 ray_origin = glm::vec3(inverse * glm::vec4(ray.origin, 1.0f));
		glm::vec3 ray_direction = glm::vec3(inverse * glm::vec4(ray.direction, 0.0f));


		std::map<float, IntersectionData> sorted;

		for (int i = 0; i < indices.size() / 3; i++) {
			std::optional<glm::vec3> intersection = RayIntersectsTriangle({ ray_origin,ray_direction }, { vertices[indices[i * 3]].Position, vertices[indices[i * 3 + 1]].Position,vertices[indices[i * 3 + 2]].Position });
			if (intersection.has_value()) {
				sorted[Magnitude2(intersection.value() - ray_origin)] = { intersection.value(),i };

				//intersections.push_back(intersection.value());
			}
		}

		if (intersections.size() > 0) return intersections;
		else return {};
	}

public:

private:

};

#endif