/*
   render/render.cc
   This file is part of the Osirion project and is distributed under 
   the terms of the GNU General Public License version 2 
*/

#include <iostream>
#include <fstream>
#include <sstream>
#include <iomanip>

#include "auxiliary/functions.h"
#include "core/application.h"
#include "core/gameinterface.h"
#include "filesystem/filesystem.h"
#include "model/model.h"
#include "model/material.h"
#include "model/material.h"
#include "render/gl.h"
#include "render/state.h"
#include "render/dust.h"
#include "render/render.h"
#include "render/screenshot.h"
#include "render/textures.h"
#include "sys/sys.h"

namespace render {

core::Cvar *r_axis = 0;
core::Cvar *r_bbox = 0;
core::Cvar *r_grid = 0;
core::Cvar *r_particles = 0;
core::Cvar *r_radius = 0;
core::Cvar *r_sky = 0;
core::Cvar *r_wireframe = 0;
core::Cvar *r_mipmap = 0;
core::Cvar *r_collision = 0;
core::Cvar *r_normals = 0;
core::Cvar *r_normalize = 0;

void func_list_textures(std::string const &args)
{
	Textures::list();
}

void func_list_materials(std::string const &args)
{
	model::Material::list();
}

void func_list_particles(std::string const &args)
{
	ParticleScript::list();
}

void init(int width, int height) 
{
	con_print << "^BInitializing renderer..." << std::endl;

	con_print << "  renderer   ^B" << gl::renderer() << std::endl;
	con_print << "  vendor     ^B" << gl::vendor() << std::endl;
	con_print << "  version    ^B" << gl::version() << std::endl;

	// initialize render state
	State::init(width, height);

	// engine variables
	r_radius = core::Cvar::get("r_radius", "0", core::Cvar::Archive);
	r_radius->set_info("[bool] render entity radius");

	r_wireframe = core::Cvar::get("r_wireframe", "0", core::Cvar::Archive);
	r_wireframe->set_info("[bool] render wireframe");

	r_normals = core::Cvar::get("r_normals", "0", core::Cvar::Archive);
	r_normals->set_info("[bool] render face normals");

	r_normalize = core::Cvar::get("r_normalize", "0", core::Cvar::Archive);
	r_normalize->set_info("[bool] use GL_NORMALIZE instead of GL_RESCALE_NORMAL  (recommended off)");

	r_grid = core::Cvar::get("r_grid", "0", core::Cvar::Archive);
	r_grid->set_info("[bool] render the space grid");

	r_axis = core::Cvar::get("r_axis", "0", core::Cvar::Archive);
	r_axis->set_info("[bool] render entity axis");

	r_bbox = core::Cvar::get("r_bbox", "0", core::Cvar::Archive);
	r_bbox->set_info("[bool] render model bounding box");

	r_sky = core::Cvar::get("r_sky", "1", core::Cvar::Archive);
	r_sky->set_info("[bool] render the sky globe");

	r_particles = core::Cvar::get("r_particles", "1", core::Cvar::Archive);
	r_particles->set_info("[bool] render particles");
	/*
	r_collision = core::Cvar::get("r_collision", "1", core::Cvar::Archive);
	r_collision->set_info("[bool] render collision (server side only)");
	*/
	Screenshot::screenshotformat = core::Cvar::get("screenshotformat", "jpg", core::Cvar::Archive);
	Screenshot::screenshotformat->set_info("[string] screenshot format: jpg png tga");

	Screenshot::screenshotquality = core::Cvar::get("screenshotquality", "85", core::Cvar::Archive);
	Screenshot::screenshotquality->set_info("[int] screenshot jpg quality");

	// hardware generate mipmaps
	r_mipmap = core::Cvar::get("r_mipmap", "1", core::Cvar::Archive);
	r_mipmap->set_info("[bool] use hardware generated mipmaps (recommended on)");
	if (!State::has_generate_mipmaps()) {
		con_print << "  no hardware generated mipmap support" << std::endl;
		(*r_mipmap) = 0.0f;
	}

	Camera::init();

	Textures::init();

	Text::init();

	Dust::init();

	// read materials
	model::Material::init();

	// engine functions
	core::Func *func = core::Func::add("list_textures", func_list_textures);
	func->set_info("list registered textures");

	func = core::Func::add("list_materials", func_list_materials);
	func->set_info("list registered materials");


	func = core::Func::add("list_particles", func_list_particles);
	func->set_info("list registered particle scripts");

	load();
}

// unload game assets (zone change)
void unload()
{
	// clear zone sky textures
	for (core::Zone::Registry::iterator it = core::Zone::registry().begin(); it != core::Zone::registry().end(); it++) {
		core::Zone *zone = (*it).second;
		if (zone->sky_texture()) {
			render::Textures::unload(zone->sky_texture());
			zone->set_sky_texture(0);
		}
	}

	for (core::Entity::Registry::iterator it = core::Entity::registry().begin(); it != core::Entity::registry().end(); it++) {
		core:: Entity *entity = (*it).second;
	
		if (entity->type() == core::Entity::Globe) { 		
			core::EntityGlobe *globe = static_cast<core::EntityGlobe *>(entity);
			if (globe->render_texture) {
				render::Textures::unload(globe->render_texture);
				globe->render_texture = 0;
			}
		}

		if (ext_render(entity)) {
			delete ext_render(entity);
		}
	}
}

// clear all assets
void clear()
{
	// clear zone sky textures
	for (core::Zone::Registry::iterator it = core::Zone::registry().begin(); it != core::Zone::registry().end(); it++) {
		core::Zone *zone = (*it).second;
		zone->set_sky_texture(0);
	}

	// clear entity models, and globe textures, this will force a reload
	for (core::Entity::Registry::iterator it = core::Entity::registry().begin(); it != core::Entity::registry().end(); it++) {
		core::Entity *entity = (*it).second;

		if (entity->model())
			entity->set_model(0);

		if (entity->type() == core::Entity::Globe) { 
			core::EntityGlobe *globe = static_cast<core::EntityGlobe *>(entity);
			globe->render_texture = 0;
		}

		if (ext_render(entity)) {
			delete ext_render(entity);
		}
	}

	// clear model registry
	model::Model::clear();

	// clear materials
	model::Material::clear();

	// clear particle system scripts
	ParticleScript::clear();
}

// load assets
void load()
{
	// load entity models
	for (core::Entity::Registry::iterator it = core::Entity::registry().begin(); it != core::Entity::registry().end(); it++) {
		core::Entity *entity = (*it).second;

		if (entity->modelname().size()) {
			entity->set_model(model::Model::load(entity->modelname()));
		}
	}

	// load info models
	for (core::Info::Registry::iterator it = core::Info::registry().begin(); it != core::Info::registry().end(); it++) {
		core::Info *info = (*it).second;
		if (info->modelname().size()) {
			model::Model::load(info->modelname());
		}
	}
}

// reset render subsystem (module disconnect)
void reset()
{
	clear();

	State::clear();

	Textures::shutdown();

	Textures::init();

	Dust::reset();

	model::Material::init();
}

void resize(int width, int height)
{
	State::resize(width, height);
}

void shutdown()
{
	con_print << "^BShutting down renderer..." << std::endl;

	core::Func::remove("list_materials");
	core::Func::remove("list_particles");
	core::Func::remove("list_textures");

	clear();

	Text::shutdown();

	Textures::shutdown();

	Camera::shutdown();

	Dust::shutdown();

	State::shutdown();
}

} // namespace render