#include <cstdlib>

#include <iostream>

#include <wchar.h>

#include <locale.h>

#include <cstring>

#include <chrono>

#include <thread>

using namespace std;

typedef uint16_t address_t;

typedef uint8_t command_t;

typedef uint8_t sleep_t;

typedef uint8_t color_t;

const address_t MEMORY_SIZE = 1024;

const command_t CMD_GOTO = 0x70;

const command_t CMD_SLEEP = 0xFF;

const command_t CMD_COLOR = 0xAA;

const command_t CMD_END = 0xED;

/**

 * Reads data on given position in memory and increments the index (position).

 */

template<typename T> T read(command_t * memory, address_t &index) {

	// TODO: for addresses: map higher memory to static hardcoded areas or peripherals

	// TODO: sizeof (command_t) != 1 ?

	T * value = reinterpret_cast<T*> (memory + index);

	index += sizeof (*value) / sizeof (command_t);

	return *value;

}

/**

 * Writes data to given position in memory and increments the index (position).

 */

template<typename T> void write(command_t * memory, address_t &index, const T value) {

	// TODO: sizeof (command_t) != 1 ?

	// T * m = (T*) (memory + index);

	T * m = reinterpret_cast<T*> (memory + index);

	*m = value;

	index += sizeof (value) / sizeof (command_t);

}

int main(int argc, char* argv[]) {

	setlocale(LC_ALL, "");

	command_t * memory = (command_t*) malloc(MEMORY_SIZE);

	{

		address_t a = 0;

		write<command_t>(memory, a, CMD_SLEEP);

		write<sleep_t>(memory, a, 255);

		write<command_t>(memory, a, CMD_SLEEP);

		write<sleep_t>(memory, a, 10);

		write<command_t>(memory, a, CMD_SLEEP);

		write<sleep_t>(memory, a, 255);

		write<command_t>(memory, a, CMD_GOTO);

		write<address_t>(memory, a, a + 4);

		write<command_t>(memory, a, 1);

		write<command_t>(memory, a, 1);

		write<command_t>(memory, a, CMD_SLEEP);

		write<sleep_t>(memory, a, 255);

		write<command_t>(memory, a, CMD_COLOR);

		write<color_t>(memory, a, 50);

		write<color_t>(memory, a, 100);

		write<color_t>(memory, a, 150);

		write<command_t>(memory, a, CMD_END);

	}

	for (address_t i = 0; i < MEMORY_SIZE;) {

		wprintf(L"command %d = ", i);

		command_t ch = read<command_t>(memory, i);

		wprintf(L"%X\n", ch);

		string command;

		color_t r;

		color_t g;

		color_t b;

		switch (ch) {

			case CMD_GOTO:

				i = read<address_t>(memory, i);

				command.append("GOTO ");

				break;

			case CMD_SLEEP:

				command.append("SLEEP");

				this_thread::sleep_for(chrono::milliseconds(read<sleep_t>(memory, i)));

				break;

			case CMD_COLOR:

				command.append("COLOR");

				r = read<color_t>(memory, i);

				g = read<color_t>(memory, i);

				b = read<color_t>(memory, i);

				break;

			case CMD_END:

				command.append("END");

				i = MEMORY_SIZE;

				break;

		}

		if (!command.empty()) {

			wprintf(L"\t%s\n", command.c_str());

		}

	}

	free(memory);

	memory = nullptr;

	wprintf(L"all done\n");

	return 0;

}