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