sprocket

-module(sprocket@internal@reducer).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([init/3, shutdown/1, get_state/1, dispatch/2, handle_message/2, start/3, process_commands/1]).
-export_type([reducer_actor/0, reducer_message/2, state/2]).

-type reducer_actor() :: {initialized, fun(() -> gleam@dynamic:dynamic_())} |
    {running, gleam@dynamic:dynamic_(), fun(() -> nil)}.

-type reducer_message(KGR, KGS) :: shutdown |
    {get_state, gleam@erlang@process:subject(KGR)} |
    {reducer_dispatch, KGS} |
    {push_commands, list(fun((fun((KGS) -> nil)) -> nil))} |
    process_commands.

-opaque state(KGT, KGU) :: {state,
        gleam@erlang@process:subject(reducer_message(KGT, KGU)),
        KGT,
        fun((KGT, KGU) -> {KGT, list(fun((fun((KGU) -> nil)) -> nil))}),
        fun((KGT) -> nil),
        list(fun((fun((KGU) -> nil)) -> nil))}.

-file("/home/runner/work/sprocket/sprocket/src/sprocket/internal/reducer.gleam", 41).
-spec init(
    KHC,
    fun((KHC, KHD) -> {KHC, list(fun((fun((KHD) -> nil)) -> nil))}),
    fun((KHC) -> nil)
) -> fun(() -> gleam@otp@actor:init_result(state(KHC, KHD), reducer_message(KHC, KHD))).
init(Initial, Update, Notify) ->
    fun() ->
        Self = gleam@erlang@process:new_subject(),
        Selector = gleam@erlang@process:selecting(
            gleam_erlang_ffi:new_selector(),
            Self,
            fun gleam@function:identity/1
        ),
        {ready, {state, Self, Initial, Update, Notify, []}, Selector}
    end.

-file("/home/runner/work/sprocket/sprocket/src/sprocket/internal/reducer.gleam", 139).
-spec shutdown(gleam@erlang@process:subject(reducer_message(any(), any()))) -> nil.
shutdown(Subject) ->
    gleam@erlang@process:send(Subject, shutdown).

-file("/home/runner/work/sprocket/sprocket/src/sprocket/internal/reducer.gleam", 144).
-spec get_state(gleam@erlang@process:subject(reducer_message(KIH, any()))) -> KIH.
get_state(Subject) ->
    gleam@erlang@process:call(
        Subject,
        fun(_capture) -> {get_state, _capture} end,
        1000
    ).

-file("/home/runner/work/sprocket/sprocket/src/sprocket/internal/reducer.gleam", 149).
-spec dispatch(gleam@erlang@process:subject(reducer_message(any(), KIJ)), KIJ) -> nil.
dispatch(Subject, Msg) ->
    gleam@otp@actor:send(Subject, {reducer_dispatch, Msg}).

-file("/home/runner/work/sprocket/sprocket/src/sprocket/internal/reducer.gleam", 54).
-spec handle_message(reducer_message(KHM, KHN), state(KHM, KHN)) -> gleam@otp@actor:next(reducer_message(KHM, KHN), state(KHM, KHN)).
handle_message(Message, State) ->
    case Message of
        shutdown ->
            {stop, normal};

        {get_state, Reply_with} ->
            {state, _, Model, _, _, _} = State,
            gleam@erlang@process:send(Reply_with, Model),
            gleam@otp@actor:continue(State);

        {reducer_dispatch, Msg} ->
            {state, Self, Model@1, Update, Notify, _} = State,
            {Updated_model, Cmds} = Update(Model@1, Msg),
            gleam@erlang@process:send(Self, {push_commands, Cmds}),
            Notify(Model@1),
            gleam@otp@actor:continue(erlang:setelement(3, State, Updated_model));

        {push_commands, Cmds@1} ->
            {state, _, _, _, _, Pending_commands} = State,
            Pending_commands@1 = lists:append(Pending_commands, Cmds@1),
            gleam@otp@actor:continue(
                erlang:setelement(6, State, Pending_commands@1)
            );

        process_commands ->
            {state, Self@1, _, _, _, Pending_commands@2} = State,
            _pipe = Pending_commands@2,
            gleam@list:each(
                _pipe,
                fun(Cmd) ->
                    gleam@erlang@process:start(
                        fun() ->
                            Cmd(fun(_capture) -> dispatch(Self@1, _capture) end)
                        end,
                        false
                    )
                end
            ),
            gleam@otp@actor:continue(erlang:setelement(6, State, []))
    end.

-file("/home/runner/work/sprocket/sprocket/src/sprocket/internal/reducer.gleam", 118).
-spec start(
    {KHX, list(fun((fun((KHY) -> nil)) -> nil))},
    fun((KHX, KHY) -> {KHX, list(fun((fun((KHY) -> nil)) -> nil))}),
    fun((KHX) -> nil)
) -> {ok, gleam@erlang@process:subject(reducer_message(KHX, KHY))} |
    {error, gleam@otp@actor:start_error()}.
start(Initial, Update, Notify) ->
    {Model, Cmds} = Initial,
    gleam@result:map(
        gleam@otp@actor:start_spec(
            {spec, init(Model, Update, Notify), 1000, fun handle_message/2}
        ),
        fun(Self) ->
            gleam@erlang@process:send(Self, {push_commands, Cmds}),
            Self
        end
    ).

-file("/home/runner/work/sprocket/sprocket/src/sprocket/internal/reducer.gleam", 158).
-spec process_commands(
    gleam@erlang@process:subject(reducer_message(any(), any()))
) -> nil.
process_commands(Subject) ->
    gleam@erlang@process:send(Subject, process_commands).