#include "..\..\Engine\Engine\Engine.h"
#include "Options.h"
#include "misc.h"
#include "Editor.h"
#include "Animator.h"
#include "ParticleEditor.h"
using namespace std;

Math math;
Options options;
ParticleEditor ped;
GameWorld* world = NULL;
MapLoader* loader = NULL;
Editor *editor = NULL;
Animator *animator = NULL;
bool console_state = false;
GUI_Element* gui_test = NULL;

//////////////////// INIT //
////////////////////////////

bool game_preload()
{
	//load game settings - ako ne uspije koriste se default vrijednosti
	options.log = g_engine->GetLog();
	options.Load();
	g_engine->setFullscreen(options.fullscreen);
	g_engine->v_sync = options.vsync;
	g_engine->SetScreenW(options.screen_w);
	g_engine->SetScreenH(options.screen_h);
	if(options.lockframerate==0) g_engine->framerate_lock = false;
	else
	{
		g_engine->framerate_lock = true;
		g_engine->framerate_set = options.lockframerate;
	}
	g_engine->setAppTitle("Game");
	g_engine->setColorDepth(32);
	return true;
}

void Menu(std::string path)
{
	g_engine->gui->ClearAll();
	XML_ParserGUI xml_parsergui;
	GUI_Element* tmp = xml_parsergui.BuildGUI(path);
	if(tmp)
	{
		g_engine->gui->AddLayout(tmp);
		((GUI_Layout*)tmp)->setPosition(g_engine->GetScreenW()/2-tmp->getWidth()/2,g_engine->GetScreenH()/2-tmp->getHeight()/2);
		((GUI_Layout*)tmp)->Refresh();
	}
	else
	{
		g_engine->GetLog()->Write("#ERROR#MENU: Failed to create menu \"" + path + "\"!");
		g_engine->gui->AddNotification("Failed to create menu \"" + path + "\"!");
	}
	loader->state = GAME;
	g_engine->setState(GAME);
	g_engine->setGameState(MENU);
}

bool game_init(HWND)
{
	g_engine->GetLog()->Write("ENGINE: Loading game assets...");
	g_engine->GetLog()->Save();

	//GAME ASSETS
	if(!g_engine->LoadGameAssets("Data/game_assets.txt")) return false;

	//WORLD
	world = new GameWorld();
	world->Init(g_engine->GetLog(),g_engine->audio,g_engine->texture_m,g_engine->font_m,g_engine->skeleton_m,g_engine->animation_m);
	world->graphics = g_engine->ar_graphics;
	world->input = g_engine->input->GetInputState();
	world->screen_w = g_engine->GetScreenW();
	world->screen_h = g_engine->GetScreenH();
	world->ms = new MapSave(g_engine->texture_m,g_engine->animation_m,g_engine->pm);

	//MAP LOADER
	loader = new MapLoader();
	loader->Init(g_engine->GetLog(),new MapSave(g_engine->texture_m,g_engine->animation_m,g_engine->pm),world);
	loader->animations = g_engine->animation_m;
	loader->skeletons = g_engine->skeleton_m;
	loader->textures = g_engine->texture_m;
	loader->audio = g_engine->audio;
	loader->screen_w = g_engine->GetScreenW();
	loader->screen_h = g_engine->GetScreenH();
	if(!loader->MapList_Load()) return false;
	if(!loader->MapList_Save()) return false;

	//OPTIONS
	options.log = g_engine->GetLog();
	options.gui = g_engine->gui;
	g_engine->audio->setVolumeSound((float)options.volume_sound/100);
	g_engine->audio->setVolumeStream((float)options.volume_music/100);

	//EDITOR
	editor = new Editor(g_engine->input->GetInputState(),g_engine->gui,g_engine->font_m,(float)g_engine->GetScreenW(),(float)g_engine->GetScreenH());
	editor->log = g_engine->GetLog();
	editor->ar_graphics = g_engine->ar_graphics;
	editor->pm = g_engine->pm;
	editor->world = world;
	editor->loader = loader;
	editor->animations = g_engine->animation_m;
	editor->skeletons = g_engine->skeleton_m;
	editor->textures = g_engine->texture_m;
	editor->audio = g_engine->audio;
	if(!editor->Init()) return false;

	//MODELER
	animator = new Animator(g_engine->input->GetInputState(),g_engine->gui,g_engine->font_m,g_engine->animation_m,g_engine->skeleton_m,(float)g_engine->GetScreenW(),(float)g_engine->GetScreenH());
	animator->log = g_engine->GetLog();

	//particle editor
	ped.log = g_engine->GetLog();
	ped.gui = g_engine->gui;
	ped.pm = g_engine->pm;
	ped.texture_m = g_engine->texture_m;
	ped.screen_w = (float)g_engine->GetScreenW();
	ped.screen_h = (float)g_engine->GetScreenH();
	ParticleEmitter* pem = new ParticleEmitter();
	ped.pem = pem;
	ped.pem->x = ped.screen_w/2;
	ped.pem->y = ped.screen_h/2;
	ped.pem->e_texture = g_engine->gui->tx_default;
	for(int i=0;i<100;i++) ped.pem->AddParticle();

	//MENU
	Menu("Gui/menu_main.xml");

	return true;
}

//////////  UPDATE  //
//////////////////////

void game_update()
{
	int screen_w = g_engine->GetScreenW();
	int screen_h = g_engine->GetScreenH();

	if(g_engine->getState()==EDITOR)			editor->Update(g_engine->getRenderType(),g_engine->getDeltaFix());
	else if(g_engine->getState()==ANIMATOR)		animator->Update();
	else if(g_engine->getState()==PARTICLES)	ped.Update(g_engine->getDeltaFix());
	else if(g_engine->getState()==GAME)			world->Update(g_engine->getGameState(),g_engine->getRenderType(),g_engine->getPaused(),g_engine->getDeltaFix());

	//gui, hud i konzola
	g_engine->ar_graphics->ogl_2d.Render2D(0,0,screen_w,screen_h,1);
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
	if(g_engine->getState()==GAME && world->players[0]->p_player)
	{
		world->players[0]->hud->Draw(
			world->players[0]->p_player->energy,
			world->players[0]->armor,
			world->players[0]->player_weapon,
			g_engine->getDeltaFix());
	}
	g_engine->gui->DrawGUI();
	g_engine->gui->DrawCursor();

	if(console_state)
	{
		g_engine->ar_graphics->ogl_2d.DrawTexture(
			g_engine->gui->tx_default->GetTexture(),
			0,0,(float)screen_w,(float)screen_h,
			0,0,g_engine->gui->tx_default->GetWidth(),g_engine->gui->tx_default->GetHeight(),
			1,1,0,false,0xaa000000,0,0);
		ShowConsole();
	}
}

void game_spriteUpdate(Sprite* b)
{
	world->SpriteUpdate(b);
}

bool B2D_SpriteCollision(Sprite* a, Sprite* b)
{
	return world->SpriteCollision(a,b);
}

void game_spriteErase(Sprite* a)
{
	world->SpriteErase(a);
}

void game_end(){}

void game_spritePostRender(Sprite *a)
{
	if(g_engine->getState()==EDITOR || g_engine->getState()==GAME) editor->SpritePostRender(a);
}

////////////////////  GUI CONTROLS  //
//////////////////////////////////////

void GUI_MousePress(GUI_Element* b, int bttn)
{
	if(g_engine->getState()==ANIMATOR)		{animator->GUI_MousePress(b,bttn);return;}
	if(g_engine->getState()==EDITOR)		{editor->GUI_MousePress(b,bttn);return;}
	else if(g_engine->getState()==OPTIONS)	{options.GUI_MousePress(b,bttn);return;}
}

void GUI_MouseRelease(GUI_Element* b, int bttn)
{
	if(g_engine->getState()==PARTICLES)
	{
		ped.GUI_MouseRelease(b,bttn);
		return;
	}
	else if(g_engine->getState()==ANIMATOR)
	{
		if(b->getID()=="menubarA_close") {animator->End();Menu("Gui/menu_main.xml");}
		else animator->GUI_MouseRelease(b,bttn);
		return;
	}
	else if(g_engine->getState()==EDITOR)
	{
		if(b->getID()=="menubarE_close") {editor->End();Menu("Gui/menu_main.xml");}
		else editor->GUI_MouseRelease(b,bttn);
		return;
	}
	else if(g_engine->getState()==OPTIONS)
	{
		if(b->getID()=="options_close") {options.Save();options.root = NULL;Menu("Gui/menu_main.xml");}
		else options.GUI_MouseRelease(b,bttn);
		return;
	}
	else if(g_engine->getState()==GAME)
	{
		if(g_engine->getGameState()==MENU)
		{
			//main
			if(b->getID()=="mm_newgame") Menu("Gui/menu_newgame.xml");
			else if(b->getID()=="mm_options")
			{
				g_engine->gui->ClearAll();
				g_engine->setState(OPTIONS);
				options.Menu_LoadLayout();
			}
			else if(b->getID()=="mm_quit") g_engine->Close();
			//new game
			else if(b->getID()=="mm_campaign")
			{
				g_engine->gui->ClearAll();
				g_engine->setState(GAME);
				g_engine->setGameState(PLAY);
				world->mapm->DeleteAll();
				world->mapm->mapc = -1;
				loader->LoadCampaign("Data/Maps/campaign.txt",1,world->mapm,g_engine->GetScreenW(),g_engine->GetScreenH());
				world->mapm->mapc = 0;
			}
			else if(b->getID()=="mm_custom") editor->Map_LoadButtons(loader->map_list,b->getX()+b->getWidth(),b->getY(),"load");
			else if(b->getID()=="map_edit")
			{
				g_engine->gui->ClearAll();
				g_engine->setState(GAME);
				g_engine->setGameState(PLAY);
				world->mapm->DeleteAll();
				world->mapm->mapc = -1;
				loader->LoadMap(((GUI_Button*)b)->getText(),1,world->mapm,g_engine->GetScreenW(),g_engine->GetScreenH());
				world->mapm->mapc = 0;
			}
			else if(b->getID()=="mm_easy")		world->difficulty = 0;
			else if(b->getID()=="mm_normal")	world->difficulty = 1;
			else if(b->getID()=="mm_hard")		world->difficulty = 2;
			else if(b->getID()=="mm_back")		Menu("Gui/menu_main.xml");
			return;
		}
	}
}

void GUI_EdittextEnter(GUI_Textbox* b)
{
	if(g_engine->getState()==PARTICLES)		ped.GUI_EdittextEnter(b);
	else if(g_engine->getState()==ANIMATOR) animator->GUI_EdittextEnter(b);
	else if(g_engine->getState()==EDITOR)	editor->GUI_EdittextEnter(b);
	else if(g_engine->getState()==OPTIONS)	options.GUI_EdittextEnter(b);
}

bool GUI_RenderPost(GUI_Element* b)
{
	if(g_engine->getState()==ANIMATOR)		return animator->GUI_RenderPost(b);
	else if(g_engine->getState()==EDITOR)	return editor->GUI_RenderPost(b);
	return false;
}

bool GUI_RenderHoverOver(GUI_Element* b)
{
	if(g_engine->getState()==ANIMATOR)		return animator->GUI_RenderHoverOver(b);
	else if(g_engine->getState()==EDITOR)	return editor->GUI_RenderHoverOver(b);
	return false;
}

bool GUI_RenderHoverOver2(GUI_Element* b)
{
	if(g_engine->getState()==ANIMATOR)		return animator->GUI_RenderHoverOver2(b);
	else if(g_engine->getState()==EDITOR)	return editor->GUI_RenderHoverOver2(b);
	return false;
}

bool GUI_RenderPress(GUI_Element* b, int key)
{
	if(g_engine->getState()==ANIMATOR)		return animator->GUI_RenderPress(b,key);
	else if(g_engine->getState()==EDITOR)	return editor->GUI_RenderPress(b,key);
	return false;
}

bool GUI_RenderPress2(GUI_Element* b, int key)
{
	if(g_engine->getState()==ANIMATOR)		return animator->GUI_RenderPress2(b,key);
	else if(g_engine->getState()==EDITOR)	return editor->GUI_RenderPress2(b,key);
	return false;
}

void GUI_Bury(GUI_Element *b)
{
	if(g_engine->getState()==ANIMATOR)			animator->GUI_Bury(b);
	else if(g_engine->getState()==EDITOR)		editor->GUI_Bury(b);
	else if(g_engine->getState()==PARTICLES)	ped.GUI_Bury(b);
}

//////////////////// INPUT //
/////////////////////////////

void SDL_KeyPress(int key)
{
	if(g_engine->getState()==ANIMATOR)		animator->KeyPress(key);
	else if(g_engine->getState()==EDITOR)	editor->KeyPress(key);
	else if(g_engine->getState()==GAME)		world->KeyPress(key);
}

void SDL_KeyRelease(int key)
{
	//global
	switch(key)
	{
	case SDLK_F10://activate particle editor
		if(g_engine->input->GetInputState()->getKeyState(SDLK_RCTRL))
		{
			g_engine->gui->ClearAll();
			world->mapm->DeleteAll();
			g_engine->setState(PARTICLES);
			ped.Begin();
		}
		break;

	case SDLK_F11://activate animation editor
		if(g_engine->input->GetInputState()->getKeyState(SDLK_RCTRL))
		{
			g_engine->gui->ClearAll();
			world->mapm->DeleteAll();
			g_engine->setState(ANIMATOR);
			animator->Begin();
		}
		else g_engine->setRenderType(g_engine->getRenderType()+1);//toggle render mode
		break;

	case SDLK_F12://activate map editor
		if(g_engine->input->GetInputState()->getKeyState(SDLK_RCTRL))
		{
			g_engine->gui->ClearAll();
			world->mapm->DeleteAll();
			g_engine->setState(EDITOR);
			loader->state = EDITOR;
			editor->Begin();
		}
		else console_state = !console_state;//toggle console
		break;

	case SDLK_F9:
		{
			if(gui_test)
			{
				gui_test->setAlive(false);
				gui_test = NULL;
			}

			XML_ParserGUI xml_parsergui;
			gui_test = xml_parsergui.BuildGUI("gui_test.xml");
			if(gui_test)
			{
				g_engine->gui->AddLayout(gui_test);
				((GUI_Layout*)gui_test)->setPosition(0,0);
				((GUI_Layout*)gui_test)->Refresh();
			}
			else g_engine->audio->Play("BLASTF1A");
		}
		break;
	}

	if(g_engine->getState()==ANIMATOR) animator->KeyRelease(key);
	else if(g_engine->getState()==EDITOR)
	{
		if(key==SDLK_F7 && editor->GetSelectedSprite()) world->ToRagdoll(editor->GetSelectedSprite(),editor->map);
		else if(key==SDLK_PAGEUP) editor->b2d_enabled = !editor->b2d_enabled;
		editor->KeyRelease(key);
		return;
	}
	else if(g_engine->getState()==GAME)
	{
		world->KeyRelease(key);
		switch(key)
		{
		case SDLK_p:
			if(world->state_game==PLAY)
				world->pause = !world->pause;
			break;

		case SDLK_ESCAPE:
			world->pause = false;
			world->bullet_time = false;
			g_engine->audio->StopAll();
			for(unsigned int i=0;i<world->players.size();i++)
			{
				if(world->players[i]->p_player) world->DeletePlayer(world->players[i]->p_player->getID());
				world->players[i]->active = false;
			}
			world->mapm->DeleteAll();
			Menu("Gui/menu_main.xml");
			break;
		}
	}
}

//b2d
//ne radi kako treba unutar klase
void MouseDown(float x, float y)
{
	if(!editor->map) return;
	if(editor->map->mousejoint) return;

	b2Vec2 p(editor->GetCurX_ZO()*P2M,editor->GetCurY_ZO()*P2M);

	// Make a small box.
	b2AABB aabb;
	b2Vec2 d;
	d.Set(0.001f, 0.001f);
	aabb.lowerBound = p - d;
	aabb.upperBound = p + d;

	// Query the world for overlapping shapes.
	QueryCallback callback(p);
	editor->map->world->QueryAABB(&callback, aabb);

	if (callback.m_fixture)
	{
		b2Body* body = callback.m_fixture->GetBody();
		b2MouseJointDef md;
		md.bodyA = editor->map->groundbody;
		md.bodyB = body;
		md.target = p;
		md.maxForce = 1000.0f * body->GetMass();
		editor->map->mousejoint = (b2MouseJoint*)editor->map->world->CreateJoint(&md);
		body->SetAwake(true);
	}
}

void MouseUp()
{
	if(!editor->map) return;
	if(!editor->map->mousejoint) return;

	editor->map->world->DestroyJoint(editor->map->mousejoint);
	editor->map->mousejoint = NULL;
}

void MouseMove(float x, float y)
{
	if(!editor->map) return;
	if(!editor->map->mousejoint) return;

	b2Vec2 p(editor->GetCurX_ZO()*P2M,editor->GetCurY_ZO()*P2M);
	if(editor->map->mousejoint) editor->map->mousejoint->SetTarget(p);
}

void SDL_MousePress(int bttn)
{
	if(g_engine->getState()==PARTICLES)
	{
		ped.pem->x = (float)g_engine->input->GetInputState()->mouse_x;
		ped.pem->y = (float)g_engine->input->GetInputState()->mouse_y;
	}
	else if(g_engine->getState()==ANIMATOR) animator->MousePress(bttn);
	else if(g_engine->getState()==EDITOR)
	{
		MouseDown(editor->GetCurX_ZO(),editor->GetCurY_ZO());
		editor->MousePress(bttn);
	}
	else if(g_engine->getState()==GAME) world->MousePress(bttn);
}

void SDL_MouseRelease(int bttn)
{
	if(g_engine->getState()==ANIMATOR) animator->MouseRelease(bttn);
	else if(g_engine->getState()==EDITOR)
	{
		MouseUp();
		editor->MouseRelease(bttn);
	}
	else if(g_engine->getState()==GAME) world->MouseRelease(bttn);
}

void SDL_MouseWheel(int wheel)
{
	if(g_engine->getState()==PARTICLES)		ped.MouseWheel(wheel);
	else if(g_engine->getState()==ANIMATOR) animator->MouseWheel(wheel);
	else if(g_engine->getState()==EDITOR)	editor->MouseWheel(wheel);
	else if(g_engine->getState()==GAME)		world->MouseWheel(wheel);
}

void SDL_MouseMotion(int x, int y, int delta_x, int delta_y)
{
	MouseMove((float)x,(float)y);
}