/*
 * GameScreen
 */

#include "GameScreen.h"

/*
 * Initialize
 */
ErrorCode GameScreen::Initialize(ServiceProvider* pServiceProvider)
{
	ErrorCode eCode = kEnvironment.Initialize(pServiceProvider);
	if(eCode != Error_Success)
	{
		TRACE("Error: Failed to initialize environment\n");

		Terminate();
		return eCode;
	}

	eCode = kBot.Initialize(pServiceProvider);
	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 = pServiceProvider->GetService("InputManager", &pInputManager);
	if(eCode != Error_Success)
	{
		TRACE("Error: Failed to acquire input manager\n");

		Terminate();
		return eCode;
	}

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

		Terminate();
		return eCode;
	}

	nGameState			= GameState_Load;
	nSimulationState	= SimulationState_Idle;
	nCurrentLevel		= 0;

	return eCode;
}

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

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

	UpdateInput(fElapsed);
	UpdateLogic(fElapsed);

	{
		const D3DXVECTOR3& kCameraPosition = kCameraController.GetLocation();

		char kBuffer[256];
		sprintf_s(kBuffer, "Camera: <%.2f, %.2f, %.2f> (%.2f, %.2f, %.2f)", kCameraPosition.x, kCameraPosition.y, kCameraPosition.z, kCameraController.fCameraDistance, kCameraController.fCameraYaw, kCameraController.fCameraPitch);
		pDebugText->SetText(kBuffer);
	}

	kInterface.Update(fElapsed);
}

/*
 * Render
 */
void GameScreen::Render(RenderContext& kContext)
{
	if(nGameState != GameState_Load)
	{
		D3DVIEWPORT9 kOriginal;
		kContext.GetViewport(&kOriginal);

		D3DVIEWPORT9 kViewport;
		kViewport.X			= 0;
		kViewport.Y			= 0;
		kViewport.Width		= ScreenSizeX - 280;	// minus size of interface
		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);
}

/*
 * Load
 */
ErrorCode GameScreen::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());

			//kCameraController.SetDistance(
		}
	}

	return eCode;
}

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

		pToolbar = new ActionPanel(4, 2);
		pToolbar->Initialize(pServiceProvider);
		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(pServiceProvider);
		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 ActionPanel(4, 3);
		pCode[0]->Initialize(pServiceProvider);
		pCode[0]->SetTexture("Data\\Textures\\PanelB.png");
		pCode[0]->SetPosition(16.0f, 160.0f);
		pCode[0]->Subscribe(ActionPanel::EventAction, &GameScreen::OnAction, this);
		pCode[0]->SetDepth(256.0f);

		GuiLabel* pFunctionALabel = new GuiLabel();
		pFunctionALabel->Initialize(pServiceProvider);
		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 ActionPanel(4, 2);
		pCode[1]->Initialize(pServiceProvider);
		pCode[1]->SetTexture("Data\\Textures\\PanelA.png");
		pCode[1]->SetPosition(16.0f, 360.0f);
		pCode[1]->Subscribe(ActionPanel::EventAction, &GameScreen::OnAction, this);

		GuiLabel* pFunctionBLabel = new GuiLabel();
		pFunctionBLabel->Initialize(pServiceProvider);
		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 ActionPanel(4, 2);
		pCode[2]->Initialize(pServiceProvider);
		pCode[2]->SetTexture("Data\\Textures\\PanelA.png");
		pCode[2]->SetPosition(16.0f, 504.0f);
		pCode[2]->Subscribe(ActionPanel::EventAction, &GameScreen::OnAction, this);

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

		pButtonPlay = new GuiButton();
		pButtonPlay->Initialize(pServiceProvider);
		pButtonPlay->SetTexture(GuiButtonState_Normal, "Data\\Textures\\Button2N.png", true);
		pButtonPlay->SetTexture(GuiButtonState_Hover, "Data\\Textures\\Button2H.png", true);
		pButtonPlay->SetTexture(GuiButtonState_Down, "Data\\Textures\\Button2D.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, &GameScreen::OnPlay, this);

		pButtonStop = new GuiButton();
		pButtonStop->Initialize(pServiceProvider);
		pButtonStop->SetTexture(GuiButtonState_Normal, "Data\\Textures\\Button2N.png", true);
		pButtonStop->SetTexture(GuiButtonState_Hover, "Data\\Textures\\Button2H.png", true);
		pButtonStop->SetTexture(GuiButtonState_Down, "Data\\Textures\\Button2D.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, &GameScreen::OnStop, this);

		pButtonReset = new GuiButton();
		pButtonReset->Initialize(pServiceProvider);
		pButtonReset->SetTexture(GuiButtonState_Normal, "Data\\Textures\\Button2N.png", true);
		pButtonReset->SetTexture(GuiButtonState_Hover, "Data\\Textures\\Button2H.png", true);
		pButtonReset->SetTexture(GuiButtonState_Down, "Data\\Textures\\Button2D.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, &GameScreen::OnReset, this);

		pButtonExit = new GuiButton();
		pButtonExit->Initialize(pServiceProvider);
		pButtonExit->SetTexture(GuiButtonState_Normal, "Data\\Textures\\Button2N.png", true);
		pButtonExit->SetTexture(GuiButtonState_Hover, "Data\\Textures\\Button2H.png", true);
		pButtonExit->SetTexture(GuiButtonState_Down, "Data\\Textures\\Button2D.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, &GameScreen::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);

		pDebugText = new GuiLabel();
		pDebugText->Initialize(pServiceProvider);
		pDebugText->SetFont("Courier New", 16);
		pDebugText->SetPosition(10.0f, 10.0f);
		pDebugText->SetText("Debug");
		pDebugText->SetColor(D3DCOLOR_XRGB(255, 255, 255));

		kInterface.Add(pBackground);
		kInterface.Add(pDebugText);
	}

	return eCode;
}

/*
 * UpdateInput
 */
void GameScreen::UpdateInput(float 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;
				nGameState		= GameState_Load;

				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 GameScreen::UpdateLogic(float fElapsed)
{
	if(nGameState == GameState_Load)
	{
		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 < MaximumFunctionCount; ++i)
			{
				pCode[i]->Clear();
			}

			nGameState = GameState_Active;
		}
		else
		{
			//pScreenManager->Push("GameOver");
		}

		nSimulationState = SimulationState_Idle;
	}
	else

	if(nGameState == GameState_Active)
	{
		if(nSimulationState == SimulationState_Active)
		{
			if(kBot.Update(fElapsed))
			{
				if(kEnvironment.RequirementsMet())
				{
					nGameState = GameState_Load;
					//pScreenManager->Push("LevelOver");
				}
			}
		}
	}
}

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

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

/*
 * OnPlay
 */
void GameScreen::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 GameScreen::OnStop(GuiEventArguments& kArguments)
{
	if(nSimulationState == SimulationState_Active)
	{
		kEnvironment.Reset();

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

		nSimulationState = SimulationState_Idle;
	}
}

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

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

/*
 * OnExit
 */
void GameScreen::OnExit(GuiEventArguments& kArguments)
{
	//pScreenManager->Push("Confirm");
}