-module(execdaemon).

 -export([open/0, terminate/1, command/3, read_from/1, wait_for_event/1, run/2]).

 open() ->

     Pid = spawn(fun startup/0),

     Pid ! {subscribe, self()},

     receive

 	{subscribed, Pid2} when Pid == Pid2 -> Pid

     end.

 startup() ->

     Port = open_port({spawn, jukebox:priv_dir() ++ "/execdaemon/execdaemon"}, [stream, use_stdio, eof]),

     mainloop(Port, 1, [], [], "").

 mainloop(Port, ReqNum, Requests, Subscribers, Acc) ->

     receive

 	{subscribe, Pid} ->

 	    Pid ! {subscribed, self()},

 	    mainloop(Port, ReqNum, Requests, [Pid | Subscribers], Acc);

 	execdaemon_terminate ->

 	    port_command(Port, [0]),

 	    mainloop(Port, ReqNum, Requests, Subscribers, Acc);

 	{execdaemon_command, Pid, Command, Arg} ->

 	    port_command(Port, lists:flatten([integer_to_list(ReqNum), ":",

 					      atom_to_list(Command), ",", Arg, [0]])),

 	    mainloop(Port, ReqNum + 1, [{ReqNum, Pid} | Requests], Subscribers, Acc);

 	{_Port1, eof} ->

 	    {_, Pids} = lists:unzip(Requests),

 	    send_to_subs(Pids ++ Subscribers, {execdaemon_eof, self()}),

 	    port_close(Port);

 	{_Port1, {data, Data}} ->

 	    {NewRequests, NewAcc} = process_received(Subscribers, Requests, Acc, Data),

 	    mainloop(Port, ReqNum, NewRequests, Subscribers, NewAcc)

     end.

 send_to_subs(Subscribers, Msg) ->

     lists:foreach(fun (Subscriber) -> Subscriber ! Msg end, Subscribers).

 process_received(_Subscribers, Requests, Acc, []) ->

     {Requests, Acc};

 process_received(Subscribers, Requests, Acc, [0 | Rest]) ->

     {ReqNum, Code, Aux} = split_response(lists:reverse(Acc)),

     if

 	ReqNum == 0 ->

 	    send_to_subs(Subscribers, {execdaemon_event, self(), Code, Aux}),

 	    process_received(Subscribers, Requests, [], Rest);

 	true ->

 	    case proplists:get_value(ReqNum, Requests, none) of

 		none -> process_received(Subscribers, Requests, [], Rest);

 		Pid ->

 		    Pid ! {execdaemon_response, self(), Code, Aux},

 		    process_received(Subscribers, proplists:delete(ReqNum, Requests), [], Rest)

 	    end

     end;

 process_received(Subscribers, Requests, Acc, [Ch | Rest]) ->

     process_received(Subscribers, Requests, [Ch | Acc], Rest).

 split_response(Str) ->

     {ReqNum, ":" ++ CmdArg} = lists:split(string:chr(Str, $:) - 1, Str),

     {Cmd, "," ++ Arg} = lists:split(string:chr(CmdArg, $,) - 1, CmdArg),

     {list_to_integer(ReqNum), list_to_atom(Cmd), Arg}.

 terminate(Pid) ->

     Pid ! execdaemon_terminate.

 command(Pid, Command, Arg) ->

     Pid ! {execdaemon_command, self(), Command, Arg},

     read_from(Pid).

 read_from(Pid) ->

     receive

 	{execdaemon_response, Pid1, Code, Aux} when Pid == Pid1 ->

 	    {Code, Aux};

 	{execdaemon_eof, Pid1} when Pid == Pid1 ->

 	    eof

     end.

 wait_for_event(Pid) ->

     receive

 	{execdaemon_event, Pid1, Code, Aux} when Pid == Pid1 ->

 	    {Code, Aux};

 	{execdaemon_eof, Pid1} when Pid == Pid1 ->

 	    eof

     end.

 run(Program, Argvec) ->

     Pid = open(),

     command(Pid, program, Program),

     command(Pid, argc, integer_to_list(length(Argvec))),

     lists:foldl(fun (Arg, Count) ->

 			command(Pid, arg, [integer_to_list(Count), ",", Arg]),

 			Count + 1

 		end, 0, Argvec),

     command(Pid, execv, ""),

     Pid.