#include <GL/glew.h>
#include "Texture.h"
#include "Renderer.h"
#include "Image.h"


//======================================================================================================================
// Statics                                                                                                             =
//======================================================================================================================
int Texture::textureUnitsNum = -1;
bool Texture::mipmappingEnabled = true;
bool Texture::compressionEnabled = false;
int Texture::anisotropyLevel = 8;


//======================================================================================================================
// Constructor                                                                                                         =
//======================================================================================================================
Texture::Texture():
	glId(numeric_limits<uint>::max()),
	target(GL_TEXTURE_2D)
{
}


//======================================================================================================================
// load                                                                                                                =
//======================================================================================================================
bool Texture::load(const char* filename)
{
	target = GL_TEXTURE_2D;
	if(glId != numeric_limits<uint>::max())
	{
		ERROR("Texture already loaded");
		return false;
	}

	Image img;
	if(!img.load(filename)) return false;


	// bind the texture
	glGenTextures(1, &glId);
	bind(0);
	if(mipmappingEnabled)
	{
		setTexParameter(GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
	}
	else
	{
		setTexParameter(GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	}

	setTexParameter(GL_TEXTURE_MAG_FILTER, GL_LINEAR);

	texParameter(GL_TEXTURE_MAX_ANISOTROPY_EXT, float(anisotropyLevel));

	// leave to GL_REPEAT. There is not real performance impact
	setRepeat(true);

	int format = (img.bpp==32) ? GL_RGBA : GL_RGB;

	int intFormat; // the internal format of the image
	if(compressionEnabled)
	{
		//int_format = (img.bpp==32) ? GL_COMPRESSED_RGBA_S3TC_DXT1_EXT : GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
		intFormat = (img.bpp==32) ? GL_COMPRESSED_RGBA : GL_COMPRESSED_RGB;
	}
	else
	{
		intFormat = (img.bpp==32) ? GL_RGBA : GL_RGB;
	}

	glTexImage2D(target, 0, intFormat, img.width, img.height, 0, format, GL_UNSIGNED_BYTE, img.data);
	if(mipmappingEnabled)
	{
		glGenerateMipmap(target);
	}

	img.unload();
	return true;
}


//======================================================================================================================
// createEmpty2D                                                                                                       =
//======================================================================================================================
bool Texture::createEmpty2D(float width_, float height_, int internalFormat, int format_, GLenum type_,
                             bool mimapping)
{
	DEBUG_ERR(glGetError() != GL_NO_ERROR); // dont enter the func with prev error

	target = GL_TEXTURE_2D;
	DEBUG_ERR(internalFormat>0 && internalFormat<=4); // deprecated internal format
	DEBUG_ERR(glId != numeric_limits<uint>::max()); // Texture already loaded

	// GL stuff
	glGenTextures(1, &glId);
	bind();

	if(mimapping)
		setTexParameter(GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
	else
		setTexParameter(GL_TEXTURE_MIN_FILTER, GL_LINEAR);

	setTexParameter(GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	setRepeat(true);


	// allocate to vram
	glTexImage2D(target, 0, internalFormat, width_, height_, 0, format_, type_, NULL);

	if(mimapping)
		glGenerateMipmap(target);

	GLenum errid = glGetError();
	if(errid != GL_NO_ERROR)
	{
		ERROR("OpenGL Error: " << gluErrorString(errid));
		return false;
	}
	return true;
}


//======================================================================================================================
// createEmpty2DMSAA                                                                                                   =
//======================================================================================================================
bool Texture::createEmpty2DMSAA(float width, float height, int samples_num, int internal_format)
{
	/*type = GL_TEXTURE_2D_MULTISAMPLE;
	DEBUG_ERR(internal_format>0 && internal_format<=4); // deprecated internal format
	DEBUG_ERR(glId != numeric_limits<uint>::max()) // Texture already loaded

	glGenTextures(1, &glId);
	bind();
	
	// allocate
	glTexImage2DMultisample(type, samples_num, internal_format, width, height, false);*/
	return true;
}


//======================================================================================================================
// unload                                                                                                              =
//======================================================================================================================
void Texture::unload()
{
	glDeleteTextures(1, &glId);
}


//======================================================================================================================
// bind                                                                                                                =
//======================================================================================================================
void Texture::bind(uint unit) const
{
	if(unit >= static_cast<uint>(textureUnitsNum))
		WARNING("Max tex units passed");

	glActiveTexture(GL_TEXTURE0+unit);
	glBindTexture(target, glId);
}


//======================================================================================================================
// getWidth                                                                                                            =
//======================================================================================================================
int Texture::getWidth() const
{
	bind();
	int i;
	glGetTexLevelParameteriv(target, 0, GL_TEXTURE_WIDTH, &i);
	return i;
}


//======================================================================================================================
// getHeight                                                                                                           =
//======================================================================================================================
int Texture::getHeight() const
{
	bind();
	int i;
	glGetTexLevelParameteriv(target, 0, GL_TEXTURE_HEIGHT, &i);
	return i;
}


//======================================================================================================================
// setTexParameter [int]                                                                                                  =
//======================================================================================================================
void Texture::setTexParameter(GLenum paramName, GLint value) const
{
	bind();
	glTexParameteri(target, paramName, value);
}


//======================================================================================================================
// setTexParameter [float]                                                                                                =
//======================================================================================================================
void Texture::texParameter(GLenum paramName, GLfloat value) const
{
	bind();
	glTexParameterf(target, paramName, value);
}