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

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(false).

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

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

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

-file("src/sprocket/internal/reducer.gleam", 41).
?DOC(false).
-spec init(
    KVH,
    fun((KVH, KVI) -> {KVH, list(fun((fun((KVI) -> nil)) -> nil))}),
    fun((KVH) -> nil)
) -> fun(() -> gleam@otp@actor:init_result(state(KVH, KVI), reducer_message(KVH, KVI))).
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("src/sprocket/internal/reducer.gleam", 139).
?DOC(false).
-spec shutdown(gleam@erlang@process:subject(reducer_message(any(), any()))) -> nil.
shutdown(Subject) ->
    gleam@erlang@process:send(Subject, shutdown).

-file("src/sprocket/internal/reducer.gleam", 144).
?DOC(false).
-spec get_state(gleam@erlang@process:subject(reducer_message(KWM, any()))) -> KWM.
get_state(Subject) ->
    gleam@erlang@process:call(
        Subject,
        fun(Field@0) -> {get_state, Field@0} end,
        1000
    ).

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

-file("src/sprocket/internal/reducer.gleam", 54).
?DOC(false).
-spec handle_message(reducer_message(KVR, KVS), state(KVR, KVS)) -> gleam@otp@actor:next(reducer_message(KVR, KVS), state(KVR, KVS)).
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(
                begin
                    _record = State,
                    {state,
                        erlang:element(2, _record),
                        Updated_model,
                        erlang:element(4, _record),
                        erlang:element(5, _record),
                        erlang:element(6, _record)}
                end
            );

        {push_commands, Cmds@1} ->
            {state, _, _, _, _, Pending_commands} = State,
            Pending_commands@1 = lists:append(Pending_commands, Cmds@1),
            gleam@otp@actor:continue(
                begin
                    _record@1 = State,
                    {state,
                        erlang:element(2, _record@1),
                        erlang:element(3, _record@1),
                        erlang:element(4, _record@1),
                        erlang:element(5, _record@1),
                        Pending_commands@1}
                end
            );

        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(
                begin
                    _record@2 = State,
                    {state,
                        erlang:element(2, _record@2),
                        erlang:element(3, _record@2),
                        erlang:element(4, _record@2),
                        erlang:element(5, _record@2),
                        []}
                end
            )
    end.

-file("src/sprocket/internal/reducer.gleam", 118).
?DOC(false).
-spec start(
    {KWC, list(fun((fun((KWD) -> nil)) -> nil))},
    fun((KWC, KWD) -> {KWC, list(fun((fun((KWD) -> nil)) -> nil))}),
    fun((KWC) -> nil)
) -> {ok, gleam@erlang@process:subject(reducer_message(KWC, KWD))} |
    {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("src/sprocket/internal/reducer.gleam", 158).
?DOC(false).
-spec process_commands(
    gleam@erlang@process:subject(reducer_message(any(), any()))
) -> nil.
process_commands(Subject) ->
    gleam@erlang@process:send(Subject, process_commands).