telega

-module(telega@internal@registry).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-define(FILEPATH, "src/telega/internal/registry.gleam").
-export([stop/1, register/3, unregister/2, start/0, get/2]).
-export_type([actor/1, registry/1, registry_message/1]).

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

-opaque actor(AJGI) :: {actor,
        gleam@erlang@process:pid_(),
        gleam@erlang@process:process_monitor(),
        gleam@erlang@process:subject(AJGI)}.

-opaque registry(AJGJ) :: {registry,
        gleam@erlang@process:subject(registry_message(AJGJ)),
        gleam@erlang@process:selector(registry_message(AJGJ)),
        gleam@dict:dict(binary(), actor(AJGJ))}.

-opaque registry_message(AJGK) :: {register,
        binary(),
        gleam@erlang@process:pid_(),
        gleam@erlang@process:subject(AJGK)} |
    {get,
        gleam@erlang@process:subject(gleam@option:option(gleam@erlang@process:subject(AJGK))),
        binary()} |
    {actor_exit, binary(), gleam@erlang@process:process_down()} |
    {unregister, binary()} |
    shutdown.

-file("src/telega/internal/registry.gleam", 58).
?DOC(false).
-spec stop(gleam@erlang@process:subject(registry_message(any()))) -> nil.
stop(Actor) ->
    gleam@otp@actor:send(Actor, shutdown).

-file("src/telega/internal/registry.gleam", 62).
?DOC(false).
-spec register(
    gleam@erlang@process:subject(registry_message(AJGS)),
    binary(),
    gleam@erlang@process:subject(AJGS)
) -> gleam@erlang@process:subject(AJGS).
register(Actor, Key, Subject) ->
    Pid = gleam@erlang@process:subject_owner(Subject),
    gleam@otp@actor:send(Actor, {register, Key, Pid, Subject}),
    Subject.

-file("src/telega/internal/registry.gleam", 72).
?DOC(false).
-spec unregister(
    gleam@erlang@process:subject(registry_message(any())),
    binary()
) -> nil.
unregister(Actor, Key) ->
    gleam@otp@actor:send(Actor, {unregister, Key}).

-file("src/telega/internal/registry.gleam", 168).
?DOC(false).
-spec build_selector(
    gleam@erlang@process:subject(registry_message(AJHP)),
    gleam@dict:dict(binary(), actor(AJHP))
) -> gleam@erlang@process:selector(registry_message(AJHP)).
build_selector(Self, Actors) ->
    Base_selector = begin
        _pipe = gleam_erlang_ffi:new_selector(),
        gleam@erlang@process:selecting(_pipe, Self, fun(Msg) -> Msg end)
    end,
    gleam@dict:fold(
        Actors,
        Base_selector,
        fun(Selector, Key, Actor) ->
            gleam@erlang@process:selecting_process_down(
                Selector,
                erlang:element(3, Actor),
                fun(_capture) -> {actor_exit, Key, _capture} end
            )
        end
    ).

-file("src/telega/internal/registry.gleam", 149).
?DOC(false).
-spec remove(
    registry(AJHL),
    binary(),
    gleam@option:option(gleam@erlang@process:pid_())
) -> registry(AJHL).
remove(Self, Key, When_pid) ->
    Rm = fun(Actor) ->
        gleam@erlang@process:demonitor_process(erlang:element(3, Actor)),
        Actors = gleam@dict:delete(erlang:element(4, Self), Key),
        Selector = build_selector(
            erlang:element(2, Self),
            erlang:element(4, Self)
        ),
        _record = Self,
        {registry, erlang:element(2, _record), Selector, Actors}
    end,
    case gleam_stdlib:map_get(erlang:element(4, Self), Key) of
        {ok, {actor, Pid, _, _} = Actor@1} when When_pid =:= {some, Pid} ->
            Rm(Actor@1);

        {ok, Actor@2} when When_pid =:= none ->
            Rm(Actor@2);

        {ok, _} ->
            Self;

        {error, nil} ->
            Self
    end.

-file("src/telega/internal/registry.gleam", 123).
?DOC(false).
-spec handle_register(
    registry(AJHH),
    binary(),
    gleam@erlang@process:pid_(),
    gleam@erlang@process:subject(AJHH)
) -> registry(AJHH).
handle_register(Self, Key, Pid, Process_subject) ->
    Registry = remove(Self, Key, none),
    Monitor = gleam@erlang@process:monitor_process(Pid),
    Selector = begin
        _pipe = erlang:element(3, Self),
        gleam@erlang@process:selecting_process_down(
            _pipe,
            Monitor,
            fun(_capture) -> {actor_exit, Key, _capture} end
        )
    end,
    Actor = {actor, Pid, Monitor, Process_subject},
    Actors = gleam@dict:insert(erlang:element(4, Registry), Key, Actor),
    _record = Registry,
    {registry, erlang:element(2, _record), Selector, Actors}.

-file("src/telega/internal/registry.gleam", 85).
?DOC(false).
-spec loop(registry_message(AJHD), registry(AJHD)) -> gleam@otp@actor:next(registry_message(AJHD), registry(AJHD)).
loop(Message, Self) ->
    case Message of
        {get, Reply_with, Key} ->
            _pipe = gleam_stdlib:map_get(erlang:element(4, Self), Key),
            _pipe@1 = gleam@result:map(
                _pipe,
                fun(Actor) -> erlang:element(4, Actor) end
            ),
            _pipe@2 = gleam@option:from_result(_pipe@1),
            gleam@otp@actor:send(Reply_with, _pipe@2),
            gleam@otp@actor:continue(Self);

        {register, Key@1, Pid, Process_subject} ->
            Next_registry = handle_register(Self, Key@1, Pid, Process_subject),
            _pipe@3 = Next_registry,
            _pipe@4 = gleam@otp@actor:continue(_pipe@3),
            gleam@otp@actor:with_selector(
                _pipe@4,
                erlang:element(3, Next_registry)
            );

        {actor_exit, Key@2, Process_down} ->
            Next_registry@1 = remove(
                Self,
                Key@2,
                {some, erlang:element(2, Process_down)}
            ),
            _pipe@5 = Next_registry@1,
            _pipe@6 = gleam@otp@actor:continue(_pipe@5),
            gleam@otp@actor:with_selector(
                _pipe@6,
                erlang:element(3, Next_registry@1)
            );

        {unregister, Key@3} ->
            Next_registry@2 = remove(Self, Key@3, none),
            _pipe@7 = Next_registry@2,
            _pipe@8 = gleam@otp@actor:continue(_pipe@7),
            gleam@otp@actor:with_selector(
                _pipe@8,
                erlang:element(3, Next_registry@2)
            );

        shutdown ->
            {stop, normal}
    end.

-file("src/telega/internal/registry.gleam", 40).
?DOC(false).
-spec start() -> {ok, gleam@erlang@process:subject(registry_message(any()))} |
    {error, telega@error:telega_error()}.
start() ->
    _pipe@1 = gleam@otp@actor:start_spec(
        {spec,
            fun() ->
                Self = gleam@erlang@process:new_subject(),
                Selector = begin
                    _pipe = gleam_erlang_ffi:new_selector(),
                    gleam@erlang@process:selecting(
                        _pipe,
                        Self,
                        fun gleam@function:identity/1
                    )
                end,
                Registry = {registry, Self, Selector, maps:new()},
                {ready, Registry, Selector}
            end,
            100,
            fun loop/2}
    ),
    gleam@result:map_error(
        _pipe@1,
        fun(Error) -> {registry_start_error, gleam@string:inspect(Error)} end
    ).

-file("src/telega/internal/registry.gleam", 78).
?DOC(false).
-spec get(gleam@erlang@process:subject(registry_message(AJGZ)), binary()) -> gleam@option:option(gleam@erlang@process:subject(AJGZ)).
get(Actor, Key) ->
    gleam@otp@actor:call(Actor, fun(_capture) -> {get, _capture, Key} end, 10).