// Contents: Turing Machine Simulator.
// Author:   Sterr, Ambrose
// Date:     03/31/03
// Email:    ads7@pitt.edu
// IDNUM:    2896
// File ends with "End-of-File"

// Known problems:  Turing Machine Simulator can only hold machines with "max" or fewer instruction lines 

//**********************************************//
// Version 1.1:							//
// REVISED 02/27/2006					//
// By Ambrose Sterr						//
// For Theory of Computation @ Marlboro College	//
// The limit on the machine size has been removed and	//
// the tape now dynamically grows to accept input.	//
// New spaces in the tape are initialized with the '_'	//
// character.							//
// Pause is now optional, and the machine is a little bit	//
// more robust and less prone to unhandled errors.	//
//**********************************************//

import java.io.* ;
import java.util.StringTokenizer ;
import java.util.Date ;

public class TuringMachine {

//	static final int max = 25 ;
//	static String[][] loadedMachine = new String[max][5] ;
	static String loadedMachine[][], loadedTape, istate ;
	static int ipos, pause, lines;

	public static void main(String[] args) {

//		String arg0, arg1, arg2 ;
//		int arg3, arg4 ;
		try {
			if (args.length == 4)
				pause = 1;
			else
				pause = Integer.parseInt(args[4]);
//		arg0 = args[0] ;
//		arg1 = args[1] ;
//		arg2 = args[2] ;
//		arg3 = Integer.parseInt(args[3]) ;

			istate = args[1] ;
			ipos = Integer.parseInt(args[3]) ;
//		pause = arg4 ;

			lines = -1;

		} catch (Exception e) {
			System.out.println("Invalid arguments.");
		}
		readMachine(args[0]) ;
		readTape(args[2]) ;
		runMachine() ;
	}

	public static void readMachine(String machine) {

		//Reads machine file:

		FileReader machineReader ;
		BufferedReader bufferedMachine ;

		try {
			machineReader = new FileReader(machine) ;
			bufferedMachine = new BufferedReader(machineReader) ;
//			bufferedMachine.mark()
			String junk = "";
			while (junk != null) {
				junk = bufferedMachine.readLine();
				lines++;
			}
			if (lines <= 0) {
				System.out.println("Machine file is empty!");
				System.exit(0);
			}
			bufferedMachine.close();
			loadedMachine = new String[lines][5] ;
			machineReader = new FileReader(machine);
			bufferedMachine = new BufferedReader(machineReader);
			StringTokenizer tokenizer ;
			String line ;

			int lineNumber = 0 ;
			line = bufferedMachine.readLine() ;
			while (line != null) {
				tokenizer = new StringTokenizer (line) ;

				loadedMachine[lineNumber][0] = tokenizer.nextToken() ;
				loadedMachine[lineNumber][1] = tokenizer.nextToken() ;
				loadedMachine[lineNumber][2] = tokenizer.nextToken() ;
				loadedMachine[lineNumber][3] = tokenizer.nextToken() ;
				loadedMachine[lineNumber][4] = tokenizer.nextToken() ;

				lineNumber++ ;
				line = bufferedMachine.readLine() ;
			}
			bufferedMachine.close() ;
		} catch (IOException e) { System.out.println ("Machine read error:" + e); System.exit(0);}

	}

	public static void readTape(String tape) {

		//Reads tape file:

		FileReader tapeReader ;
		BufferedReader bufferedTape ;

		try {
			tapeReader = new FileReader(tape) ;
			bufferedTape = new BufferedReader(tapeReader) ;
			loadedTape = bufferedTape.readLine() ;
			if (loadedTape == null) { loadedTape = "_"; }
			bufferedTape.close() ;
		} catch (IOException e) { System.out.println ("Tape read error:" + e); System.exit(0);}

	}

	public static void sleep(long milliseconds) {
		if (milliseconds > 0) {
			Date d ; 
			long start, now ; 
			d = new Date() ; 
			start = d.getTime() ; 
			do { d = new Date() ; now = d.getTime() ; } while ( (now - start) < milliseconds ) ; 
		}
	}

	public static void runMachine() {

		String state, stateStr, chr, move ;
		//char chr ;
		if ((ipos > loadedTape.length()) || ipos < 0) {
			System.out.println("Initial position is off of the tape.");
			System.exit(0);
		}
		int pos;
		int cmdLine = 0 ;

		//Sets up initial state:

		System.out.println ("STARTING MACHINE...") ;
		System.out.println (loadedTape) ;
		state = istate ;
		pos = ipos ;
		stateStr = "" ;
		for (int i = 0; i < pos; i++) {
			stateStr = stateStr + " " ;
		}
		stateStr = stateStr + "^" + " " + state ;
		System.out.println (stateStr) ;
		System.out.println ("RUNNING...") ;

		while (cmdLine < lines) {

			sleep(pause) ;
			if (loadedTape.length() == pos+1)
				loadedTape = loadedTape + "_";
//			if (loaded
			chr = "" + loadedTape.charAt(pos) ;

			for (cmdLine = 0; (cmdLine < lines) && (!(state.equals(loadedMachine[cmdLine][0])) || !(chr.equals(loadedMachine[cmdLine][1]))); cmdLine++) { }


			if (cmdLine < lines) {
				state = loadedMachine[cmdLine][4] ;
				stateStr = "" ;	
				loadedTape = loadedTape.substring(0,pos) + loadedMachine[cmdLine][2] + loadedTape.substring(pos + 1) ;

				if (loadedMachine[cmdLine][3].equals("right"))
					pos++ ;
				else if (loadedMachine[cmdLine][3].equals("left"))
					pos-- ;

				for (int j = 0; j < pos; j++) {
					stateStr = stateStr + " " ;
				}
				stateStr = stateStr + "^" + " " + state ;
			}
			else {
				System.out.println("HALTED...") ;
			}

			System.out.println (loadedTape) ;
			System.out.println (stateStr) ;

		}
	}
	
}