// ==============================================================
//	This file is part of Glest Shared Library (www.glest.org)
//
//	Copyright (C) 2001-2008 Martiño Figueroa
//
//	You can redistribute this code and/or modify it under
//	the terms of the GNU General Public License as published
//	by the Free Software Foundation; either version 2 of the
//	License, or (at your option) any later version
// ==============================================================

#include "texture_manager.h"

#include <cstdlib>
#include <stdexcept>

#include "graphics_interface.h"
#include "graphics_factory.h"

#include "util.h"
#include "platform_util.h"
#include "leak_dumper.h"

using namespace Shared::Util;
using namespace Shared::Platform;

namespace Shared{ namespace Graphics{

// =====================================================
//	class TextureManager
// =====================================================

TextureManager::TextureManager() {
	if(GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
		throw megaglest_runtime_error("Loading graphics in headless server mode not allowed!");
	}


	textureFilter= Texture::fBilinear;
	maxAnisotropy= 1;
}

TextureManager::~TextureManager(){
	end();
}

void TextureManager::initTexture(Texture *texture) {
	if(texture != NULL) {
		texture->init(textureFilter, maxAnisotropy);
	}
}

void TextureManager::endTexture(Texture *texture,bool mustExistInList) {
	if(texture != NULL) {
		bool found = false;
		for(unsigned int idx = 0; idx < textures.size(); idx++) {
			Texture *curTexture = textures[idx];
			if(curTexture == texture) {
				found = true;
				textures.erase(textures.begin() + idx);
				break;
			}
		}
		if(found == false && mustExistInList == true) {
			throw std::runtime_error("found == false in endTexture");
		}
		texture->end();
		delete texture;
	}
}

void TextureManager::endLastTexture(bool mustExistInList) {
	bool found = false;
	if(textures.size() > 0) {
		found = true;
		int index = (int)textures.size()-1;
		Texture *curTexture = textures[index];
		textures.erase(textures.begin() + index);

		curTexture->end();
		delete curTexture;
	}
	if(found == false && mustExistInList == true) {
		throw std::runtime_error("found == false in endLastTexture");
	}
}

void TextureManager::init(bool forceInit) {
	for(unsigned int i=0; i<textures.size(); ++i){
		Texture *texture = textures[i];
		if(texture == NULL) {
			throw std::runtime_error("texture == NULL during init");
		}
		if(forceInit == true) {
			texture->reseInitState();
		}
		if(forceInit == true) {
			texture->end(false);
		}
		texture->init(textureFilter, maxAnisotropy);
	}
}

void TextureManager::end(){
	for(unsigned int i=0; i<textures.size(); ++i){
		if(textures[i] != NULL) {
			textures[i]->end();
			delete textures[i];
		}
	}
	textures.clear();
}

void TextureManager::setFilter(Texture::Filter textureFilter){
	this->textureFilter= textureFilter;
}

void TextureManager::setMaxAnisotropy(int maxAnisotropy){
	this->maxAnisotropy= maxAnisotropy;
}

Texture *TextureManager::getTexture(const string &path){
	for(unsigned int i=0; i<textures.size(); ++i){
		if(textures[i]->getPath()==path){
			return textures[i];
		}
	}
	return NULL;
}

Texture1D *TextureManager::newTexture1D(){
	Texture1D *texture1D= GraphicsInterface::getInstance().getFactory()->newTexture1D();
	textures.push_back(texture1D);

	return texture1D;
}

Texture2D *TextureManager::newTexture2D(){
	Texture2D *texture2D= GraphicsInterface::getInstance().getFactory()->newTexture2D();
	textures.push_back(texture2D);

	return texture2D;
}

Texture3D *TextureManager::newTexture3D(){
	Texture3D *texture3D= GraphicsInterface::getInstance().getFactory()->newTexture3D();
	textures.push_back(texture3D);

	return texture3D;
}


TextureCube *TextureManager::newTextureCube(){
	TextureCube *textureCube= GraphicsInterface::getInstance().getFactory()->newTextureCube();
	textures.push_back(textureCube);

	return textureCube;
}

}}//end namespace