#include <cstdlib>

 #include <iostream>

 #include <wchar.h>

 #include <locale.h>

 #include <cstring>

 #include <unordered_map>

 #include "types.h"

 #include "memory.h"

 #include "Command.h"

 #include "commands/Goto.h"

 #include "commands/GotoCompare.h"

 #include "commands/Sleep.h"

 #include "commands/End.h"

 #include "commands/Color.h"

 using namespace std;

 // TODO: strong typedefs http://www.boost.org/doc/libs/1_61_0/libs/serialization/doc/strong_typedef.html ?

 /**

  * Skip to the given address.

  * parameter: address_t

  */

 const command_t CMD_GOTO = 0x70;

 /**

  * Compare values on two addresses and go to one of given three addresses.

  * parameter: address_t a

  * parameter: address_t b

  * parameter: address_t GOTO target when a == b

  * parameter: address_t GOTO target when a > b

  * parameter: address_t GOTO target when a < b

  */

 const command_t CMD_GOTO_COMPARE = 0x80;

 /**

  * Wait given time in ms.

  * parameter: sleep_t

  */

 const command_t CMD_SLEEP = 0xFF;

 /**

  * Set RGB LED color.

  * parameter: led_t LED number

  * parameter: color_t red

  * parameter: color_t green

  * parameter: color_t blue

  */

 const command_t CMD_COLOR = 0xAA;

 /**

  * Stop program.

  */

 const command_t CMD_END = 0xED;

 /**

  * Increase value at given address

  * parameter: address_t

  */

 const command_t CMD_INCREMENT = 0x11;

 /**

  * Decrease value at given address

  * parameter: address_t

  */

 const command_t CMD_DECREMENT = 0x12;

 /**

  * Placeholder for unsupported command.

  * Just for testing.

  */

 const command_t CMD_INVALID = 0x1;

 // TODO: more commands, better numbers

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

 	setlocale(LC_ALL, "");

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

 	// Sample program / data:

 	// TODO: load bytes from file, stdin, serial port, network…

 	{

 		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 + sizeof (address_t) + 2 * sizeof (command_t));

 		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<led_t>(memory, a, 23);

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

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

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

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

 		write<address_t>(memory, a, 0);

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

 		write<address_t>(memory, a, 0);

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

 		write<address_t>(memory, a, 0);

 		write<address_t>(memory, a, 0 + sizeof (command_t) + sizeof (sleep_t));

 		write<address_t>(memory, a, a - 3 * sizeof (address_t) - 2 * sizeof (command_t));

 		write<address_t>(memory, a, 0);

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

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

 	}

 	unordered_map<command_t, shared_ptr < Command>> commands = {

 		{CMD_GOTO, make_shared<commands::Goto>()},

 		{CMD_GOTO_COMPARE, make_shared<commands::GotoCompare>()},

 		{CMD_SLEEP, make_shared<commands::Sleep>()},

 		{CMD_END, make_shared<commands::End>()},

 		{CMD_COLOR, make_shared<commands::Color>()},

 	};

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

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

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

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

 		shared_ptr<Command> cx = commands[command];

 		if (cx) {

 			cx->process(memory, i);

 			continue;

 		} else {

 			// TODO: wprintf(L"invalid command\n");

 		}

 		switch (command) {

 			case CMD_INCREMENT:

 			case CMD_DECREMENT:

 			{

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

 				address_t address_r = address;

 				address_t address_w = address_r;

 				octet_t value = read<octet_t>(memory, address_r);

 				value = command == CMD_INCREMENT ? value + 1 : value - 1;

 				write<octet_t>(memory, address_w, value);

 				wprintf(L"%sCREMENT %*d → %02X\n", (command == CMD_INCREMENT ? "IN" : "DE"), 5, address, value);

 				break;

 			}

 			default:

 			{

 				wprintf(L"invalid command\n");

 			}

 		}

 	}

 	free(memory);

 	memory = nullptr;

 	wprintf(L"all done\n");

 	return 0;

 }