#include <shader.h> // Assuming this includes necessary OpenGL headers and defines Shader class
#include <fstream>
#include <sstream>
#include <iostream>

// Constructor for creating a shader program from various shader file paths
Shader::Shader(const char* vertexPath, const char* fragmentPath, const char* geometryPath,
	const char* TCSPath, const char* TESPath)
{
	// 1. Retrieve the shader source code from file paths
	std::string vertexCode;
	std::string fragmentCode;
	std::string geometryCode;
	std::string TCSCode;
	std::string TESCode;

	std::ifstream vShaderFile;
	std::ifstream fShaderFile;
	std::ifstream gShaderFile;
	std::ifstream tcsShaderFile;
	std::ifstream tesShaderFile;

	// Ensure ifstream objects can throw exceptions for robust file handling
	vShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
	fShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
	gShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
	tcsShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
	tesShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);

	try
	{
		// Open and read vertex and fragment shader files
		vShaderFile.open(vertexPath);
		fShaderFile.open(fragmentPath);
		std::stringstream vShaderStream, fShaderStream;
		vShaderStream << vShaderFile.rdbuf(); // Read file's buffer contents into streams
		fShaderStream << fShaderFile.rdbuf();
		vShaderFile.close();
		fShaderFile.close();
		vertexCode = vShaderStream.str(); // Convert streams to strings
		fragmentCode = fShaderStream.str();

		// Conditionally open and read geometry shader file
		if (geometryPath != nullptr)
		{
			gShaderFile.open(geometryPath);
			std::stringstream gShaderStream;
			gShaderStream << gShaderFile.rdbuf();
			gShaderFile.close();
			geometryCode = gShaderStream.str();
		}

		// Conditionally open and read Tessellation Control Shader file
		if (TCSPath != nullptr)
		{
			tcsShaderFile.open(TCSPath);
			std::stringstream tcsShaderStream;
			tcsShaderStream << tcsShaderFile.rdbuf();
			tcsShaderFile.close();
			TCSCode = tcsShaderStream.str();
		}

		// Conditionally open and read Tessellation Evaluation Shader file
		if (TESPath != nullptr)
		{
			tesShaderFile.open(TESPath);
			std::stringstream tesShaderStream;
			tesShaderStream << tesShaderFile.rdbuf();
			tesShaderFile.close();
			TESCode = tesShaderStream.str();
		}
	}
	catch (std::ifstream::failure e)
	{
		std::cout << "ERROR::SHADER::FILE_NOT_SUCCESFULLY_READ: " << e.what() << std::endl; // Added e.what() for more detail
	}
	// Get C-style strings for OpenGL API calls
	const char* vShaderCode = vertexCode.c_str();
	const char* fShaderCode = fragmentCode.c_str();
	const char* gShaderCode = geometryPath != nullptr ? geometryCode.c_str() : nullptr;
	const char* tcsShaderCode = TCSPath != nullptr ? TCSCode.c_str() : nullptr;
	const char* tesShaderCode = TESPath != nullptr ? TESCode.c_str() : nullptr;

	// 2. Compile shaders
	unsigned int vertex, fragment, geometry, tessControl, tessEval;

	// Vertex Shader
	vertex = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(vertex, 1, &vShaderCode, NULL);
	glCompileShader(vertex);
	checkCompileErrors(vertex, "VERTEX"); // Custom error checking function

	// Fragment Shader
	fragment = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(fragment, 1, &fShaderCode, NULL);
	glCompileShader(fragment);
	checkCompileErrors(fragment, "FRAGMENT");

	// Geometry Shader (if provided)
	if (geometryPath != nullptr)
	{
		geometry = glCreateShader(GL_GEOMETRY_SHADER);
		glShaderSource(geometry, 1, &gShaderCode, NULL);
		glCompileShader(geometry);
		checkCompileErrors(geometry, "GEOMETRY");
		std::cout << "Loaded Geometry Shader" << std::endl; // More descriptive message
	}

	// Tessellation Control Shader (if provided)
	if (TCSPath != nullptr)
	{
		tessControl = glCreateShader(GL_TESS_CONTROL_SHADER);
		glShaderSource(tessControl, 1, &tcsShaderCode, NULL);
		glCompileShader(tessControl);
		checkCompileErrors(tessControl, "TESS_CONTROL");
		std::cout << "Loaded Tessellation Control Shader" << std::endl;
	}

	// Tessellation Evaluation Shader (if provided)
	if (TESPath != nullptr)
	{
		tessEval = glCreateShader(GL_TESS_EVALUATION_SHADER);
		glShaderSource(tessEval, 1, &tesShaderCode, NULL);
		glCompileShader(tesEval);
		checkCompileErrors(tesEval, "TESS_EVALUATION");
		std::cout << "Loaded Tessellation Evaluation Shader" << std::endl;
	}

	// Create and link shader Program
	ID = glCreateProgram();
	glAttachShader(ID, vertex);
	glAttachShader(ID, fragment);
	if (geometryPath != nullptr) glAttachShader(ID, geometry);
	if (TCSPath != nullptr) glAttachShader(ID, tessControl);
	if (TESPath != nullptr) glAttachShader(ID, tessEval);
	glLinkProgram(ID);
	checkCompileErrors(ID, "PROGRAM"); // Custom error checking for linking

	// Clean up: delete individual shaders after linking
	glDeleteShader(vertex);
	glDeleteShader(fragment);
	if (geometryPath != nullptr) glDeleteShader(geometry);
	if (TCSPath != nullptr) glDeleteShader(tessControl);
	if (TESPath != nullptr) glDeleteShader(tessEval);
}