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

//#define DBGLOG(...)             printf(__VA_ARGS__)
#define DBGLOG(...)
#define error(...)              fprintf(stderr, __VA_ARGS__); \
                                fprintf(stderr, "%lu | %s\n", \
                                        g_asm_line_number, g_asm_line);

#define MAX_LINE_LEN            256

char *g_asm_line;                 // currently-read line for convenience
size_t g_asm_line_number;         // current line number
size_t g_instruction_number = 0;  // instruction offset


void print_binary_word16(uint16_t w)
{
        unsigned char i, msb;
        char binary_string[17];
        binary_string[16] = '\0';

        for (i = 0; i < 16; ++i) {
                msb = (char)(w >> 15);

                if (msb != 0)
                        binary_string[i] = '1';
                else
                        binary_string[i] = '0';
                w <<= 1;
        }
        printf("%s", binary_string);
}

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];
	uint32_t a_field = 0;
	size_t i, a = 0;

	DBGLOG("line: %s\n", comp_line);

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

	if (line[1] == '\0') {
		error("syntax 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) {
				error("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
			error("syntax error: invalid char '%c' found after @\n",
			      c);
			return false;
		}
	}

	a_field_str[a] = '\0';

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

	*instruction = 0x0000 | (uint16_t) a_field;
	return true;
}

/* returns dest bits 0b00000ddd
 * Note: order doesn't matter for multi-register dest (but officially it should)
 */
static bool parse_c_type_dest(const char *dest_line, uint8_t *dest)
{
	size_t len;
	DBGLOG("dest_line: %s\n", dest_line);

	for (len = 0; dest_line[len] != '='; ++len) {  // read until '='
		if (dest_line[len] == 'A') {
			if (*dest & 0x04) { // if A register already set
				error("syntax error: A register set twice\n");
				return false;
			}
			*dest |= 0x04;
		} else if (dest_line[len] == 'D') {
			if (*dest & 0x02) { // if D register already set
				error("syntax error: D register set twice\n");
				return false;
			}
			*dest |= 0x02;
		} else if (dest_line[len] == 'M') {
			if (*dest & 0x01) { // if M register already set
				error("syntax error: M register set twice\n");
				return false;
			}
			*dest |= 0x01;
		} else {
			error("syntax error: invalid destination register %c\n",
			      dest_line[len]);
			return false;
		}

		if (len >= 3) {
			error("syntax error: dest field incorrect length %lu\n",
			      len);
			return false;
		}
	}
	if (len == 0) {
		error("syntax error: dest field empty\n");
		return false;
	}

	return true;
}

/* returns comp bits 0b0acccccc
 */
static bool parse_c_type_comp(const char *comp_line, uint8_t *comp)
{
	size_t len;
	DBGLOG("comp_line: %s\n", comp_line);

	for (len = 0; comp_line[len] == '0' || comp_line[len] == '1' ||
	              comp_line[len] == '-' || comp_line[len] == 'D' ||
	              comp_line[len] == 'A' || comp_line[len] == 'M' ||
	              comp_line[len] == '!' || comp_line[len] == '+' ||
	              comp_line[len] == '&' || comp_line[len] == '|'; ++len) {}
	if (len == 1) {  // 0 1 D A M
		switch (comp_line[0]) {
		case '0': *comp = 0x2a; break; // 0 101010
		case '1': *comp = 0x3f; break; // 0 111111
		case 'D': *comp = 0x0c; break; // 0 001100
		case 'A': *comp = 0x30; break; // 0 110000
		case 'M': *comp = 0x70; break; // 1 110000
		default:
			error("syntax error: comp field incorrect value\n");
			return false;
		}
	} else if (len == 2) {  // -1 !D !A !M -D -A -M 
		if (comp_line[0] == '-') {
			switch (comp_line[1]) {
			case '1': *comp = 0x3a; break; // 0 111010
			case 'D': *comp = 0x0f; break; // 0 001111
			case 'A': *comp = 0x33; break; // 0 110011
			case 'M': *comp = 0x73; break; // 1 110011
			default:
				error("syntax error: comp field incorrect value\n");
				return false;
			}
		} else if (comp_line[0] == '!') {
			switch (comp_line[1]) {
			case 'D': *comp = 0x0d; break; // 0 001101
			case 'A': *comp = 0x31; break; // 0 110001
			case 'M': *comp = 0x71; break; // 1 110001
			default:
				error("syntax error: comp field incorrect value\n");
				return false;
			}
		} else {
			error("syntax error: comp field incorrect value\n");
			return false;
		}
	} else if (len == 3) {
		if (comp_line[0] == 'D') {
			if (comp_line[2] == '1') {  // D+1 D-1
				if (comp_line[1] == '+') {
					*comp = 0x1f; // 0 011111
				} else if (comp_line[1] == '-') {
					*comp = 0x0e; // 0 001110
				} else {
					error("syntax error: comp field "
					      "incorrect value\n");
					return false;
				}
			} else {             // D+A D+M D-A D-M D&A D&M D|A D|M
				if (comp_line[2] == 'M') {
					*comp = 0x40;              // _1_ 000000
				} else if (comp_line[2] == 'A') {
					*comp = 0x00;              // _0_ 000000
				} else {
					error("syntax error: comp field "
					      "incorrect value\n");
					return false;
				}

				switch (comp_line[1]) {
				case '+': *comp |= 0x02; break; // 000010
				case '-': *comp |= 0x13; break; // 010011
				case '&': *comp |= 0x00; break; // 000000
				case '|': *comp |= 0x15; break; // 010101
				default:
					error("syntax error: comp field "
					      "incorrect value\n");
					return false;
				}
			}
		} else {
			// A+1 M+1 A-1 M-1 A-D M-D
			if (comp_line[0] == 'M') {
				*comp = 0x40;              // _1_ 000000
			} else if (comp_line[0] == 'A') {
				*comp = 0x00;              // _0_ 000000
			} else {
				error("syntax error: comp field incorrect value\n");
				return false;
			}

			if (comp_line[1] == '+' && comp_line[2] == '1') {
				*comp |= 0x37;  // 1 110111
			} else if (comp_line[1] == '-' && comp_line[2] == '1') {
				*comp |= 0x32;  // 1 110010
			} else if (comp_line[1] == '-' && comp_line[2] == 'D') {
				*comp |= 0x07;  // 1 000111
			} else {
				error("syntax error: comp field incorrect value\n");
				return false;
			}
		}
	} else {
		error("syntax error: comp field incorrect length %lu\n", len);
		return false;
	}

	return true;
}

/* returns jump bits 0b00000jjj
 */
static bool parse_c_type_jump(const char *jump_line, uint8_t *jump)
{
	size_t len;
	char *err_3rd_char = "syntax error: 3rd letter in jump field incorrect\n";

	DBGLOG("jump_line: %s\n", dest_line);

	for (len = 0; jump_line[len] == 'J' || jump_line[len] == 'G' ||
	              jump_line[len] == 'T' || jump_line[len] == 'E' ||
	              jump_line[len] == 'Q' || jump_line[len] == 'L' ||
	              jump_line[len] == 'N' || jump_line[len] == 'M' ||
	              jump_line[len] == 'P'; ++len) {}
	if (len != 3) {
		error("syntax error: jump field incorrect length %lu\n", len);
		return false;
	}

	if (jump_line[0] == 'J') {                         // if "J__"
		switch (jump_line[1]) {
		case 'G':                                  // if "JG_"
			if (jump_line[2] == 'T') {         // if "JGT"
				*jump = 0x1;
			} else if (jump_line[2] == 'E') {  // if "JGE"
				*jump = 0x3;
			} else {
				error(err_3rd_char); return false;
			}
			break;
		case 'E':                                  // if "JE_"
			if (jump_line[2] == 'Q') {         // if "JEQ"
				*jump = 0x2;
			} else {
				error(err_3rd_char); return false;
			}
			break;
		case 'L':                                  // if "JL_"
			if (jump_line[2] == 'T') {         // if "JLT"
				*jump = 0x4;
			} else if (jump_line[2] == 'E') {  // if "JLE"
				*jump = 0x6;
			} else {
				error(err_3rd_char); return false;
			}
			break;
		case 'N':                                  // if "JN_"
			if (jump_line[2] == 'E') {         // if "JNE"
				*jump = 0x5;
			} else {
				error(err_3rd_char); return false;
			}
			break;
		case 'M':                                  // if "JM_"
			if (jump_line[2] == 'P') {         // if "JMP"
				*jump = 0x7;
			} else {
				error(err_3rd_char); return false;
			}
			break;
		default:
			error("syntax error: 2nd letter in jump field incorrect\n");
			return false;
		}
	} else {
		error("syntax error: jump field doesn't start with 'J'\n");
		return false;
	}

	return true;
}

/* Instruction format: 0b111accccccdddjjj
 * Assumes line begins with actual instruction (prepended whitespace stripped)
 * TODO: eventually just replace all wasteful c-instruction parsing w/ strcmp()
 */
static bool parse_c_type(const char *line, uint16_t *instruction)
{
	bool ret = false;
	char c;
	const char *dest_start = NULL;
	const char *comp_start = NULL;
	const char *jump_start = NULL;
	size_t i = 0;
	uint8_t dest = 0;  // default value when not present
	uint8_t comp = 0;
	uint8_t jump = 0;  // default value when not present

	// set pointers to comp, dest, and/or jump field (if applicable)
	c = line[0];
	for (i = 0; c != ' ' && c != '\t' &&
	            c != '\n' && c != '\0'; ++i) {  // read until end of line
		c = line[i];

		if (c == '=') {                     // indicates dest field
			if (1 <= i && i <= 3) {
				dest_start = &line[0];   // start of line
				// this 'i+1' might be dangerous!
				comp_start = &line[i+1]; // after "[dest]="
			} else {
				error("syntax error: dest incorrect length %lu\n", i);
				return false;
			}
		} else if (c == ';') {              // indicates jump field
			if (1 <= i && i <= 7) {
				// this 'i+1' might be dangerous!
				jump_start = &line[i+1]; // after "[comp];"
			} else {
				error("syntax error: jump incorrect length %lu\n", i);
				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;
		}
	}

	*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 = false;
	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);
			++g_instruction_number;
			break;
		} else if (c >= '!' && c < '~') {
			ret = parse_c_type(&line[i], instruction);
			++g_instruction_number;
			break;
		} else {
			error("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, uint16_t *instruction)
{
	char c;
	bool slash_found = false;
	size_t i;

	// filter out comment lines
	for (i = 0; (c = line[i]) != '\0'; ++i) {
		if (c == ' ' || c == '\t') {
			continue;
		} else if (i == 0 && c == '\0') {
			return false;
		} else if (c == '/') {
			if (slash_found) {    // second slash means comment
				return false;
			}
			slash_found = true;
			continue;
		} else if (slash_found) {
			// this char not slash, but previous was: invalid syntax
			error("syntax error: found '/', comments need '//'\n");
			return false;
		} else {                      // non-whitespace/slash 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 i, file_line, in_line_len;
	char *in_file_path;
	FILE *fp;

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

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

	file_line = 0;
	while (fgets(in_line, MAX_LINE_LEN, fp) != NULL) {  // parse loop
		++file_line;

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

		if (in_line_len == 0 || in_line_len == 1)
			continue;

		g_asm_line = in_line;
		g_asm_line_number = file_line;
		result = parse_line(in_line, &instruction);

		if (result) {
			print_binary_word16(instruction);
			putchar('\n');
		}
	}

	if (fclose(fp)) {
		fprintf(stderr, "Failed to close file %s\n", in_file_path);
		exit(-1);
	}

	return 0;
}