/*
 * Mediator
 */

#include "Mediator.h"
#include <windows.h>

/*
 * fUpdatePeriod
 */
static const float fUpdatePeriod = 1.0f / 60.0f;

/*
 * Mediator
 */
Mediator::Mediator()
{
}

/*
 * Run
 */
ErrorCode Mediator::Run()
{
	ErrorCode eCode = Initialize();
	if(eCode == Error_Success)
	{
		float fAccumulator = 0.0f;

		kClock.Reset();

		while(pModel->nGameState != GameState_Exit)
		//while(pWorld->IsActive())
		{
			ProcessMessages();

			fAccumulator += Min(kClock.GetElapsed(), fUpdatePeriod);
			while(fAccumulator >= fUpdatePeriod)
			{
				Update(fUpdatePeriod);
				fAccumulator -= fUpdatePeriod;
			}

			//if(updated)
			{
				Render();
			}
		}

		Terminate();
	}

	return eCode;
}

/*
 * Initialize
 */
ErrorCode Mediator::Initialize()
{
	pModel		= new Model();
	pView		= new View(pModel);
	pController = new Controller(pModel, pView);
	//pWorld = new World();

	ErrorCode eCode = pView->Initialize();
	//eCode = pWorld->Initialize();
	if(eCode == Error_Success)
	{
		//pWorld->Activate();

		eCode = pController->Initialize();
		if(eCode == Error_Success)
		{
			pModel->nCurrentLevel	= 0;
			pModel->nGameState		= GameState_LoadMap;
		}
	}
	
	return eCode;
}

/*
 * Terminate
 */
void Mediator::Terminate()
{
	/*
	if(pWorld)
	{
		pWorld->Terminate();

		delete pWorld;
		pWorld = NULL;
	}
	*/

	if(pController)
	{
		pController->Terminate();

		delete pController;
		pController = 0;
	}

	if(pView)
	{
		pView->Terminate();

		delete pView;
		pView = 0;
	}

	delete pModel;
	pModel = 0;
}

/*
 * Update
 */
void Mediator::Update(float fElapsed)
{
	pController->Update(fElapsed);
	//pWorld->Update(fElapsed);
}

/*
 * Render
 */
void Mediator::Render()
{
	pView->Render();
	//pWorld->Render();
}

/*
 * ProcessMessages
 */
void Mediator::ProcessMessages()
{
	MSG kMessage;

	while(PeekMessage(&kMessage, NULL, 0, 0, PM_REMOVE))
	{
		if(kMessage.message == WM_QUIT)
		{
			pModel->nGameState = GameState_Exit;
			//pWorld->Deactivate();
			break;
		}

		TranslateMessage(&kMessage);
		DispatchMessage(&kMessage);
	}
}