/*
 * World
 */

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

/*
 * World
 */
World::World() : kToolbar(8), kMain(16), kFunction(8), kControls(4)
{
	nGameState				= GameState_Active;
	nSimulationState		= SimulationState_Idle;
	pFunction				= 0;
	nCurrentFunction		= 0;
	nCurrentLevel			= 0;

	kArrowBounds[0]			= Rectangle2(1206.0f + 0 * 16.0f, 473.0f + 0 * 54.0f, 16.0f, 16.0f);
	kArrowBounds[1]			= Rectangle2(1206.0f + 2 * 16.0f, 473.0f + 0 * 54.0f, 16.0f, 16.0f);

	kDialog1Bounds[0]		= Rectangle2(567.0f, 412.0f, 150.0f, 60.0f);

	kDialog2Bounds[0]		= Rectangle2(1023.0f + 2.5f * 54.0f, 638.0f + 0 * 00.0f, 48.0f, 48.0f);
	kDialog2Bounds[1]		= Rectangle2(1023.0f + 2.5f * 54.0f, 638.0f + 0 * 00.0f, 48.0f, 48.0f);

	kToolbar.Add(1023.0f + 0 * 54.0f, 85.0f + 0 * 54.0f, 48.0f, 48.0f);
	kToolbar.Add(1023.0f + 1 * 54.0f, 85.0f + 0 * 54.0f, 48.0f, 48.0f);
	kToolbar.Add(1023.0f + 2 * 54.0f, 85.0f + 0 * 54.0f, 48.0f, 48.0f);
	kToolbar.Add(1023.0f + 3 * 54.0f, 85.0f + 0 * 54.0f, 48.0f, 48.0f);
	kToolbar.Add(1023.0f + 0 * 54.0f, 85.0f + 1 * 54.0f, 48.0f, 48.0f);
	kToolbar.Add(1023.0f + 1 * 54.0f, 85.0f + 1 * 54.0f, 48.0f, 48.0f);
	kToolbar.Add(1023.0f + 2 * 54.0f, 85.0f + 1 * 54.0f, 48.0f, 48.0f);
	kToolbar.Add(1023.0f + 3 * 54.0f, 85.0f + 1 * 54.0f, 48.0f, 48.0f);

	kMain.Add(1023.0f + 0 * 54.0f, 238.0f + 0 * 54.0f, 48.0f, 48.0f);
	kMain.Add(1023.0f + 1 * 54.0f, 238.0f + 0 * 54.0f, 48.0f, 48.0f);
	kMain.Add(1023.0f + 2 * 54.0f, 238.0f + 0 * 54.0f, 48.0f, 48.0f);
	kMain.Add(1023.0f + 3 * 54.0f, 238.0f + 0 * 54.0f, 48.0f, 48.0f);
	kMain.Add(1023.0f + 0 * 54.0f, 238.0f + 1 * 54.0f, 48.0f, 48.0f);
	kMain.Add(1023.0f + 1 * 54.0f, 238.0f + 1 * 54.0f, 48.0f, 48.0f);
	kMain.Add(1023.0f + 2 * 54.0f, 238.0f + 1 * 54.0f, 48.0f, 48.0f);
	kMain.Add(1023.0f + 3 * 54.0f, 238.0f + 1 * 54.0f, 48.0f, 48.0f);
	kMain.Add(1023.0f + 0 * 54.0f, 238.0f + 2 * 54.0f, 48.0f, 48.0f);
	kMain.Add(1023.0f + 1 * 54.0f, 238.0f + 2 * 54.0f, 48.0f, 48.0f);
	kMain.Add(1023.0f + 2 * 54.0f, 238.0f + 2 * 54.0f, 48.0f, 48.0f);
	kMain.Add(1023.0f + 3 * 54.0f, 238.0f + 2 * 54.0f, 48.0f, 48.0f);
	kMain.Add(1023.0f + 0 * 54.0f, 238.0f + 3 * 54.0f, 48.0f, 48.0f);
	kMain.Add(1023.0f + 1 * 54.0f, 238.0f + 3 * 54.0f, 48.0f, 48.0f);
	kMain.Add(1023.0f + 2 * 54.0f, 238.0f + 3 * 54.0f, 48.0f, 48.0f);
	kMain.Add(1023.0f + 3 * 54.0f, 238.0f + 3 * 54.0f, 48.0f, 48.0f);

	kFunction.Add(1023.0f + 0 * 54.0f, 501.0f + 0 * 54.0f, 48.0f, 48.0f);
	kFunction.Add(1023.0f + 1 * 54.0f, 501.0f + 0 * 54.0f, 48.0f, 48.0f);
	kFunction.Add(1023.0f + 2 * 54.0f, 501.0f + 0 * 54.0f, 48.0f, 48.0f);
	kFunction.Add(1023.0f + 3 * 54.0f, 501.0f + 0 * 54.0f, 48.0f, 48.0f);
	kFunction.Add(1023.0f + 0 * 54.0f, 501.0f + 1 * 54.0f, 48.0f, 48.0f);
	kFunction.Add(1023.0f + 1 * 54.0f, 501.0f + 1 * 54.0f, 48.0f, 48.0f);
	kFunction.Add(1023.0f + 2 * 54.0f, 501.0f + 1 * 54.0f, 48.0f, 48.0f);
	kFunction.Add(1023.0f + 3 * 54.0f, 501.0f + 1 * 54.0f, 48.0f, 48.0f);

	kControls.Add(1023.0f + 0.5f * 54.0f, 638.0f + 0 * 00.0f, 48.0f, 48.0f);
	kControls.Add(1023.0f + 1.5f * 54.0f, 638.0f + 0 * 00.0f, 48.0f, 48.0f);
	kControls.Add(1023.0f + 2.5f * 54.0f, 638.0f + 0 * 00.0f, 48.0f, 48.0f);
}

/*
 * Initialize
 */
ErrorCode World::Initialize(EventSystem* pSystem, ResourceManager* pResourceManager, InputManager* pInput)
{
	ErrorCode eCode = Error_Fail;

	if(pResourceManager && pInput)
	{
		pEventSystem = pSystem;
		pInputManager = pInput;

		eCode = kEnvironment.Initialize(pResourceManager);
		if(eCode == Error_Success)
		{
			eCode = kBot.Initialize(pResourceManager);
			if(eCode == Error_Success)
			{
				//eCode = kProgram.Initialize(pResourceManager);
				if(eCode == Error_Success)
				{
					eCode = InitializeInterface(pResourceManager);				
					if(eCode == Error_Success)
					{
						nCurrentLevel	= 0;
						nGameState		= GameState_LoadMap;
					}
				}
			}
		}
	}

	return eCode;
}

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

/*
 * Activate
 */
void World::Activate()
{
	nGameState = GameState_LoadMap;
}

/*
 * Deactivate
 */
void World::Deactivate()
{
	nGameState = GameState_Exit;
}

/*
 * IsActive
 */
bool World::IsActive()
{
	return nGameState != GameState_Exit;
}

/*
 * Load
 */
bool World::Load(const char* pName)
{
	ErrorCode eCode = kLoader.Load(pName);
	if(eCode == Error_Success)
	{
		if(pFunction)
		{
			delete[] pFunction;
			pFunction = NULL;
		}

		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.kPosition	= kLoader.GetInitialPosition();
			kBot.kDirection	= kLoader.GetInitialDirection();

			const uint32 nCount = kLoader.GetFunctionCount();

			pFunction = new Code[nCount + 1];
			pFunction[0].Initialize(MainFunctionLength);
			pFunction[0].Clear();

			for(uint32 i = 0; i < nCount; ++i)
			{
				const uint32 nLength = kLoader.GetFunctionLength(i);

				pFunction[i + 1].Initialize(nLength);
				pFunction[i + 1].Clear();
			}
		}
	}

	return eCode == Error_Success;
}

/*
 * ResetEnvironment
 */
void World::ResetEnvironment()
{
	kEnvironment.Reset();
}

/*
 * ResetBot
 */
void World::ResetBot()
{
	kBot.Reset();
	kBot.kPosition	= kLoader.GetInitialPosition();
	kBot.kDirection	= kLoader.GetInitialDirection();
}

/*
 * ResetCode
 */
void World::ClearCode()
{
	for(uint32 i = 0; i < kLoader.GetFunctionCount(); ++i)
	{
		pFunction[i].Clear();
	}
}

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

	if(nGameState == GameState_LoadMap)
	{
		char kBuffer[256];
		sprintf_s(kBuffer, "Data\\Maps\\Map%02d.map", nCurrentLevel++);

		nGameState = Load(kBuffer) ? GameState_Active : GameState_Over;
	}
	else

	if(nGameState == GameState_Active)
	{
		if(nSimulationState == SimulationState_Active)
		{
			if(kBot.Update(fElapsed))
			{
				if(kEnvironment.RequirementsMet())
				{
					kDialog.Reset("Some message");
					kDialog.AddButton(DialogButton_Ok, "Ok", 0.0f, 0.0f, 0.0f, 0.0f);

					nGameState = GameState_Complete;
				}
			}
		}

		kInterface.Update(fElapsed);
	}
}

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

	kContext.Begin(nColor);

	if(nGameState >= GameState_Active)
	{
		kCameraController.SetMode(CameraMode_3D);
		Render3D(kContext);

		kCameraController.SetMode(CameraMode_2D);
		Render2D(kContext);
	}

	kContext.End();
}

/*
 * InitializeInterface
 */
ErrorCode World::InitializeInterface(ResourceManager* pResourceManager)
{
	GuiContainer* pRoot = kInterface.GetRoot();
	//ASSERT(pRoot != NULL);

	GuiLabel*
	pLabel = new GuiLabel();
	pLabel->Initialize(pResourceManager);
	pLabel->SetFont("Courier New", 16);
	pLabel->SetText("This is a test!");
	pLabel->SetFlags(GuiLabelFlag_CenterX | GuiLabelFlag_CenterY);
	pLabel->SetPosition(0.5f * ScreenSizeX, 0.5f * ScreenSizeY);

	pRoot->Add(pLabel);

	//return kInterface.Initialize(pResourceManager);

	/*
	GuiElement* pRoot = kInterface.GetRoot();

	//CodePanel* 
	pToolbar = new CodePanel(8);
	pToolbar->SetBackgroundTexture("Data\\Textures\\CodePanel.tga");
	pToolbar->SetSlotTexture("Data\\Textures\\Slot.tga");

	//CodePanel* 
	pMain = new CodePanel(16);
	pMain->SetBackgroundTexture("Data\\Textures\\CodePanel.tga");
	pMain->SetSlotTexture("Data\\Textures\\Slot.tga");

	//CodePanel* 
	pFunctionA = new CodePanel(16);
	pFunctionA->SetBackgroundTexture("Data\\Textures\\CodePanel.tga");
	pFunctionA->SetSlotTexture("Data\\Textures\\Slot.tga");

	//CodePanel* 
	pFunctionB = new CodePanel(16);
	pFunctionB->SetBackgroundTexture("Data\\Textures\\CodePanel.tga");
	pFunctionB->SetSlotTexture("Data\\Textures\\Slot.tga");

	//SelectorPanel*
	pSelectorPanel = new SelectorPanel();
	pSelectorPanel->SetLeftTexture("Data\\Textures\\Left.tga");
	pSelectorPanel->SetRightTexture("Data\\Textures\\Right.tga");
	pSelectorPanel->Add(pFunctionA);
	pSelectorPanel->Add(pFunctionB);

	//GuiButton*
	pButtonStart = new GuiButton();
	pButtonStart->SetTexture("Data\\Textures\\Play.tga");
	pButtonStart->SetDimensions(...);
	pButtonStart->SetCallback(&World::OnClick, this);

	//GuiButton*
	pButtonStop = new GuiButton();
	pButtonStop->SetTexture("Data\\Textures\\Stop.tga");
	pButtonStop->SetDimensions(...);
	pButtonStop->SetCallback(&World::OnClick, this);

	//GuiButton*
	pButtonReset = new GuiButton();
	pButtonReset->SetTexture("Data\\Textures\\Reset.tga");
	pButtonReset->SetDimensions(...);
	pButtonReset->SetCallback(&World::OnClick, this);

	//GuiButton*
	pButtonExit = new GuiButton();
	pButtonExit->SetTexture("Data\\Textures\\Exit.tga");
	pButtonExit->SetDimensions(...);
	pButtonExit->SetCallback(&World::OnClick, this);

	//GuiPanel*
	pControlPanel = new GuiPanel();
	pControlPanel->SetTexture("Data\\Textures\\ControlPanel.tga")
	pControlPanel->SetDimensions(...);
	pControlPanel->Add(pButtonStart);
	pControlPanel->Add(pButtonStop);
	pControlPanel->Add(pButtonReset);
	pControlPanel->Add(pButtonExit);

	//GuiDialog*
	pLevelDialog = new GuiDialog();
	pLevelDialog->AddButton(DialogButton_Ok, "Ok");
	pLevelDialog->SetVisible(false);

	//GuiDialog*
	pGameDialog = new GuiDialog();
	pGameDialog->AddButton(DialogButton_Ok, "Ok");
	pGameDialog->SetVisible(false);

	//GuiDialog*
	pConfirmDialog = new GuiDialog();
	pConfirmDialog->AddButton(DialogButton_Yes, "Yes");
	pConfirmDialog->AddButton(DialogButton_No, "No");
	pConfirmDialog->SetVisible(false);

	//GuiPanel* 
	pContainerPanel = new GuiPanel();
	pContainerPanel->SetBackgroundTexture("Data\\Texturse\\ContainerPanel.tga");
	pContainerPanel->Add(pToolbar);
	pContainerPanel->Add(pMain);
	pContainerPanel->Add(pSelectorPanel);
	pContainerPanel->Add(pControlPanel);

	pRoot->Add(pControlPanel);
	pRoot->Add(pLevelDialog);
	pRoot->Add(pGameDialog);
	pRoot->Add(pConfirmDialog);
	*/

	return Error_Success;
}

/*
 * Render3D
 */
void World::Render3D(RenderContext& kContext)
{
	kEnvironment.Render(kContext, kCameraController);
	kBot.Render(kContext, kCameraController);
}

/* 
 * Render2D
 */
void World::Render2D(RenderContext& kContext)
{
	kInterface.Render(kContext, kCameraController);
}

/*
 * ProcessInput
 */
void World::ProcessInput(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);
	}
	#endif

	const float fMouseX = pInputManager->GetMouseX();
	const float fMouseY = pInputManager->GetMouseY();

	if(nGameState == GameState_Active)
	{
		if(pInputManager->IsButtonDown(0) && !pInputManager->WasButtonDown(0))
		{
			int32 nSelection = kControls.Pick(fMouseX, fMouseY);
			if(nSelection >= 0)
			{
				if(nSelection == ControlButton_Play)
				{
					if(nSimulationState == SimulationState_Idle)
					{
						ResetBot();
						kBot.Upload(pFunction, kLoader.GetFunctionCount() + 1);

						nSimulationState = SimulationState_Active;
					}
				}
				else

				if(nSelection == ControlButton_Stop)
				{
					if(nSimulationState == SimulationState_Active)
					{
						ResetEnvironment();
						ResetBot();

						nSimulationState = SimulationState_Idle;
					}
				}
				else

				if(nSelection == ControlButton_Exit)
				{
					nGameState = GameState_Exit;
				}
			}
			else
			{
				// pick against the toolbar
				nSelection = kToolbar.Pick(fMouseX, fMouseY);
				if(nSelection >= 0)
				{
					kDragController.Begin(Action_Forward + nSelection);
				}
				else
				{
					// pick against the main pane
					nSelection = kMain.Pick(fMouseX, fMouseY);
					if(nSelection >= 0)
					{
						Code* pCode = pFunction;
						if(!pCode->IsEmptySlot(nSelection))
						{
							kDragController.Begin(pCode->GetSlot(nSelection));
							pCode->ClearSlot(nSelection);
						}
					}
					else
					{
						// pick against the function pane
						nSelection = kFunction.Pick(fMouseX, fMouseY);
						if(nSelection >= 0)
						{
							Code* pCode = pFunction + nCurrentFunction + 1;
							if(!pCode->IsEmptySlot(nSelection))
							{
								kDragController.Begin(pCode->GetSlot(nSelection));
								pCode->ClearSlot(nSelection);
							}
						}
						else
						{
							// pick against the function pane arrows
							for(uint32 i = 0; i < sizeof(kArrowBounds) / sizeof(kArrowBounds[0]); ++i)
							{
								if(kArrowBounds[i].Contains(fMouseX, fMouseY))
								{
									const uint32 nCount = kLoader.GetFunctionCount();
									nCurrentFunction = (nCurrentFunction + 2 * (int32)i - 1 + nCount) % nCount;
								}
							}
						}
					}
				}
			}
		}
		else

		if(!pInputManager->IsButtonDown(0) && pInputManager->WasButtonDown(0))
		{
			if(kDragController.IsActive())
			{
				const uint32 nAction = kDragController.End();

				int32 nSelection = kMain.Pick(fMouseX, fMouseY);
				if(nSelection >= 0)
				{
					pFunction[0].SetSlot(nSelection, nAction);
				}
				else
				{
					nSelection = kFunction.Pick(fMouseX, fMouseY);
					if(nSelection >= 0)
					{
						pFunction[nCurrentFunction + 1].SetSlot(nSelection, nAction);
					}
				}
			}
		}
	}
	else

	if(nGameState == GameState_Complete)
	{
		if(pInputManager->IsButtonDown(0) && !pInputManager->WasButtonDown(0))
		{
			for(uint32 i = 0; i < sizeof(kDialog1Bounds) / sizeof(kDialog1Bounds[0]); ++i)
			{
				if(kDialog1Bounds[i].Contains(fMouseX, fMouseY))
				{
					if(i == 0)
					{
						if(nSimulationState == SimulationState_Active)
						{
							ResetEnvironment();
							ResetBot();

							nSimulationState = SimulationState_Idle;
						}

						nGameState = GameState_LoadMap;
					}
				}
			}

			/*
			int32 nSelection = kDialog.Pick(fMouseX, fMouseY);

			if(nSelection == DialogButton_A)
			{
				if(nSimulationState == SimulationState_Active)
				{
					ResetEnvironment();
					ResetBot();

					nSimulationState = SimulationState_Idle;
				}

				nGameState = GameState_LoadMap;
			}
			*/
		}
	}
	else

	if(nGameState == GameState_Over)
	{
		// check to see if button was clicked
		if(pInputManager->IsButtonDown(0) && !pInputManager->WasButtonDown(0))
		{
			for(uint32 i = 0; i < sizeof(kDialog1Bounds) / sizeof(kDialog1Bounds[0]); ++i)
			{
				if(kDialog1Bounds[i].Contains(fMouseX, fMouseY))
				{
					if(i == 0)
					{
						nCurrentLevel	= 0;
						nGameState		= GameState_LoadMap;
					}
				}
			}

			/*
			int32 nSelection = kDialog.Pick(fMouseX, fMouseY);

			if(nSelection == DialogButton_A)
			{
				nCurrentLevel	= 0;
				nGameState		= GameState_LoadMap;
			}
			*/
		}
	}
	else

	if(nGameState == GameState_Confirm)
	{
		// check to see if button was clicked
		if(pInputManager->IsButtonDown(0) && !pInputManager->WasButtonDown(0))
		{
			for(uint32 i = 0; i < sizeof(kDialog2Bounds) / sizeof(kDialog2Bounds[0]); ++i)
			{
				if(kDialog2Bounds[i].Contains(fMouseX, fMouseY))
				{
					if(i == 0)
					{
						nGameState = GameState_Exit;
					}
					else

					if(i == 1)
					{
						nGameState = GameState_Active;
					}
				}
			}

			/*
			int32 nSelection = kDialog.Pick(fMouseX, fMouseY);

			if(nSelection == DialogButton_A)
			{
				nGameState = GameState_Exit;
			}
			else

			if(nSelection == DialogButton_B)
			{
				nGameState = GameState_Active;
			}
			*/
		}
	}
}