/*
 * Program
 */

#include "Program.h"

/*
 * Program
 */
Program::Program()
{
}

/*
 * Initialize
 */
ErrorCode Program::Initialize()
{
	return Clear(), Error_Success;
}

/*
 * Terminate
 */
void Program::Terminate()
{
}

/*
 * SetAction
 */
void Program::SetAction(uint32 nFunction, uint32 nIndex, uint32 nAction)
{
	if(nFunction < FunctionCount && nIndex < Function::MaximumInstructionCount)
	{
		kFunction[nFunction].nInstruction[nIndex] = nAction;
	}
}

/*
 * Clear
 */
void Program::Clear()
{
	for(uint32 i = 0; i < FunctionCount; ++i)
	{
		for(uint32 j = 0; j < Function::MaximumInstructionCount; ++j)
		{
			kFunction[i].nInstruction[j] = Action_Default;
		}
	}
}

/*
 * Upload
 */
ErrorCode Program::Upload(VirtualMachine& kMachine) const
{
	ErrorCode eCode = Error_Success;

	kMachine.Reset();
	kMachine.ClearMemory();
	kMachine.RemoveAllFunctions();

	for(uint32 i = 0; i < FunctionCount && eCode == Error_Success; ++i)
	{
		kMachine.AddFunction(i, kFunction[i].CalculateSize());

		uint32 nSize = kMachine.GetFunctionSize(i);
		uint8* pData = kMachine.GetFunctionMemory(i);

		eCode = Compile(i, pData, nSize);
	}

	return eCode;
}

/*
 * Compile
 */
ErrorCode Program::Compile(uint32 nIndex, uint8* pData, uint32 nSize) const
{
	for(uint32 i = 0; i < Function::MaximumInstructionCount; ++i)
	{
		const uint32 nAction = kFunction[nIndex].nInstruction[i];

		if(Action_Forward <= nAction && nAction <= Action_Light)
		{
			if(nSize < 2)
				return Error_Fail;

			*pData++ = Instruction_Action;
			*pData++ = nAction;

			nSize -= 2;
		}
		else

		if(Action_FunctionA <= nAction && nAction <= Action_FunctionB)
		{
			if(nSize < 2)
				return Error_Fail;

			*pData++ = Instruction_Call;
			*pData++ = nAction - Action_FunctionA + 1;

			nSize -= 2;
		}
	}

	return Error_Success;
}