/**

  * RGB assembler

  * Copyright © 2017 František Kučera (frantovo.cz)

  *

  * This program is free software: you can redistribute it and/or modify

  * it under the terms of the GNU General Public License as published by

  * the Free Software Foundation, either version 3 of the License, or

  * (at your option) any later version.

  *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  * GNU General Public License for more details.

  *

  * You should have received a copy of the GNU General Public License

  * along with this program. If not, see <http://www.gnu.org/licenses/>.

  */

 #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.h"

 #include "commands/Goto.h"

 #include "commands/GotoCompare.h"

 #include "commands/Sleep.h"

 #include "commands/End.h"

 #include "commands/Color.h"

 #include "commands/IncrementDecrement.h"

 using namespace std;

 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>()},

 		{CMD_INCREMENT, make_shared < commands::IncrementDecrement>(true, 1)},

 		{CMD_DECREMENT, make_shared < commands::IncrementDecrement>(false, 1)},

 	};

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

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

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

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

 		shared_ptr<Command> command = commands[commandCode];

 		if (command) {

 			command->process(memory, i);

 		} else {

 			wprintf(L"invalid command\n");

 		}

 	}

 	free(memory);

 	memory = nullptr;

 	wprintf(L"all done\n");

 	return 0;

 }