/*
 * World
 */

#include "World.h"
#include "VertexTypes.h"
#include "GuiLabel.h"
#include "GuiImage.h"
#include "GuiButton.h"

/*
 * World
 */
World::World()
{
	nWorldState			= WorldState_Main;
	nLogicState			= LogicState_LevelLoad;
	nSimulationState	= SimulationState_Idle;
	nCurrentLevel		= 0;
}

/*
 * Initialize
 */
ErrorCode World::Initialize(ResourceManager* pResourceManager, InputManager* pInput)
{
	//ASSERT(pResourceManager != NULL);
	//ASSERT(pInput != NULL);

	ErrorCode eCode = kEnvironment.Initialize(pResourceManager);
	if(eCode != Error_Success)
	{
		TRACE("Error: Failed to initialize environment\n");

		Terminate();
		return eCode;
	}

	eCode = kBot.Initialize(pResourceManager);
	if(eCode != Error_Success)
	{
		TRACE("Error: Failed to initialize bot\n");

		Terminate();
		return eCode;
	}

	eCode = kProgram.Initialize();
	if(eCode == Error_Success)
	{
		TRACE("Error: Failed to initialize program\n");

		Terminate();
		return eCode;
	}

	eCode = InitializeInterface(pResourceManager);				
	if(eCode != Error_Success)
	{
		TRACE("Error: Failed to initialize interface\n");

		Terminate();
		return eCode;
	}

	pInputManager	= pInput;
	nLogicState		= LogicState_LevelLoad;
	nCurrentLevel	= 0;

	return eCode;
}

/*
 * Terminate
 */
void World::Terminate()
{
	kInterface.Terminate();
	kProgram.Terminate();
	kBot.Terminate();
	kEnvironment.Terminate();
}

/*
 * Activate
 */
void World::Activate()
{
	nWorldState	= WorldState_Game;
	nLogicState	= LogicState_LevelLoad;
}

/*
 * Deactivate
 */
void World::Deactivate()
{
	nWorldState = WorldState_Exit;
}

/*
 * IsActive
 */
bool World::IsActive()
{
	return nWorldState != WorldState_Exit;
}

/*
 * Load
 */
ErrorCode World::Load(const char* pName)
{
	ErrorCode eCode = kLoader.Load(pName);
	if(eCode == Error_Success)
	{
		const Size& kSize = kLoader.GetSize();

		eCode = kEnvironment.Setup(kSize.X, kSize.Y);
		if(eCode == Error_Success)
		{
			for(uint32 nY = 0; nY < kSize.Y; ++nY)
			{
				for(uint32 nX = 0; nX < kSize.X; ++nX)
				{
					kEnvironment.SetType(nX, nY, kLoader.GetTowerType(nX, nY));
					kEnvironment.SetAltitude(nX, nY, kLoader.GetTowerHeight(nX, nY));
				}
			}

			kBot.Setup(&kEnvironment);
			kBot.SetPosition(kLoader.GetInitialPosition());
			kBot.SetDirection(kLoader.GetInitialDirection());
		}
	}

	return eCode;
}

/*
 * Update
 */
void World::Update(float fElapsed)
{
	kInterface.Update(fElapsed);

	if(nWorldState == WorldState_Main)
	{
	}
	else

	if(nWorldState == WorldState_Game)
	{
		UpdateInput(fElapsed);
		UpdateLogic(fElapsed);
	}
	else

	if(nWorldState == WorldState_Pause)
	{
	}
}

/*
 * Render
 */
void World::Render(RenderContext& kContext)
{
	const uint32 nColor = D3DCOLOR_XRGB(32, 32, 32);

	kContext.Begin(nColor);

	D3DVIEWPORT9 kOriginal;
	kContext.GetViewport(&kOriginal);

	D3DVIEWPORT9 kViewport;
	kViewport.X			= 0;
	kViewport.Y			= 0;
	kViewport.Width		= ScreenSizeX - 280;
	kViewport.Height	= ScreenSizeY;
	kViewport.MinZ		= kOriginal.MinZ;
	kViewport.MaxZ		= kOriginal.MaxZ;

	kContext.SetViewport(kViewport);

	kCameraController.SetMode(CameraMode_3D);
	kEnvironment.Render(kContext, kCameraController);
	kBot.Render(kContext, kCameraController);

	kContext.SetViewport(kOriginal);

	kCameraController.SetMode(CameraMode_2D);
	kInterface.Render(kContext, kCameraController);

	kContext.End();
}

/*
 * InitializeInterface
 */
ErrorCode World::InitializeInterface(ResourceManager* pResourceManager)
{
	ErrorCode eCode = kInterface.Initialize(pResourceManager, pInputManager);
	if(eCode == Error_Success)
	{
		pBackground = new GuiImage();
		pBackground->Initialize(pResourceManager);
		pBackground->SetTexture("Data\\Textures\\Background03.tga", true);
		pBackground->SetPosition(ScreenSizeX - pBackground->GetWidth(), 0.0f);
		pBackground->SetDepth(512.0f);

		pToolbar = new CodePanel(4, 2);
		pToolbar->Initialize(pResourceManager);
		pToolbar->SetTexture("Data\\Textures\\PanelA.png");
		pToolbar->SetPosition(16, 16.0f);
		pToolbar->SetAction(0, Action_Forward);
		pToolbar->SetAction(1, Action_RotateCW);
		pToolbar->SetAction(2, Action_RotateCCW);
		pToolbar->SetAction(3, Action_Jump);
		pToolbar->SetAction(4, Action_Light);
		pToolbar->SetAction(5, Action_FunctionA);
		pToolbar->SetAction(6, Action_FunctionB);
		pToolbar->SetPermanent(true);
		pToolbar->SetDepth(256.0f);

		GuiLabel* pMainLabel = new GuiLabel();
		pMainLabel->Initialize(pResourceManager);
		pMainLabel->SetFont("Courier New", 16);
		pMainLabel->SetText("Main:");
		pMainLabel->SetColor(D3DCOLOR_XRGB(0, 0, 0));
		pMainLabel->SetPosition(26.0f, 149.0f);
		pMainLabel->SetDepth(256.0f);

		pCode[0] = new CodePanel(4, 3);
		pCode[0]->Initialize(pResourceManager);
		pCode[0]->SetTexture("Data\\Textures\\PanelB.png");
		pCode[0]->SetPosition(16.0f, 160.0f);
		pCode[0]->Subscribe(CodePanel::EventAction, &World::OnAction, this);
		pCode[0]->SetDepth(256.0f);

		GuiLabel* pFunctionALabel = new GuiLabel();
		pFunctionALabel->Initialize(pResourceManager);
		pFunctionALabel->SetFont("Courier New", 16);
		pFunctionALabel->SetText("Function 1:");
		pFunctionALabel->SetColor(D3DCOLOR_XRGB(0, 0, 0));
		pFunctionALabel->SetPosition(26.0f, 349.0f);

		pCode[1] = new CodePanel(4, 2);
		pCode[1]->Initialize(pResourceManager);
		pCode[1]->SetTexture("Data\\Textures\\PanelA.png");
		pCode[1]->SetPosition(16.0f, 360.0f);
		pCode[1]->Subscribe(CodePanel::EventAction, &World::OnAction, this);

		GuiLabel* pFunctionBLabel = new GuiLabel();
		pFunctionBLabel->Initialize(pResourceManager);
		pFunctionBLabel->SetFont("Courier New", 16);
		pFunctionBLabel->SetText("Function 2:");
		pFunctionBLabel->SetColor(D3DCOLOR_XRGB(0, 0, 0));
		pFunctionBLabel->SetPosition(26.0f, 493.0f);

		pCode[2] = new CodePanel(4, 2);
		pCode[2]->Initialize(pResourceManager);
		pCode[2]->SetTexture("Data\\Textures\\PanelA.png");
		pCode[2]->SetPosition(16.0f, 504.0f);
		pCode[2]->Subscribe(CodePanel::EventAction, &World::OnAction, this);

		const float fButtonPadding	= 32.0f;
		const float fButtonSpacing	= 8.0f;
		const float fButtonSize		= 48.0f;

		pButtonPlay = new GuiButton();
		pButtonPlay->Initialize(pResourceManager);
		pButtonPlay->SetTexture(GuiButtonState_Normal, "Data\\Textures\\Button1N.png", true);
		pButtonPlay->SetTexture(GuiButtonState_Hover, "Data\\Textures\\Button1H.png", true);
		pButtonPlay->SetTexture(GuiButtonState_Down, "Data\\Textures\\Button1D.png", true);
		pButtonPlay->SetFont("Courier New", 16, FW_BOLD);
		pButtonPlay->SetText("Play");
		pButtonPlay->SetColor(D3DCOLOR_XRGB(0, 0, 0));
		pButtonPlay->SetPosition(fButtonPadding + 0.0f * (fButtonSize + fButtonSpacing), 652.0f);
		pButtonPlay->Subscribe(GuiButton::EventClick, &World::OnPlay, this);

		pButtonStop = new GuiButton();
		pButtonStop->Initialize(pResourceManager);
		pButtonStop->SetTexture(GuiButtonState_Normal, "Data\\Textures\\Button1N.png", true);
		pButtonStop->SetTexture(GuiButtonState_Hover, "Data\\Textures\\Button1H.png", true);
		pButtonStop->SetTexture(GuiButtonState_Down, "Data\\Textures\\Button1D.png", true);
		pButtonStop->SetFont("Courier New", 16, FW_BOLD);
		pButtonStop->SetText("Stop");
		pButtonStop->SetColor(D3DCOLOR_XRGB(0, 0, 0));
		pButtonStop->SetPosition(fButtonPadding + 1.0f * (fButtonSize + fButtonSpacing), 652.0f);
		pButtonStop->Subscribe(GuiButton::EventClick, &World::OnStop, this);

		pButtonReset = new GuiButton();
		pButtonReset->Initialize(pResourceManager);
		pButtonReset->SetTexture(GuiButtonState_Normal, "Data\\Textures\\Button1N.png", true);
		pButtonReset->SetTexture(GuiButtonState_Hover, "Data\\Textures\\Button1H.png", true);
		pButtonReset->SetTexture(GuiButtonState_Down, "Data\\Textures\\Button1D.png", true);
		pButtonReset->SetFont("Courier New", 16, FW_BOLD);
		pButtonReset->SetText("Reset");
		pButtonReset->SetColor(D3DCOLOR_XRGB(0, 0, 0));
		pButtonReset->SetPosition(fButtonPadding + 2.0f * (fButtonSize + fButtonSpacing), 652.0f);
		pButtonReset->Subscribe(GuiButton::EventClick, &World::OnReset, this);

		pButtonExit = new GuiButton();
		pButtonExit->Initialize(pResourceManager);
		pButtonExit->SetTexture(GuiButtonState_Normal, "Data\\Textures\\Button1N.png", true);
		pButtonExit->SetTexture(GuiButtonState_Hover, "Data\\Textures\\Button1H.png", true);
		pButtonExit->SetTexture(GuiButtonState_Down, "Data\\Textures\\Button1D.png", true);
		pButtonExit->SetFont("Courier New", 16, FW_BOLD);
		pButtonExit->SetText("Exit");
		pButtonExit->SetColor(D3DCOLOR_XRGB(0, 0, 0));
		pButtonExit->SetPosition(fButtonPadding + 3.0f * (fButtonSize + fButtonSpacing), 652.0f);
		pButtonExit->Subscribe(GuiButton::EventClick, &World::OnExit, this);

		pBackground->Add(pToolbar);
		pBackground->Add(pMainLabel);
		pBackground->Add(pCode[0]);
		pBackground->Add(pFunctionALabel);
		pBackground->Add(pCode[1]);
		pBackground->Add(pFunctionBLabel);
		pBackground->Add(pCode[2]);
		pBackground->Add(pButtonPlay);
		pBackground->Add(pButtonStop);
		pBackground->Add(pButtonReset);
		pBackground->Add(pButtonExit);

		pMessageDialog = new MessageDialog();
		pMessageDialog->Initialize(pResourceManager);
		pMessageDialog->Subscribe(GuiDialog::EventResult, &World::OnResult, this);

		const D3DXVECTOR2& kMessageSize = pMessageDialog->GetDimensions();
		pMessageDialog->SetPosition(0.5f * ((ScreenSizeX - pBackground->GetWidth()) - kMessageSize.x), 0.5f * (ScreenSizeY - kMessageSize.y));

		pConfirmDialog = new ChoiceDialog();
		pConfirmDialog->Initialize(pResourceManager);
		pConfirmDialog->Subscribe(GuiDialog::EventResult, &World::OnConfirm, this);

		const D3DXVECTOR2& kConfigSize = pConfirmDialog->GetDimensions();
		pConfirmDialog->SetPosition(0.5f * ((ScreenSizeX - pBackground->GetWidth()) - kConfigSize.x), 0.5f * (ScreenSizeY - kConfigSize.y));

		//pHud = new GuiElement();
		//pHud->Add(pBackground);

		kInterface.Add(pBackground);
		kInterface.Add(pMessageDialog);
		kInterface.Add(pConfirmDialog);
	}

	return eCode;
}

/*
 * UpdateInput
 */
void World::UpdateInput(float fElapsed)
{
	pInputManager->Update(fElapsed);

	#if defined(_DEBUG)
	if(pInputManager->IsKeyDown(DIK_LEFT))
	{
		kCameraController.Yaw(0.01f);
	}
	else

	if(pInputManager->IsKeyDown(DIK_RIGHT))
	{
		kCameraController.Yaw(-0.01f);
	}

	if(pInputManager->IsKeyDown(DIK_UP))
	{
		kCameraController.Pitch(0.01f);
	}
	else

	if(pInputManager->IsKeyDown(DIK_DOWN))
	{
		kCameraController.Pitch(-0.01f);
	}

	if(pInputManager->IsKeyDown(DIK_NEXT))
	{
		kCameraController.Move(0.1f);
	}
	else

	if(pInputManager->IsKeyDown(DIK_PRIOR))
	{
		kCameraController.Move(-0.1f);
	}

	static bool bControl = false;
	static uint32 nBuffer[4] = {0};
	static uint32 nCount = 0;

	if(bControl)
	{
		if(pInputManager->IsKeyDown(DIK_0) && !pInputManager->WasKeyDown(DIK_0))
		{
			nBuffer[nCount++] = 0;
		}
		else

		if(pInputManager->IsKeyDown(DIK_1) && !pInputManager->WasKeyDown(DIK_1))
		{
			nBuffer[nCount++] = 1;
		}
		else

		if(pInputManager->IsKeyDown(DIK_2) && !pInputManager->WasKeyDown(DIK_2))
		{
			nBuffer[nCount++] = 2;
		}
		else

		if(pInputManager->IsKeyDown(DIK_3) && !pInputManager->WasKeyDown(DIK_3))
		{
			nBuffer[nCount++] = 3;
		}
		else

		if(pInputManager->IsKeyDown(DIK_4) && !pInputManager->WasKeyDown(DIK_4))
		{
			nBuffer[nCount++] = 4;
		}
		else

		if(pInputManager->IsKeyDown(DIK_5) && !pInputManager->WasKeyDown(DIK_5))
		{
			nBuffer[nCount++] = 5;
		}
		else

		if(pInputManager->IsKeyDown(DIK_6) && !pInputManager->WasKeyDown(DIK_6))
		{
			nBuffer[nCount++] = 6;
		}
		else

		if(pInputManager->IsKeyDown(DIK_7) && !pInputManager->WasKeyDown(DIK_7))
		{
			nBuffer[nCount++] = 7;
		}
		else

		if(pInputManager->IsKeyDown(DIK_8) && !pInputManager->WasKeyDown(DIK_8))
		{
			nBuffer[nCount++] = 8;
		}
		else

		if(pInputManager->IsKeyDown(DIK_9) && !pInputManager->WasKeyDown(DIK_9))
		{
			nBuffer[nCount++] = 9;
		}

		if(!pInputManager->IsKeyDown(DIK_LCONTROL))
		{
			if(nCount > 0)
			{
				nCurrentLevel	= 0;
				nLogicState		= LogicState_LevelLoad;

				for(uint32 i = 0; i < nCount; ++i)
				{
					nCurrentLevel += (uint32)(nBuffer[i] * powf(10.0f, (float)i));
				}
			}

			bControl = false;
		}
	}
	else
	{
		if(pInputManager->IsKeyDown(DIK_LCONTROL))
		{
			bControl = true;
			nCount = 0;
		}
	}
	#endif
}

/*
 * UpdateLogic
 */
void World::UpdateLogic(float fElapsed)
{
	if(nLogicState == LogicState_LevelLoad)
	{
		char kBuffer[256];
		sprintf(kBuffer, "Data\\Maps\\Map%02d.map", nCurrentLevel++);

		ErrorCode eCode = Load(kBuffer);
		if(eCode == Error_Success)
		{
			kProgram.Clear();

			for(uint32 i = 0; i < MaximumCodePanels; ++i)
			{
				pCode[i]->Clear();
			}

			nLogicState = LogicState_GameActive;
		}
		else
		{
			pMessageDialog->SetButton(0, "Ok", 0);
			pMessageDialog->SetMessage("Congratulations!\nYou have completed the game");
			pMessageDialog->Show();

			nLogicState = LogicState_GameOver;
		}

		nSimulationState = SimulationState_Idle;
	}
	else

	if(nLogicState == LogicState_GameActive)
	{
		if(nSimulationState == SimulationState_Active)
		{
			if(kBot.Update(fElapsed))
			{
				if(kEnvironment.RequirementsMet())
				{
					pMessageDialog->SetButton(0, "Ok", 0);
					pMessageDialog->SetMessage("Congratulations!\nYou have completed level %d", nCurrentLevel);
					pMessageDialog->Show();

					nLogicState = LogicState_LevelComplete;
				}
			}
		}
	}
}

/*
 * OnAction
 */
void World::OnAction(GuiEventArguments& kArguments)
{
	ActionArguments& kActionArguments = (ActionArguments&)kArguments;

	for(uint32 i = 0; i < MaximumCodePanels; ++i)
	{
		if(kArguments.pSource == pCode[i])
		{
			kProgram.SetAction(i, kActionArguments.nSlot, pCode[i]->GetAction(kActionArguments.nSlot));
		}
	}
}

/*
 * OnPlay
 */
void World::OnPlay(GuiEventArguments& kArguments)
{
	if(nSimulationState == SimulationState_Idle)
	{
		kEnvironment.Reset();

		kBot.Reset();
		kBot.SetPosition(kLoader.GetInitialPosition());
		kBot.SetDirection(kLoader.GetInitialDirection());
		kBot.Upload(kProgram);

		nSimulationState = SimulationState_Active;
	}
}

/*
 * OnStop
 */
void World::OnStop(GuiEventArguments& kArguments)
{
	if(nSimulationState == SimulationState_Active)
	{
		kEnvironment.Reset();

		kBot.Reset();
		kBot.SetPosition(kLoader.GetInitialPosition());
		kBot.SetDirection(kLoader.GetInitialDirection());

		nSimulationState = SimulationState_Idle;
	}
}

/*
 * OnReset
 */
void World::OnReset(GuiEventArguments& kArguments)
{
	kProgram.Clear();

	for(uint32 i = 0; i < MaximumCodePanels; ++i)
	{
		pCode[i]->Clear();
	}
}

/*
 * OnExit
 */
void World::OnExit(GuiEventArguments& kArguments)
{
	pConfirmDialog->SetMessage("Are you sure you want to exit?");
	pConfirmDialog->SetButton(0, "Yes", DialogResult_Yes);
	pConfirmDialog->SetButton(1, "No", DialogResult_No);
	pConfirmDialog->Show();

	nWorldState = WorldState_Confirm;
}

/*
 * OnResult
 */
void World::OnResult(GuiEventArguments& kArguments)
{
	if(nWorldState == WorldState_Game)
	{
		if(nLogicState == LogicState_LevelComplete)
		{
			nLogicState = LogicState_LevelLoad;
		}
		else

		if(nLogicState == LogicState_GameOver)
		{
			nCurrentLevel	= 0;
			nLogicState		= LogicState_LevelLoad;

			//TODO: Return to main menu
			nWorldState = WorldState_Main;
		}
	}
}

/*
 * OnConfirm
 */
void World::OnConfirm(GuiEventArguments& kArguments)
{
	if(nWorldState == WorldState_Confirm)
	{
		GuiResultArguments& kResultArguments = (GuiResultArguments&)kArguments;

		if(kResultArguments.nResult == DialogResult_Yes)
		{
			Deactivate();
		}
		else

		if(kResultArguments.nResult == DialogResult_No)
		{
			nWorldState = WorldState_Game;
		}
	}
}