package simulator;

import java.io.File;
import java.util.ArrayList;
import java.util.Scanner;

import org.omg.PortableInterceptor.SYSTEM_EXCEPTION;

import dataStructures.stages.DecodeStage;
import dataStructures.stages.ExecuteStage;
import dataStructures.stages.FetchStage;
import dataStructures.stages.MemoryStage;
import dataStructures.stages.WriteBackStage;

public class Engine {
	static boolean excuteSchedule[][];
	static int numOfInstructions;
	static int clkCycles;
	static FetchStage fetchStage;
	static DecodeStage decodeStage;
	static ExecuteStage executeStage;
	static MemoryStage memoryStage;
	static WriteBackStage writeBackStage;

	public static void main(String[] args) throws Exception {
		Environment env = new Environment();
		fetchStage = new FetchStage(env);
		decodeStage = new DecodeStage(env);
		executeStage = new ExecuteStage(env);
		memoryStage = new MemoryStage(env);
		writeBackStage = new WriteBackStage(env);
		String currentDirectory = System.getProperty("user.dir");
		Scanner sc = new Scanner(new File(currentDirectory + "\\input.txt"));
		env.getInstructionMemory().setInstructions(assembler(parser(sc)));
		initializeSchedule();
		for (int i = 0; i < clkCycles; i++) {
			if (excuteSchedule[4][i]) {
				writeBackStage.run();
			}
			if (excuteSchedule[3][i]) {
				memoryStage.run();
			}
			if (excuteSchedule[2][i]) {
				executeStage.run();
			}
			if (excuteSchedule[1][i]) {
				decodeStage.run();
			}
			if (excuteSchedule[0][i]) {
				fetchStage.run();
			}

		}

	}

	private static void initializeSchedule() {
		clkCycles = 5 + numOfInstructions;
		for (int i = 0; i < numOfInstructions; i++) {
			for (int j = i; j < clkCycles; j++) {
				excuteSchedule[i][j] = true;
			}
		}
	}

	private static int[] assembler(ArrayList<String>[] parser) {
		String[] assemblyCodeInstructions = new String[parser.length];
		for (int i = 0; i < assemblyCodeInstructions.length; i++) {
			String func = "000000000000";
			String op;
			String reg1;
			String reg2;
			String writeReg;
			String command = parser[i].get(0);

			switch (command) {
			// a
			case "sum":
				op = "0000";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				writeReg = regAddress(parser[i].get(3));
				func += "0000";
				assemblyCodeInstructions[i] = op + reg1 + reg2 + writeReg + func;
				break;
			case "mul":
				op = "0000";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				writeReg = regAddress(parser[i].get(3));
				func += "0001";
				assemblyCodeInstructions[i] = op + reg1 + reg2 + writeReg + func;
				break;
			case "div":
				op = "0000";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				writeReg = regAddress(parser[i].get(3));
				func += "0010";
				assemblyCodeInstructions[i] = op + reg1 + reg2 + writeReg + func;
				break;
			case "sge":
				op = "0000";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				writeReg = regAddress(parser[i].get(3));
				func += "0011";
				assemblyCodeInstructions[i] = op + reg1 + reg2 + writeReg + func;
				break;
			case "sle":
				op = "0000";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				writeReg = regAddress(parser[i].get(3));
				func += "0100";
				assemblyCodeInstructions[i] = op + reg1 + reg2 + writeReg + func;
				break;
			case "and":
				op = "0000";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				writeReg = regAddress(parser[i].get(3));
				func += "0101";
				assemblyCodeInstructions[i] = op + reg1 + reg2 + writeReg + func;
				break;
			case "or":
				op = "0000";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				writeReg = regAddress(parser[i].get(3));
				func += "0110";
				assemblyCodeInstructions[i] = op + reg1 + reg2 + writeReg + func;
				break;
			case "eq":
				op = "0000";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				writeReg = regAddress(parser[i].get(3));
				func += "0111";
				assemblyCodeInstructions[i] = op + reg1 + reg2 + writeReg + func;
				break;
			// b
			case "sumi":
				op = "0001";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				func = makeItTweny(parser[i].get(3));
				assemblyCodeInstructions[i] = op + reg1 + reg2 + func;
				break;
			case "ld":
				op = "0010";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				func = makeItTweny(parser[i].get(3));
				assemblyCodeInstructions[i] = op + reg1 + reg2 + func;
				break;
			case "st":
				op = "0011";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				func = makeItTweny(parser[i].get(3));
				assemblyCodeInstructions[i] = op + reg1 + reg2 + func;

				break;
			case "muli":
				op = "0100";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				func = makeItTweny(parser[i].get(3));
				assemblyCodeInstructions[i] = op + reg1 + reg2 + func;

				break;
			case "divi":
				op = "0101";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				func = makeItTweny(parser[i].get(3));
				assemblyCodeInstructions[i] = op + reg1 + reg2 + func;

				break;
			case "inc":
				op = "0110";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				func = makeItTweny(parser[i].get(3));
				assemblyCodeInstructions[i] = op + reg1 + reg2 + func;

				break;
			case "clr":
				op = "0111";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				func = makeItTweny(parser[i].get(3));
				assemblyCodeInstructions[i] = op + reg1 + reg2 + func;

				break;
			case "set":
				op = "1000";
				reg1 = regAddress(parser[i].get(1));
				reg2 = regAddress(parser[i].get(2));
				func = makeItTweny(parser[i].get(3));
				assemblyCodeInstructions[i] = op + reg1 + reg2 + func;

				break;
			// c
			case "not":
				op = "1001";
				reg1 = regAddress(parser[i].get(1));
				func += func;
				assemblyCodeInstructions[i] = op + reg1 + func;

				break;
			case "neg":
				op = "1010";
				reg1 = regAddress(parser[i].get(1));
				func += func;
				assemblyCodeInstructions[i] = op + reg1 + func;

				break;
			// d
			case "skp":
				op = "1011";
				reg1 = regAddress(parser[i].get(1));
				func += func; // dummy func
				assemblyCodeInstructions[i] = op + reg1 + func;

				break;// don't care ?
			case "jmp":
				op = "1100";
				func = "00000000";
				String address = parser[i].get(1);
				assemblyCodeInstructions[i] = op + func + makeItTweny("" + findInParser(parser, address)); // not

				break;
			default:
				assemblyCodeInstructions[i] = "11111111111111111111111111111111";
			}

		}
		numOfInstructions = assemblyCodeInstructions.length;
		int []assemblyCodeInstructionsInt=new int[assemblyCodeInstructions.length];
		for (int i = 0; i < assemblyCodeInstructionsInt.length; i++) {
			 assemblyCodeInstructionsInt[i]=Integer.parseInt(assemblyCodeInstructions[i], 2);

		}

		return assemblyCodeInstructionsInt;

	}

	private static int findInParser(ArrayList<String>[] parser, String address) {
		for (int i = 0; i < parser.length; i++) {
			if (parser[i].get(0).equals(address))
				return i;
		}
		return -1;
	}

	private static String regAddress(String regName) {
		switch (regName) {
		case "g0":
			return "0000";
		case "g1":
			return "0001";
		case "g2":
			return "0010";
		case "g3":
			return "0011";
		case "g4":
			return "0100";
		case "g5":
			return "0101";
		case "g6":
			return "0110";
		case "g7":
			return "0111";
		case "sp":
			return "1000";
		case "p0":
			return "1001";
		case "p1":
			return "1010";
		case "p2":
			return "1011";
		case "p3":
			return "1100";
		case "r0":
			return "1101";
		case "zero":
			return "1110";
		case "pc":
			return "1111";

		}
		return "wrongRegName";
	}

	private static String makeItTweny(String i) {
		String s = Integer.toBinaryString(Integer.parseInt(i));
		while (s.length() < 20)
			s = "0" + s;
		return s;
	}

	private static ArrayList<String>[] parser(Scanner sc) {
		ArrayList<String> temp = new ArrayList<String>();

		while (sc.hasNextLine()) {
			temp.add(sc.nextLine());
		}
		ArrayList<String> returned[] = (ArrayList<String>[]) new ArrayList[temp.size()];
		for (int i = 0; i < returned.length; i++) {
			// System.out.println(temp.get(i));

			String[] s = temp.get(i).split(" ");
			System.out.println(temp.get(i));
			returned[i] = new ArrayList<String>();
			for (int j = 0; j < s.length; j++) {

				returned[i].add(s[j]);
			}
		}

		return returned;
	}

}