sprocket

-module(sprocket@internal@reducer).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-define(FILEPATH, "src/sprocket/internal/reducer.gleam").
-export([handle_message/2, start/3, shutdown/1, get_model/1, dispatch/2]).
-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(GEJ, GEK) :: shutdown |
    {get_model, gleam@erlang@process:subject(GEJ)} |
    {reducer_dispatch, GEK}.

-opaque state(GEL, GEM) :: {state,
        gleam@erlang@process:subject(reducer_message(GEL, GEM)),
        GEL,
        fun((GEL, GEM, fun((GEM) -> nil)) -> GEL),
        fun((GEL) -> nil)}.

-file("src/sprocket/internal/reducer.gleam", 45).
?DOC(false).
-spec handle_message(state(GFF, GFG), reducer_message(GFF, GFG)) -> gleam@otp@actor:next(state(GFF, GFG), reducer_message(GFF, GFG)).
handle_message(State, Message) ->
    case Message of
        shutdown ->
            gleam@otp@actor:stop();

        {get_model, 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,
            Dispach = fun(Msg@1) ->
                gleam@erlang@process:send(Self, {reducer_dispatch, Msg@1})
            end,
            Updated_model = Update(Model@1, Msg, Dispach),
            case Model@1 /= Updated_model of
                true ->
                    Notify(Updated_model);

                _ ->
                    nil
            end,
            gleam@otp@actor:continue(
                begin
                    _record = State,
                    {state,
                        erlang:element(2, _record),
                        Updated_model,
                        erlang:element(4, _record),
                        erlang:element(5, _record)}
                end
            )
    end.

-file("src/sprocket/internal/reducer.gleam", 94).
?DOC(false).
-spec start(
    fun((fun((GFS) -> nil)) -> GFR),
    fun((GFR, GFS, fun((GFS) -> nil)) -> GFR),
    fun((GFR) -> nil)
) -> {ok, gleam@erlang@process:subject(reducer_message(GFR, GFS))} |
    {error, gleam@otp@actor:start_error()}.
start(Initialize, Update, Notify) ->
    _pipe@2 = gleam@otp@actor:new_with_initialiser(
        1000,
        fun(Self) ->
            Dispatch = fun(Msg) ->
                gleam@erlang@process:send(Self, {reducer_dispatch, Msg})
            end,
            Model = {state, Self, Initialize(Dispatch), Update, Notify},
            _pipe = gleam@otp@actor:initialised(Model),
            _pipe@1 = gleam@otp@actor:returning(_pipe, Self),
            {ok, _pipe@1}
        end
    ),
    _pipe@3 = gleam@otp@actor:on_message(_pipe@2, fun handle_message/2),
    _pipe@4 = gleam@otp@actor:start(_pipe@3),
    gleam@result:map(_pipe@4, fun(Started) -> erlang:element(3, Started) end).

-file("src/sprocket/internal/reducer.gleam", 120).
?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", 125).
?DOC(false).
-spec get_model(gleam@erlang@process:subject(reducer_message(GGE, any()))) -> GGE.
get_model(Subject) ->
    gleam@erlang@process:call(
        Subject,
        1000,
        fun(Field@0) -> {get_model, Field@0} end
    ).

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