#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;

 const command_t CMD_INVALID = 0x1; // placeholder for unsupported command

 /**

  * 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, CMD_INVALID);

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

 		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, 0);

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

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

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

 	}

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

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

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

 		wprintf(L"%02X  ", ch);

 		color_t r;

 		color_t g;

 		color_t b;

 		sleep_t delay;

 		switch (ch) {

 			case CMD_GOTO:

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

 				wprintf(L"GOTO %*d\n", 5, i);

 				break;

 			case CMD_SLEEP:

 				delay = read<sleep_t>(memory, i);

 				wprintf(L"SLEEP %*d ms\n", 4, delay);

 				this_thread::sleep_for(chrono::milliseconds(delay));

 				break;

 			case CMD_COLOR:

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

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

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

 				wprintf(L"COLOR  %02X %02X %02X\n", r, g, b);

 				break;

 			case CMD_END:

 				wprintf(L"END\n");

 				i = MEMORY_SIZE;

 				break;

 			default:

 				wprintf(L"invalid command\n");

 		}

 	}

 	free(memory);

 	memory = nullptr;

 	wprintf(L"all done\n");

 	return 0;

 }