sprocket

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

-export([init/3, 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(KDF, KDG) :: shutdown |
    {get_model, gleam@erlang@process:subject(KDF)} |
    {reducer_dispatch, KDG}.

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

-file("src/sprocket/internal/reducer.gleam", 40).
?DOC(false).
-spec init(
    fun((fun((KDS) -> nil)) -> KDR),
    fun((KDR, KDS, fun((KDS) -> nil)) -> KDR),
    fun((KDR) -> nil)
) -> fun(() -> gleam@otp@actor:init_result(state(KDR, KDS), reducer_message(KDR, KDS))).
init(Initialize, 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
        ),
        Dispach = fun(Msg) ->
            gleam@erlang@process:send(Self, {reducer_dispatch, Msg})
        end,
        {ready, {state, Self, Initialize(Dispach), Update, Notify}, Selector}
    end.

-file("src/sprocket/internal/reducer.gleam", 55).
?DOC(false).
-spec handle_message(reducer_message(KEE, KEF), state(KEE, KEF)) -> gleam@otp@actor:next(reducer_message(KEE, KEF), state(KEE, KEF)).
handle_message(Message, State) ->
    case Message of
        shutdown ->
            {stop, normal};

        {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", 104).
?DOC(false).
-spec start(
    fun((fun((KEQ) -> nil)) -> KEP),
    fun((KEP, KEQ, fun((KEQ) -> nil)) -> KEP),
    fun((KEP) -> nil)
) -> {ok, gleam@erlang@process:subject(reducer_message(KEP, KEQ))} |
    {error, gleam@otp@actor:start_error()}.
start(Initialize, Update, Notify) ->
    gleam@result:map(
        gleam@otp@actor:start_spec(
            {spec, init(Initialize, Update, Notify), 1000, fun handle_message/2}
        ),
        fun(Self) -> Self end
    ).

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

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