-module(turingMachine2).
-export([start/1,startN/1,blankStack/1]).

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

start(Word) ->
    SL=spawn(turingMachine2,blankStack,[self()]),
    SR=spawn(turingMachine2,blankStack,[self()]),
    writeWordToStack(Word,SR),
    control(initial(),SL,SR).

writeWordToStack([],Stack) ->
    ok;
writeWordToStack([A|As],Stack) ->
    writeWordToStack(As,Stack),
    push(A,Stack).

control(Q,SL,SR) ->
    A=pop(SR),
    case catch delta(Q,A) of
	{P,B,r} ->
	    %io:format("~w,~w -> ~w,~w,~w~n",[Q,A,P,B,r]),
	    push(B,SL),
	    control(P,SL,SR);
	{P,B,l} ->
	    %io:format("~w,~w -> ~w,~w,~w~n",[Q,A,P,B,l]),
	    push(B,SR),
	    C=pop(SL),
	    push(C,SR),
	    control(P,SL,SR);
	{'EXIT',_} ->
	    push(A,SR),
	    io:format("~w~n",[final(Q)]),
	    outputStack(SL),
	    io:format("|",[]),
	    outputStack(SR),
	    io:nl()
    end.

outputStack(Stack) ->
    case pop(Stack) of
	blank ->
	    ok;
	A -> 
	    io:format("~w",[A]),
	    outputStack(Stack)
    end.

push(V,Stack) -> Stack!V.

pop(Stack) ->
    Stack!get,
    receive
	X -> X
    end.

stack(P) ->
    receive
	get -> get;
	X -> stack(P),
	     P!X,
	     stack(P)
    end.

blankStack(P) ->
    stack(P),
    P!blank,
    blankStack(P).

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)].