#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "../bindump.h"

#define DEBUG(x) printf(x)

void die(const char *err_msg, int exit_val)
{
	perror(err_msg);
	exit(exit_val);
}

void alert(const char *err_msg)
{
	fprintf(stderr, "%s", err_msg);
}

bool parse_a_type(const char *line, uint16_t *instruction)
{
	DEBUG("parse_a_type()\n");
	// eventually, if error, die("error: TODO explain...\n", -1);
	*instruction = 0x0000; // STUB, A-type MSB == 0 anyway
	return true; // STUB, A-type MSB == 0 anyway
}

bool parse_c_type(const char *line, uint16_t *instruction)
{
	DEBUG("parse_c_type()\n");
	*instruction = 0x8000; // STUB, C-type MSB == 1 anyway
	return true; // STUB, C-type MSB == 1 anyway
}
// */

// does not care about line line length; exits at first newline or after
// relevant portion parsed (allows for syntactically-incorrect lines, I know)
bool parse_instruction_w_type(const char *line, uint16_t *instruction)
{
	bool ret;
	char c;
	size_t i = 0;

	while ((c = line[i]) != '\n') {
		if (c == ' ' || c == '\t')
			;  // skip whitespace
		else if (c == '@') {
			ret = parse_a_type(line, instruction);
			break;
		} else if (c >= '!' && c < '~') {
			ret = parse_c_type(line, instruction);
			break;
		} else {
			die("error: TODO explain...\n", -1);
		}

		++i;
	}

	return ret;
}
// */

bool parse_next_instruction(const char *line, uint16_t *instruction)
{
	*instruction = 1337; // STUB, should be 0x539, 0b0000010100111001
	return parse_instruction_w_type(line, instruction);

	return true;
}

/* return false for comment or invalid assembly instruction */
bool parse_line(const char *line, size_t line_len, uint16_t *instruction)
{
	char c;
	bool slash_found = false;
	size_t i;

	if (line_len == 0 || line_len == 1)
		return false;

	// filter out comment lines
	//for (i = 0; (c = line[i]) != NULL; ++i) {
	for (i = 0; i < line_len; ++i) {
		c = line[i];

		if (c == ' ' || c == '\t') {
			continue;
		} else if (c == '/') {
			if (slash_found) {
				// second slash means this is a comment
				return false;
			}
			slash_found= true;
			continue;
		} else if (slash_found) {
			// this char not slash, but previous was: invalid syntax
			// TODO: add line, column numbers
			alert("\tsyntax error: found '/', comments "
			      "need '//'\n");
			return false;
		} else {
			// non-whitespace/slash char discovered
			break;
		}
	}

	// comment not found, so attempting to parse instruction
	return parse_next_instruction(line, instruction);
}

const char *test_lines[8] = {"// this is a comment\n",
                             "@12345\n",
                             "\n",
                             "M+1\n",
                             "@98\n",
                             "// this is another comment\n",
                             "/ this is a broken comment\n",
                             "D=M;JNE\n"};
size_t num_test_lines = (sizeof(test_lines) / sizeof(test_lines[0]));

int main()
{
	// TODO: read file by lines, parse instructions
	bool result = false; 
	uint16_t instruction;
	size_t test_line_len;

	// New organization allows code to eventually work with lines fetched
	// from a 'fgets()' loop or something

	// for testing
	for (size_t i = 0; i < num_test_lines; ++i) {
		test_line_len = strlen(test_lines[i]);
		result = parse_line(test_lines[i], test_line_len, &instruction);
		if (result) {
			printf("instruction: 0x%x  |  ", instruction);
			bindump_word16(instruction); // output instruction as binary
			putchar('\n');
		}
	}

	return 0;
}