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

#include <unistd.h>

uint8_t MEM[16384];
uint16_t PROG[16384];

unsigned int  memPointer=0;
unsigned int progPointer=0;

bool Debug=false;
bool Allegro=true;
bool ManualStep = true;
double IPS;//Instructions Per Second

void printData();
void printState();
void newState();

void* IO(void* data);
void loadProgram(char* name);

void main(int argc, char** argv){
	int breakLines[argc];
	int am_breaks=0;

	for(int i=1;i<argc-1;i++){
		if(!strcmp("NoAllegro",argv[i]))
			Allegro = false;
		else if(!strcmp("Debug",argv[i])){
			Debug = true;
		}else if(!strcmp("IPS", argv[i])){
			i++;
			IPS = atof(argv[i]);
			ManualStep = false;
		}else if(!strcmp("Break",argv[i])){
			i++;
			breakLines[am_breaks]=atoi(argv[i]);
			am_breaks++;
		}
	}

	loadProgram(argv[argc-1]);
	//simpleProgram
	//PROG[0] = 3<<14;
	//PROG[1] = 0;
	//PROG[2] = 1<<14;
	
	
	//Start thread for handling I/O
	if(Allegro){
		pthread_t IOthread;
		pthread_create(&IOthread,NULL,&IO,NULL);
	}
	while(true){
		if(Debug){
			printState();
		}
		if(ManualStep){
			printf("Press enter to go to the next state:\n");
			getchar();
		}
		else
			usleep((int)(1000000.0/IPS));
		newState();
	}
}
//Makes sure that only the 14 least significant
//bits are set to true.
#define B14(a) a &((1<<14)-1)

void printData(){
	for(int i=B14((memPointer>>3)-8); i!=B14((memPointer>>3)+9); i=B14(i+1)){
		printf("%04x: %d%d%d%d%d%d%d%d\n", i, MEM[i]>>7,
				MEM[i]>>6&1, MEM[i]>>5&1, MEM[i]>>4&1,
				MEM[i]>>3&1, MEM[i]>>2&1, MEM[i]>>1&1,
				MEM[i]&1);
		if(i==memPointer>>3){
			char pointString[16];
			memset(pointString, ' ', 14);
			pointString[14]= '\n';
			pointString[15]= '\0';
			pointString[13-(memPointer&((1<<3)-1))] = '^';
			printf(pointString);
		}
	}
}

void printProgram(){
	printf("printProgram\n");
	for(int i=B14((progPointer)-8); i!=B14((progPointer)+9); i=B14(i+1)){
		if(i==(progPointer))printf("> ");
		else printf("  ");
		printf("%04x: ", i);
		unsigned int instruction = PROG[i];
		switch(instruction >> 14){
			case(0):
				printf("Flip");
				break;
			case(1):
				printf("JMP if 1 too %04x", B14(instruction));
				break;
			case(2):
				printf("Left");
				break;
			case(3):
				printf("Right");
				break;
		}
		printf("\n");
	}
	printf("end printProgram\n");
}

void printState(){
	printf("Memory pointer:%04x\n",memPointer);
	printData();
	printf("Program pointer:\n");
	printProgram();
}

#define WRITEABLE(addr) addr!=((1<<14)-1)

void newState(){
	unsigned int instruction = PROG[progPointer];

	progPointer ++;
	switch(instruction >> 14){
		case(0)://Flip
			if(WRITEABLE(memPointer>>3))
				MEM[memPointer>>3] ^= 0x1<<(memPointer&0x7);
			break;
		case(1)://Jmp if 1
			if(MEM[memPointer>>3] &0x1<<(memPointer&0x7))
				progPointer = instruction & ((1<<14)-1);
			break;
		case(2)://Left
			memPointer=B14(memPointer-1);
			break;
		case(3)://Right
			memPointer=B14(memPointer+1);
			break;
	}
}

struct LinkedList;

struct LinkedList{
	struct LinkedList* next;
	char* string;
	int value;
};

void add(struct LinkedList** head, char* string, int value){
	struct LinkedList* new = malloc(sizeof(struct LinkedList));
	new->string = malloc((strlen(string)+1)*sizeof(char));
	strcpy(new->string, string);
	new->next = *head;
	new->value = value;
	*head = new;
}

int lookup(struct LinkedList* head, char* string){
	for(;head;head=head->next){
		if(!strcmp(string,head->string)){
			return head->value;
		}
	}
	return -1;
}

struct Stack;

struct Stack{
	struct Stack* under;
	int n;
	int index;
};

void push(struct Stack** stack, int n, int index){
	struct Stack* new = malloc(sizeof(struct Stack));
	new->n = n;
	new->index = index;
	new->under = *stack;
	*stack = new;
}

void pop(struct Stack** stack, int* n,int* index){
	*n = (*stack)->n;
	*index = (*stack)->index;
	*stack = (*stack)->under;
}


void loadProgram(char* name){
	FILE* f = fopen(name,"r");

	char instruction[20];
	int number;

	char* line = NULL;
	size_t n = 0;

	struct LinkedList* labels = NULL;
	struct LinkedList* references=NULL;

	struct Stack* repeats = NULL;


	int i=0;
	while(-1!=getline(&line, &n, f)){
		//comment
		if(line[0]=='/')continue;
		//label
		if(line[0]==':'){
			char* labelStr = strtok(line," :\n\t");
			add(&labels, labelStr, i);
		}

		char* instruction = strtok(line," \n\t");
		if(instruction==NULL)continue;
		if(!strcmp(instruction,"JMP")){
			char* address = strtok(NULL," \n\t");
			PROG[i] = 1<<14;
			add(&references,address,i);
			i++;
		}
		else if(!strcmp(instruction,"Repeat")){
			char* nString = strtok(NULL," \n\t");
			n = atoi(nString);
			push(&repeats,n,i);
			
		}
		else if(!strcmp(instruction,"End")){
			int n;
			int index;
			pop(&repeats,&n,&index);
			for(int j=1;j<n;j++){
				memcpy(PROG+index+j*(i-index),PROG+index,(i-index)*sizeof(uint16_t));
			}
			i+=(n-1)*(i-index);
			
		}
		else{
		
		char* numberStr = strtok(NULL," \n\t");
		int number=-1;
		if(numberStr!=NULL)number = atoi(numberStr);
		
		
		int instructionCode=0;
		int copies =1;

		int address =0;
		
		if(!strcmp(instruction,"Flip"))
			instructionCode=0;
		else if(!strcmp(instruction,"Left")){
			instructionCode=2;
			if(number!=-1)copies=number;
		}else if(!strcmp(instruction,"Right")){
			instructionCode=3;
			if(number!=-1)copies=number;
		}else if(!strcmp(instruction,"JMP")){
			instructionCode=1;
			if(number!=-1)address=number;
		}
		else{
			continue;
		}
		for(int j=0;j<copies;j++){
			PROG[i+j] = (instructionCode<<14) + address;
		}
		
		i+=copies;
		}

	}
	printf("%d/%d=%f%% instructions used\n", i,1<<14,((float)(i*100))/((float)(1<<14)));
	for(struct LinkedList* head = references; head!=NULL; head=head->next){
		int referenceIndex = head->value;
		char* string = head->string;
		int labelIndex = lookup(labels, string);
		if(labelIndex==-1){
			printf("Label %s does not exist\n", string);
			exit(0);
		}
		PROG[referenceIndex] += labelIndex;
	}
}

// vim: cc=100