/*
 * World
 */

#include "World.h"
#include "VertexTypes.h"
#include "GuiLabel.h"
#include "GuiImage.h"
#include "GuiButton.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);
}

/*
 * 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);

	//TODO: Remove
	if(nGameState >= GameState_Active)
	{
		kCameraController.SetMode(CameraMode_3D);
		Render3D(kContext);

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

	kContext.End();
}

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

		GuiButton* pButtonPlay = new GuiButton();
		pButtonPlay->Initialize(pResourceManager);
		pButtonPlay->SetTexture(GuiButtonState_Normal, "Data\\Textures\\Play.tga", true);
		pButtonPlay->SetPosition(1023.0f + 0.0f * 54.0f, 640.0f);
		pButtonPlay->Subscribe(GuiButton::EventClick, &World::OnPlay, this);

		GuiButton* pButtonStop = new GuiButton();
		pButtonStop->Initialize(pResourceManager);
		pButtonStop->SetTexture(GuiButtonState_Normal, "Data\\Textures\\Stop.tga", true);
		pButtonStop->SetPosition(1023.0f + 1.0f * 54.0f, 640.0f);
		pButtonStop->Subscribe(GuiButton::EventClick, &World::OnStop, this);

		/*
		GuiButton* pButtonReset = new GuiButton();
		pButtonReset->Initialize(pResourceManager);
		pButtonReset->SetTexture(GuiButtonState_Normal, "Data\\Textures\\Reset.tga", true);
		pButtonReset->SetPosition(1023.0f + 2.0f * 54.0f, 640.0f.0f);
		pButtonReset->Subscribe(GuiButton::EventClick, &World::OnReset, this);
		*/

		GuiButton* pButtonExit = new GuiButton();
		pButtonExit->Initialize(pResourceManager);
		pButtonExit->SetTexture(GuiButtonState_Normal, "Data\\Textures\\Exit.tga", true);
		pButtonExit->SetPosition(1023.0f + 3.0f * 54.0f, 640.0f);
		pButtonExit->Subscribe(GuiButton::EventClick, &World::OnExit, this);

		/*
		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);
		*/

		pLevelDialog = new GuiImage();
		pLevelDialog->Initialize(pResourceManager);
		//pLevelDialog->SetVisible(false);
		pLevelDialog->SetTexture("Data\\Textures\\Dialog2.tga", true);
		pLevelDialog->SetPosition(0.5f * (ScreenSizeX - pLevelDialog->GetWidth()), 0.5f * (ScreenSizeY - pLevelDialog->GetHeight()));

		pLevelDialogOk = new GuiButton();
		pLevelDialogOk->Initialize(pResourceManager);
		pLevelDialogOk->SetTexture(GuiButtonState_Normal, "Data\\Textures\\Slot.tga");
		pLevelDialogOk->SetFont("Courier New", 24);
		pLevelDialogOk->SetText("Ok");
		pLevelDialogOk->SetDimensions(150.0f, 52.0f);
		//pLevelDialogOk->SetPosition(23.0f, 171.0f);
		pLevelDialogOk->SetPosition(0.5f * (pLevelDialog->GetWidth() - pLevelDialogOk->GetWidth()), 171.0f);
		pLevelDialogOk->Subscribe(GuiButton::EventClick, &World::OnExit, this);

		pLevelDialog->Add(pLevelDialogOk);

		/*
		pGameDialogOk = new GuiButton();
		pGameDialogOk->Initialize(pResourceManager);
		pGameDialogOk->SetTexture(GuiButtonState_Normal, "Data\\Textures\\Button.tga", true);
		//pGameDialogOk->SetText("Ok");
		pGameDialogOk->SetPosition(1023.0f + 3.0f * 54.0f, 640.0f);
		pGameDialogOk->Subscribe(GuiButton::EventClick, &World::OnExit, this);
		*/

		pGameDialog = new GuiImage();
		pGameDialog->Initialize(pResourceManager);
		pGameDialog->SetVisible(false);
		pGameDialog->SetTexture("Data\\Textures\\Dialog2.tga", true);
		pGameDialog->SetPosition(0.5f * (ScreenSizeX - pGameDialog->GetWidth()), 0.5f * (ScreenSizeY - pGameDialog->GetHeight()));
		//pGameDialog->Add(pGameDialogOk);

		kInterface.Add(pBackground);
		kInterface.Add(pButtonPlay);
		kInterface.Add(pButtonStop);
		//kInterface.Add(pButtonReset);
		kInterface.Add(pButtonExit);
		kInterface.Add(pLevelDialog);
		kInterface.Add(pGameDialog);

		/*
		//CodePanel* 
		pToolbar = new CodePanel(8);
		pToolbar->Initialize(pResourceManager);
		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");
		pMain->Subscribe(CodePanel::Drop, &World::OnDrop, this);

		//CodePanel* 
		pFunctionA = new CodePanel(16);
		pFunctionA->SetBackgroundTexture("Data\\Textures\\CodePanel.tga");
		pFunctionA->SetSlotTexture("Data\\Textures\\Slot.tga");
		pFunctionA->Subscribe(CodePanel::Drop, &World::OnDrop, this);

		//CodePanel* 
		pFunctionB = new CodePanel(16);
		pFunctionB->SetBackgroundTexture("Data\\Textures\\CodePanel.tga");
		pFunctionB->SetSlotTexture("Data\\Textures\\Slot.tga");
		pFunctionB->Subscribe(CodePanel::Drop, &World::OnDrop, 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 eCode;
}

/*
 * 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))
		{
			// pick against the toolbar
			int32 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;
			}
			*/
		}
	}
}

/*
 * OnPlay
 */
void World::OnPlay(GuiEventArguments& kArguments)
{
	if(nSimulationState == SimulationState_Idle)
	{
		ResetBot();
		kBot.Upload(pFunction, kLoader.GetFunctionCount() + 1);

		nSimulationState = SimulationState_Active;
	}
}

/*
 * OnStop
 */
void World::OnStop(GuiEventArguments& kArguments)
{
	if(nSimulationState == SimulationState_Active)
	{
		ResetEnvironment();
		ResetBot();

		nSimulationState = SimulationState_Idle;
	}
}

/*
 * OnReset
 */
void World::OnReset(GuiEventArguments& kArguments)
{
}

/*
 * OnExit
 */
void World::OnExit(GuiEventArguments& kArguments)
{
	nGameState = GameState_Exit;
}