#include "GL/glew.h"

#include "RenderWindow.h"
#include "RenderDevice.h"
#include "FontManager.h"
#include "MeshManager.h"
#include "TextureManager.h"
#include "ShaderManager.h"
#include "ModelManager.h"
#include "TextureImage.h"
#include "ScriptSystem.h"
#include "ScriptSystem_Font.h"
#include "ScriptSystem_Image.h"
#include "ScriptSystem_Math.h"
#include "ScriptSystem_RigidBody.h"
#include "RigidBodySimulation.h"

#include "Camera.h"
#include "SceneNode.h"

#include "Utilities/CfgParser.h"
#include "Utilities/Log.h"
#include "Utilities/Kernel.h"

#include "physfs.h"

using namespace BlueCore;

void initializePhysfs(char* program)
{
	// setup physfs
	PHYSFS_init(program);

	std::string appdir = PHYSFS_getUserDir();
	appdir += ".bluecore";

	if ( !PHYSFS_setWriteDir(appdir.c_str()) )
	{
		if ( (PHYSFS_setWriteDir(PHYSFS_getUserDir()))
				&& (PHYSFS_mkdir(".bluecore")))
			PHYSFS_setWriteDir(appdir.c_str() );
	}

	PHYSFS_addToSearchPath(appdir.c_str(), 0);
	PHYSFS_addToSearchPath("data", 1);

	char **rc = PHYSFS_enumerateFiles("");

	for (char **i = rc; *i != 0; i++)
	{
		std::string filename( *i);

		if (filename.substr(filename.size() - 4, 4) == ".zip")
		{
			PHYSFS_addToSearchPath(( "data/" + filename ).c_str(), 1);
			clog << ">>> Using addon: "<< filename << endlog;
		}
	}

	PHYSFS_freeList(rc);
}

void shutdownPhysfs()
{
	PHYSFS_deinit();
}

class Application : public sigslot::has_slots<>
{
	bool _Running;
	double _DeltaTime;
	double _LastTime;

	void KeySlot(int key, int action)
	{
		if (key == GLFW_KEY_ESC && action == GLFW_RELEASE)
			quit();
	}

	ref_ptr<RenderWindow> _Window;
	ref_ptr<RenderDevice> _Device;
	ref_ptr<FontManager> _FontManager;
	ref_ptr<MeshManager> _MeshManager;
	ref_ptr<TextureManager> _TextureManager;
	ref_ptr<ScriptSystem> _ScriptSystem;
	ref_ptr<ShaderManager> _ShaderManager;
	ref_ptr<RigidBodySimulation> _Simulation;
	ref_ptr<ModelManager> _ModelManager;
	ref_ptr<Camera> _Camera;
	ref_ptr<RenderQueue> _RenderQueue;

public:

	bool initialize()
	{
		CfgParser cfg;
		cfg.parseFile("options.cfg");

		int width = cfg.get("width", 640);
		int height = cfg.get("height", 480);
		bool fullscreen = cfg.get("fullscreen", false);

		_Window = new RenderWindow();
		if (_Window->create(width, height, 0, 0, 0, fullscreen) == false)
			return false;

		_Device = new RenderDevice(_Window);
		_FontManager = new FontManager(_Device);
		_MeshManager = new MeshManager(_Device);
		_TextureManager = new TextureManager();
		_ScriptSystem = new ScriptSystem();
		_ShaderManager = new ShaderManager(_Window);
		_Simulation = new RigidBodySimulation(_ScriptSystem);
		_ModelManager = new ModelManager (_TextureManager, _ShaderManager, _MeshManager);
		_Camera = new Camera();
		_RenderQueue = new RenderQueue();

		setupScriptSystem_Font(_ScriptSystem, _FontManager);
		setupScriptSystem_Image(_ScriptSystem, _TextureManager, _Device);
		setupScriptSystem_Math(_ScriptSystem);
		setupScriptSystem_RigidBody(_ScriptSystem, _Simulation);

		_ScriptSystem->loadScript("main");
		_ScriptSystem->callFunction("Initialize");

		_Window->KeySignal.connect(this, &Application::KeySlot);
		
		_Running = true;
		
		return true;
	}
	/*
	 if (window.valid() && device.valid())
	 {

	 camera->setFoV(45.0);
	 camera->setAspectRatio((double)width/(double)height);
	 camera->setNearPlane(1.0);
	 camera->setFarPlane(15000.0);
	 camera->setPosition(Vector3(0.0, 0.0, 20.0));

	 device->setAmbientLight(1.0, 1.0, 1.0);

	 //ref_ptr<SceneNode> rootnode(new SceneNode("root node"));


	 ref_ptr<Model> model = modelmanager->loadModel("combat");

	 }
	 */

	void shutdown()
	{
		_ScriptSystem->callFunction("Shutdown");
	}

	void quit()
	{
		_Running = false;
	}

	void run()
	{
		clog << "--- starting main loop..."<< endlog;

		_DeltaTime = 0;
		_LastTime = glfwGetTime();

		while (_Window->isOpen() && _Running)
		{
			double time = glfwGetTime();
			_DeltaTime = time - _LastTime;
			_LastTime = time;

			_Device->clear();
			/*
			 camera->setRotation(Quaternion(Vector3(0.0, 1.0, 0.0), fmod(time
			 /5.0, 6.2)));
			 device->begin3D(camera);
			 queue->clear();
			 queue->addOpaqueItem(model, Vector3(10.0, 0.0, 0.0), Quaternion());
			 queue->render(device);

			 device->pushAbsoluteTransformation(Vector3(), camera->getRotation());

			 class RenderState
			 {
			 bool _Blending;
			 GLint _BlendFuncSrc;
			 GLint _BlendFuncDest;

			 bool _DepthTest;
			 bool _DepthMask;

			 bool _Lighting;
			 };
			 GLfloat mat_specular[] =
			 { 1.0, 1.0, 1.0, 1.0 };
			 GLfloat mat_shininess[] =
			 { 2.0 };
			 glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_specular);
			 glMaterialfv(GL_FRONT, GL_AMBIENT, mat_specular);
			 glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
			 glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);

			 glEnable(GL_BLEND);
			 glBlendFunc(GL_ONE, GL_ONE);
			 glEnable(GL_DEPTH_TEST);
			 glDepthMask(GL_FALSE);
			 glDisable(GL_LIGHTING);
			 glColor4d( 1.0f, 1.0f, 1.0f, 1.0f);

			 device->setTexture(0, starTexture, true);
			 starMesh->render();

			 glDisable(GL_BLEND);
			 device->popTransformation();
			 */
			// device->useShader (program);
			// device->setTexture (stage, name, texture)
			// device->clearTextures (stage+1);
			//glEnable (GL_TEXTURE_2D);
			//glEnable (GL_LIGHTING);
			//glBindTexture (GL_TEXTURE_2D, texture->getId() );

			// device->
			//device->
			//model->render();

			_Simulation->saveStates();
			_Simulation->updateSteps(_DeltaTime);
			while (_Simulation->step())
				;

			_ScriptSystem->callFunction("OnFrame", _DeltaTime);

			_Device->swap();
		}

		clog << "--- main loop finished..."<< endlog;
	}
};

int main(int argc, char **argv)
{
	initializePhysfs(argv[0]);

	Application app;

	if (app.initialize())
	{
		app.run();
	}
	app.shutdown();
	
	shutdownPhysfs();
}