/*
 * Mediator
 */

#include "Mediator.h"
#include "VertexTypes.h"

/*
 * Mediator
 */
Mediator::Mediator() : Application()
{
	pGraphicsDevice	= NULL;
}

/*
 * Initialize
 */
ErrorCode Mediator::Initialize()
{
	InitializeTrace(TraceFlag_Debug | TraceFlag_File);

	ErrorCode eCode = Application::Initialize();
	if(eCode != Error_Success)
	{
		TRACE("Error: Failed to initialize application\n");

		Terminate();
		return eCode;
	}

	eCode = GraphicsDevice::Create(kWindow.GetHandle(), ScreenSizeX, ScreenSizeY, &pGraphicsDevice);
	if(eCode != Error_Success)
	{
		TRACE("Error: Failed to initialize graphics device\n");
		
		Terminate();
		return eCode;
	}

	eCode = kContext.Initialize(pGraphicsDevice);
	if(eCode != Error_Success)
	{
		TRACE("Error: Failed to initialize render context\n");

		Terminate();
		return eCode;
	}

	eCode = kResourceManager.Initialize(pGraphicsDevice);
	if(eCode != Error_Success)
	{
		TRACE("Error: Failed to initialize resource manager\n");

		Terminate();
		return eCode;
	}

	eCode = kInputManager.Initialize(kWindow.GetHandle());
	if(eCode != Error_Success)
	{
		TRACE("Error: Failed to initialize input manager\n");

		Terminate();
		return eCode;
	}

	eCode = kServiceProvider.AddService("ResourceManager", &kResourceManager);
	if(eCode != Error_Success)
	{
		TRACE("Error: Failed to add resource manager service\n");

		Terminate();
		return eCode;
	}

	eCode = kServiceProvider.AddService("InputManager", &kInputManager);
	if(eCode != Error_Success)
	{
		TRACE("Error: Failed to add input manager service\n");

		Terminate();
		return eCode;
	}

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

		Terminate();
		return eCode;
	}

	eCode = kBot.Initialize(&kServiceProvider);
	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 = kInterface.Initialize(&kServiceProvider);
	if(eCode != Error_Success)
	{
		TRACE("Error: Failed to initialize interface\n");

		Terminate();
		return eCode;
	}

	eCode = InitializeMainMenu();
	if(eCode != Error_Success)
	{
		TRACE("Error: Failed to initialize main menu\n");

		Terminate();
		return eCode;
	}

	eCode = InitializeHelpMenu();
	if(eCode != Error_Success)
	{
		TRACE("Error: Failed to initialize help menu\n");

		Terminate();
		return eCode;
	}

	eCode = InitializeHud();
	if(eCode != Error_Success)
	{
		TRACE("Error: Failed to initialize HUD\n");

		Terminate();
		return eCode;
	}

	SetApplicationState(ApplicationState_Main);

	return eCode;
}

/*
 * Terminate
 */
void Mediator::Terminate()
{
	kInterface.Terminate();
	kProgram.Terminate();
	kBot.Terminate();
	kEnvironment.Terminate();
	kInputManager.Terminate();
	kResourceManager.Terminate();
	kContext.Terminate();

	GraphicsDevice::Destroy(pGraphicsDevice);

	TerminateTrace();
}

/*
 * Update
 */
void Mediator::Update(float fElapsed)
{
	kInputManager.Update(fElapsed);

	UpdateInput(fElapsed);

	if(nApplicationState == ApplicationState_Main)
	{
	}
	else

	if(nApplicationState == ApplicationState_Game)
	{
		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);
		}
	}
	else

	if(nApplicationState == ApplicationState_Pause)
	{
	}
	else

	if(nApplicationState == ApplicationState_Help)
	{
	}

	kInterface.Update(fElapsed);
}

/*
 * Render
 */
void Mediator::Render()
{
	const uint32 nColor = D3DCOLOR_XRGB(32, 32, 32);

	kContext.Begin(nColor);

	if(nApplicationState == ApplicationState_Main)
	{
	}
	else

	if(nApplicationState == ApplicationState_Game)
	{
		if(nGameState >= GameState_Active)
		{
			RenderGame();
		}
	}
	else

	if(nApplicationState == ApplicationState_Pause)
	{
	}
	else

	if(nApplicationState == ApplicationState_Help)
	{
	}

	RenderInterface();

	kContext.End();
}

/*
 * InitializeMainMenu
 */
ErrorCode Mediator::InitializeMainMenu()
{
	pMainBackground = new GuiImage();
	pMainBackground->Initialize(&kServiceProvider);
	pMainBackground->SetTexture("Data\\Textures\\MainMenu\\Background.png", true);
	pMainBackground->SetPosition(0, 0);
	pMainBackground->ClearFlag(GuiElementFlag_Visible);
	pMainBackground->SetDepth(512.0f);

	kInterface.Add(pMainBackground);

	return Error_Success;
}

/*
 * InitializeHelpMenu
 */
ErrorCode Mediator::InitializeHelpMenu()
{
	return Error_Success;
}

/*
 * InitializeHud
 */
ErrorCode Mediator::InitializeHud()
{
	pHudBackground = new GuiImage();
	pHudBackground->Initialize(&kServiceProvider);
	pHudBackground->SetTexture("Data\\Textures\\Background04.tga", true);
	pHudBackground->SetPosition(ScreenSizeX - pHudBackground->GetWidth(), 0.0f);
	pHudBackground->SetDepth(512.0f);
	pHudBackground->ClearFlag(GuiElementFlag_Visible);

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

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

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

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

	pButtonPlay = new GuiButton();
	pButtonPlay->Initialize(&kServiceProvider);
	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, &Mediator::OnPlay, this);

	pButtonStop = new GuiButton();
	pButtonStop->Initialize(&kServiceProvider);
	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, &Mediator::OnStop, this);

	pButtonReset = new GuiButton();
	pButtonReset->Initialize(&kServiceProvider);
	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, &Mediator::OnReset, this);

	pButtonExit = new GuiButton();
	pButtonExit->Initialize(&kServiceProvider);
	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, &Mediator::OnExit, this);

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

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

	kInterface.Add(pHudBackground);
	kInterface.Add(pDebugText);

	return Error_Success;
}

/*
 * UpdateInput
 */
void Mediator::UpdateInput(float fElapsed)
{
	if(nApplicationState == ApplicationState_Main)
	{
		if(kInputManager.IsKeyDown(DIK_SPACE))
		{
			nCurrentLevel		= 0;
			nGameState			= GameState_Load;
			nSimulationState	= SimulationState_Idle;

			SetApplicationState(ApplicationState_Game);
		}
	}
	else
	
	if(nApplicationState == ApplicationState_Help)
	{
	}
	else

	if(nApplicationState == ApplicationState_Game)
	{
		#if defined(_DEBUG)
		if(kInputManager.IsKeyDown(DIK_LEFT))
		{
			kCameraController.Yaw(0.01f);
		}
		else

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

		if(kInputManager.IsKeyDown(DIK_UP))
		{
			kCameraController.Pitch(0.01f);
		}
		else

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

		if(kInputManager.IsKeyDown(DIK_NEXT))
		{
			kCameraController.Move(0.1f);
		}
		else

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

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

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

			if(kInputManager.IsKeyDown(DIK_1) && !kInputManager.WasKeyDown(DIK_1))
			{
				nBuffer[nCount++] = 1;
			}
			else

			if(kInputManager.IsKeyDown(DIK_2) && !kInputManager.WasKeyDown(DIK_2))
			{
				nBuffer[nCount++] = 2;
			}
			else

			if(kInputManager.IsKeyDown(DIK_3) && !kInputManager.WasKeyDown(DIK_3))
			{
				nBuffer[nCount++] = 3;
			}
			else

			if(kInputManager.IsKeyDown(DIK_4) && !kInputManager.WasKeyDown(DIK_4))
			{
				nBuffer[nCount++] = 4;
			}
			else

			if(kInputManager.IsKeyDown(DIK_5) && !kInputManager.WasKeyDown(DIK_5))
			{
				nBuffer[nCount++] = 5;
			}
			else

			if(kInputManager.IsKeyDown(DIK_6) && !kInputManager.WasKeyDown(DIK_6))
			{
				nBuffer[nCount++] = 6;
			}
			else

			if(kInputManager.IsKeyDown(DIK_7) && !kInputManager.WasKeyDown(DIK_7))
			{
				nBuffer[nCount++] = 7;
			}
			else

			if(kInputManager.IsKeyDown(DIK_8) && !kInputManager.WasKeyDown(DIK_8))
			{
				nBuffer[nCount++] = 8;
			}
			else

			if(kInputManager.IsKeyDown(DIK_9) && !kInputManager.WasKeyDown(DIK_9))
			{
				nBuffer[nCount++] = 9;
			}

			if(!kInputManager.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(kInputManager.IsKeyDown(DIK_LCONTROL))
			{
				bControl = true;
				nCount = 0;
			}
		}
		#endif
	}
}

/*
 * UpdateLogic
 */
void Mediator::UpdateLogic(float fElapsed)
{
	if(nGameState == GameState_Load)
	{
		ErrorCode eCode = LoadLevel(nCurrentLevel++);
		if(eCode == Error_Success)
		{
			kProgram.Clear();

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

			nGameState = GameState_Active;
		}
		else
		{
			pMessageDialog->SetButton(0, "Ok", DialogResult_Ok);
			pMessageDialog->SetMessage("Congratulations!\nYou've won the game!");
			pMessageDialog->Show();

			nGameState = GameState_Over;
		}

		nSimulationState = SimulationState_Idle;
	}
	else

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

					nGameState = GameState_Level;
				}
			}
		}
	}
}

/*
 * RenderGame
 */
void Mediator::RenderGame()
{
	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);
}

/*
 * RenderInterface
 */
void Mediator::RenderInterface()
{
	kCameraController.SetMode(CameraMode_2D);
	kInterface.Render(kContext, kCameraController);
}

/*
 * SetApplicationState
 */
void Mediator::SetApplicationState(uint32 nState)
{
	if(nApplicationState == ApplicationState_Main)
	{
		pMainBackground->ClearFlag(GuiElementFlag_Visible);
	}
	else
	
	if(nApplicationState == ApplicationState_Help)
	{
	}
	else

	if(nApplicationState == ApplicationState_Game)
	{
		pHudBackground->ClearFlag(GuiElementFlag_Visible);
	}

	nApplicationState = nState;

	if(nApplicationState == ApplicationState_Main)
	{
		pMainBackground->SetFlag(GuiElementFlag_Visible);
	}
	else
	
	if(nApplicationState == ApplicationState_Help)
	{
	}
	else

	if(nApplicationState == ApplicationState_Game)
	{
		pHudBackground->SetFlag(GuiElementFlag_Visible);
	}
}

/*
 * LoadLevel
 */
ErrorCode Mediator::LoadLevel(uint32 nLevel)
{
	char kName[MAX_PATH];
	sprintf(kName, "Data\\Maps\\Map%02d.map", nLevel);

	ErrorCode eCode = kLoader.Load(kName);
	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;
}

/*
 * OnStart
 */
void Mediator::OnStart(GuiEventArguments& kArguments)
{
}

/*
 * OnHelp
 */
void Mediator::OnHelp(GuiEventArguments& kArguments)
{
}

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

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

		nSimulationState = SimulationState_Idle;
	}
}

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

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

/*
 * OnExit
 */
void Mediator::OnExit(GuiEventArguments& kArguments)
{
	//pScreenManager->Push("Confirm");
	bRunning = false;
}