-module(turingMachine).
-export([start/1,startN/1,startTapeEntry/2,tapeEntry/3]).

startN(N) ->
    start(repeat(N,a)).%++repeat(N,b)).

start(Word) ->
    TapeEntry=spawn(turingMachine,startTapeEntry,[Word,nothing]),
    control(initial(),TapeEntry).
    
    

control(Q,TapeEntry) ->
    TapeEntry!{get,self()},
    receive
	{L,A,R} -> case catch delta(Q,A) of
		       {P,B,D} ->
			   %io:format("~w,~w -> ~w,~w,~w~n",[Q,A,P,B,D]),
			   TapeEntry!{update,B},
			   control(P,case D of
					 r -> R;
					 l -> L
				     end);
		       {'EXIT',_} ->
			   io:format("~w~n",[final(Q)]),
			   outputTape(TapeEntry)
		   end
    end.

startTapeEntry([A|As],Left) ->
    Right=spawn(turingMachine,startTapeEntry,[As,self()]),
    tapeEntry(Left,A,Right);
startTapeEntry([],Left) ->
    tapeEntry(Left,blank,nothing).

outputTape(TapeEntry) ->
    TapeEntry!{getTerminate,self()},
    receive
	{_,blank,_} ->
	    io:format("~n",[]);
	{_,A,Next} ->
	    io:format("~w",[A]),
	    outputTape(Next)
    end.

tapeEntry(L,A,R) ->
    receive
	{get,P} -> 
	    NewL=case L of
		     nothing ->
			 spawn(turingMachine,tapeEntry,[nothing,blank,self()]);
		     _ -> L
		 end,
	    NewR=case R of
		     nothing ->
			 spawn(turingMachine,tapeEntry,[self(),blank,nothing]);
		     _ -> R
		 end,
	    P!{NewL,A,NewR},
	    tapeEntry(NewL,A,NewR);
	{update,B} ->
	    tapeEntry(L,B,R);
        {getTerminate,P} ->
	    P!{L,A,R}
    end.

initial() -> q0.

%delta(q0,a) -> {q1,blank,r};
%delta(q0,blank) -> {f,blank,r};
%delta(q1,a) -> {q1,a,r};
%delta(q1,b) -> {q2,b,r};
%delta(q2,b) -> {q2,b,r};
%delta(q2,blank) -> {q3,blank,l};
%delta(q3,b) -> {q4,blank,l};
%delta(q4,b) -> {q4,b,l};
%delta(q4,a) -> {q4,a,l};
%delta(q4,blank) -> {q0,blank,r}.

delta(q0,a) -> {q1,b,r};
delta(q1,a) -> {q1,a,r};
delta(q1,c) -> {q1,c,r};
delta(q1,blank) -> {q2,c,l};
delta(q2,c) -> {q2,c,l};
delta(q2,a) -> {q2,a,l};
delta(q2,b) -> {q0,b,r};
delta(q0,c) -> {q3,c,l};
delta(q3,b) -> {q3,b,l};
delta(q3,blank) -> {f,blank,r}.

final(f) -> true;
final(_) -> false.

repeat(0,_) ->
    [];
repeat(N,A) ->
    [A|repeat(N-1,A)].