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

#include "../bindump.h"

#define DEBUG(...)              printf(__VA_ARGS__)
#define die(err_msg)            perror(err_msg); exit(-1)
#define alert(...)              fprintf(stderr, __VA_ARGS__)

#define MAX_LINE_LEN            256


static uint32_t myatoi(const char *a_field_str)
{
	size_t i;
	uint32_t ret = 0;

	for (i = 0; i < 5 && '0' <= a_field_str[i] && a_field_str[i] <= '9'; ++i) {
		ret = (ret * 10) + (a_field_str[i] - 0x30);
	}

	return ret;
}

static bool parse_a_type(const char *line, uint16_t *instruction)
{
	char c, a_field_str[6];  // TODO: eventually factor out use of array
	uint32_t a_field = 0;
	size_t i, a = 0;

	if (line[0] != '@') {
		alert("error: A-type instruction doesn't start with @\n");
		return false;
	}

	if (line[1] == '\0') {
		alert("error: A-type instruction empty after @\n");
		return false;
	}

	for (i = 1; (c = line[i]) != '\0' && a < 6; ++i) {
		if ('0' <= c && c <= '9') {
			if (a > 4) {
				alert("error: @<number> too long\n");
				return false;
			}
			a_field_str[a] = c; // get number
			a++;
		} else if ((c == ' ' || c == '\t' || c == '/') && i > 1) {
			break;
		} else {       // any other character
			alert("syntax error: invalid char '%c' found after @\n",
			      c);
			return false;
		}
	}

	a_field_str[a] = '\0';   // exit

	// TODO: extension: support negative numbers
	a_field = myatoi(a_field_str);
	if (a_field > 32767) {
		alert("error: %u > 32767, too large\n", a_field);
		return false;
	}

	*instruction = 0x0000 | (uint16_t) a_field;
	return true; // STUB, A-type MSB == 0 anyway
}

/* returns dest bits 0b00000ddd
 */
static bool parse_c_type_dest(const char *dest_line, uint8_t *dest)
{
	DEBUG("dest_line: %s\n", dest_line);

	/* if 'A'
	 *     if 'D'
	 *         if 'M'
	 *     else if '='
	 * if 'D'
	 *     if 'M'
	 *     else if '='
	 * if 'M'
	 *     if '='
	 * default:
	 *     "syntax error"
	 */

	*dest = 0x03;  // 0b00000011
	return true;
}

/* returns comp bits 0b0acccccc
 */
static bool parse_c_type_comp(const char *comp_line, uint8_t *comp)
{
	DEBUG("comp_line: %s\n", comp_line);
	*comp = 0x53;  // 0b01010011
	return true;
}

/* returns jump bits 0b00000jjj
 */
static bool parse_c_type_jump(const char *jump_line, uint8_t *jump)
{
	// Note: can do 'jump' fields via lookup tables once extracted from line
	DEBUG("jump_line: %s\n", jump_line);
	
	/* if 'J'
	 *     if 'G'
	 *         if 'T'
	 *         if 'E'
	 *     if 'E'
	 *         if 'Q'
	 *     if 'L'
	 *         if 'T'
	 *         if 'E'
	 *     if 'N'
	 *         if 'E'
	 *     if 'M'
	 *         if 'P'
	 * default:
	 *     "syntax error"
	 */

	*jump = 0x01;  // 0b00000001
	return true;
}

/* Instruction format: 0b111accccccdddjjj
 * Assumes line begins with actual instruction (prepended whitespace stripped)
 */
static bool parse_c_type(const char *line, uint16_t *instruction)
{
	bool ret;
	char c;
	char *dest_start = NULL;
	char *comp_start = NULL;
	char *jump_start = NULL;
	size_t i = 0;
	uint8_t dest = 0;
	uint8_t comp = 0;
	uint8_t jump = 0;

	c = line[0];
	for (i = 0; c != ' ' && c != '\t' &&
	            c != '\n' && c != '\0'; ++i) {
		c = line[i];

		if (c == '=') {
			if (1 <= i && i <= 3) {
				dest_start = &line[0];   // start of line
				comp_start = &line[i+1]; // after "[dest]="
			} else {
				//syntax error
				alert("syntax error: destination field in line"
				      " incorrectly formatted\n");
				return false;
			}
		} else if (c == ';') {
			if (1 <= i && i <= 7) {
				jump_start = &line[i+1]; // after "[comp];"
			} else {
				//syntax error
				alert("syntax error: jump field in line"
				      " incorrectly formatted\n");
				return false;
			}
		}
	}

	// Only the comp field is mandatory for assembly instructions;
	// dest and jump fields are optional, and may/may not be present
	if (comp_start == NULL) {
		comp_start = &line[0];  // start of line (no dest field)
	}

	ret = parse_c_type_comp(comp_start, &comp);
	if (!ret) {
		return false;
	}

	if (dest_start != NULL) {
		ret = parse_c_type_dest(dest_start, &dest);
		if (!ret) {
			return false;
		}
	}

	if (jump_start != NULL) {
		ret = parse_c_type_jump(jump_start, &jump);
		if (!ret) {
			return false;
		}
	}

	// STUB: DM=D-M;JGT  // 0b111 1010011 011 001
	*instruction = 0xe000 | ((uint16_t)comp << 6)
	                      | ((uint16_t)dest << 3)
	                      | ((uint16_t)jump);
	return true;
}

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

	while ((c = line[i]) != '\0') {
		if (c == ' ' || c == '\t')
			;  // skip any whitespace at start of line
		else if (c == '@') {
			ret = parse_a_type(&line[i], instruction);
			break;
		} else if (c >= '!' && c < '~') {
			ret = parse_c_type(&line[i], instruction);
			break;
		} else {
			alert("syntax error: line '%s' incorrectly formatted\n",
			      line);
		}

		++i;
	}

	return ret;
}

// 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("syntax 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);
}


char *usage_msg = "Usage: assembler1 [path/to/file.asm]\n";

int main(int argc, char *argv[])
{
	bool result = false; 
	uint16_t instruction;
	char in_line[MAX_LINE_LEN];
	size_t in_line_len, i, count;
	char *in_file_path;
	FILE *fp;

	if (argc != 2) {                            // requires 1 argument
		die(usage_msg);
		exit(-1);
	}

	in_file_path = argv[1];
	fp = fopen(in_file_path, "r");
	if (fp == NULL) {
		die("failed to open file for reading\n");
		exit(-1);
	}

	count = 1;
	while (fgets(in_line, MAX_LINE_LEN, fp) != NULL) {
		in_line_len = strlen(in_line);

		for (i = 0; i < in_line_len; ++i) { // remove newlines
			if (in_line[i] == '\n') {
				in_line[i] = '\0';
				break;
			}
		}

		DEBUG("%lu|%s\n", count, in_line);
		result = parse_line(in_line, in_line_len, &instruction);
		if (result) {
			DEBUG("instruction: 0x%x  |  ", instruction);
			bindump_word16(instruction); // output instruction as binary
			putchar('\n');
		}
	++count;
	}

	return 0;
}