chip

-module(chip).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([register/3, members/3, stop/1, from/1, start/1]).
-export_type([named/0, message/2, state/2, process_down/0]).

-type named() :: {named, binary()} | unnamed.

-opaque message(IRS, IRT) :: {register, gleam@erlang@process:subject(IRS), IRT} |
    {deregister, gleam@erlang:reference_(), gleam@erlang@process:pid_()} |
    {group_store2,
        gleam@erlang@process:subject(lamb:table(IRT, gleam@erlang@process:subject(IRS)))} |
    {no_operation, gleam@dynamic:dynamic_()} |
    stop.

-type state(IRU, IRV) :: {state,
        integer(),
        lamb:table(gleam@erlang@process:pid_(), nil),
        lamb:table(IRV, gleam@erlang@process:subject(IRU))}.

-type process_down() :: {process_down,
        gleam@erlang:reference_(),
        gleam@erlang@process:pid_()}.

-file("/Users/chouzar/Bench/Projects/chip/src/chip.gleam", 139).
-spec register(
    gleam@erlang@process:subject(message(ISN, ISO)),
    ISO,
    gleam@erlang@process:subject(ISN)
) -> nil.
register(Registry, Group, Subject) ->
    gleam@erlang@process:send(Registry, {register, Subject, Group}).

-file("/Users/chouzar/Bench/Projects/chip/src/chip.gleam", 162).
-spec members(gleam@erlang@process:subject(message(ISS, IST)), IST, integer()) -> list(gleam@erlang@process:subject(ISS)).
members(Registry, Group, Timeout) ->
    Group_store = gleam@erlang@process:call(
        Registry,
        fun(_capture) -> {group_store2, _capture} end,
        Timeout
    ),
    lamb:lookup(Group_store, Group).

-file("/Users/chouzar/Bench/Projects/chip/src/chip.gleam", 180).
-spec stop(gleam@erlang@process:subject(message(any(), any()))) -> nil.
stop(Registry) ->
    gleam@erlang@process:send(Registry, stop).

-file("/Users/chouzar/Bench/Projects/chip/src/chip.gleam", 334).
-spec monitor(
    lamb:table(gleam@erlang@process:pid_(), nil),
    gleam@erlang@process:pid_()
) -> nil.
monitor(Monitors, Pid) ->
    case lamb:any(Monitors, Pid) of
        true ->
            nil;

        false ->
            _ = gleam@erlang@process:monitor_process(Pid),
            nil
    end.

-file("/Users/chouzar/Bench/Projects/chip/src/chip.gleam", 320).
-spec process_down(gleam@dynamic:dynamic_()) -> message(any(), any()).
process_down(Message) ->
    case chip_erlang_ffi:decode_down_message(Message) of
        {ok, {process_down, Monitor, Pid}} ->
            {deregister, Monitor, Pid};

        {error, nil} ->
            {no_operation, Message}
    end.

-file("/Users/chouzar/Bench/Projects/chip/src/chip.gleam", 348).
-spec schedulers() -> integer().
schedulers() ->
    erlang:system_info(erlang:binary_to_atom(<<"schedulers"/utf8>>)).

-file("/Users/chouzar/Bench/Projects/chip/src/chip.gleam", 358).
-spec demonitor(gleam@erlang:reference_()) -> nil.
demonitor(Reference) ->
    _ = erlang:demonitor(Reference, [erlang:binary_to_atom(<<"flush"/utf8>>)]),
    nil.

-file("/Users/chouzar/Bench/Projects/chip/src/chip.gleam", 240).
-spec loop(message(ITK, ITL), state(ITK, ITL)) -> gleam@otp@actor:next(message(ITK, ITL), state(ITK, ITL)).
loop(Message, State) ->
    case Message of
        {group_store2, Client} ->
            gleam@erlang@process:send(Client, erlang:element(4, State)),
            _pipe = State,
            gleam@otp@actor:continue(_pipe);

        {register, Subject, Group} ->
            Pid = gleam@erlang@process:subject_owner(Subject),
            nil = monitor(erlang:element(3, State), Pid),
            lamb:insert(erlang:element(3, State), Pid, nil),
            lamb:insert(erlang:element(4, State), Group, Subject),
            _pipe@1 = State,
            gleam@otp@actor:continue(_pipe@1);

        {deregister, Monitor, Pid@1} ->
            nil = demonitor(Monitor),
            lamb:remove(
                erlang:element(3, State),
                begin
                    _pipe@2 = lamb@query:new(),
                    lamb@query:index(_pipe@2, Pid@1)
                end
            ),
            lamb:remove(
                erlang:element(4, State),
                begin
                    _pipe@3 = lamb@query:new(),
                    lamb@query:record(
                        _pipe@3,
                        {lamb@query@term:tag(<<"subject"/utf8>>),
                            Pid@1,
                            lamb@query@term:any()}
                    )
                end
            ),
            _pipe@4 = State,
            gleam@otp@actor:continue(_pipe@4);

        {no_operation, _} ->
            _pipe@5 = State,
            gleam@otp@actor:continue(_pipe@5);

        stop ->
            {stop, normal}
    end.

-file("/Users/chouzar/Bench/Projects/chip/src/chip.gleam", 105).
-spec from(binary()) -> {ok,
        gleam@erlang@process:subject(message(any(), any()))} |
    {error, nil}.
from(Name) ->
    gleam@result:'try'(
        lamb:from_name(<<"chip_registries"/utf8>>),
        fun(Table) -> case lamb:lookup(Table, Name) of
                [] ->
                    {error, nil};

                [Registry] ->
                    {ok, Registry};

                [_ | _] ->
                    erlang:error(#{gleam_error => panic,
                            message => (<<<<<<"Unexpected error trying to retrieve registry "/utf8,
                                        Name/binary>>/binary,
                                    " from ETS table: "/utf8>>/binary,
                                "chip_registries"/utf8>>),
                            module => <<"chip"/utf8>>,
                            function => <<"from"/utf8>>,
                            line => 112})
            end end
    ).

-file("/Users/chouzar/Bench/Projects/chip/src/chip.gleam", 289).
-spec initialize_named_registries_store() -> lamb:table(binary(), gleam@erlang@process:subject(message(any(), any()))).
initialize_named_registries_store() ->
    case lamb:from_name(<<"chip_registries"/utf8>>) of
        {ok, Table} ->
            Table;

        {error, nil} ->
            case lamb:create(<<"chip_registries"/utf8>>, public, set, true) of
                {ok, Table@1} ->
                    Table@1;

                {error, _} ->
                    erlang:error(#{gleam_error => panic,
                            message => (<<"Unexpected error trying to initialize chip's ETS store"/utf8>>),
                            module => <<"chip"/utf8>>,
                            function => <<"initialize_named_registries_store"/utf8>>,
                            line => 299})
            end
    end.

-file("/Users/chouzar/Bench/Projects/chip/src/chip.gleam", 304).
-spec initialize_monitors_store() -> lamb:table(gleam@erlang@process:pid_(), nil).
initialize_monitors_store() ->
    case lamb:create(<<"chip_monitors"/utf8>>, private, set, false) of
        {ok, Table} ->
            Table;

        {error, _} ->
            erlang:error(#{gleam_error => panic,
                    message => (<<"Unexpected error trying to initialize chip's monitor store"/utf8>>),
                    module => <<"chip"/utf8>>,
                    function => <<"initialize_monitors_store"/utf8>>,
                    line => 308})
    end.

-file("/Users/chouzar/Bench/Projects/chip/src/chip.gleam", 312).
-spec initialize_groups_store() -> lamb:table(any(), gleam@erlang@process:subject(any())).
initialize_groups_store() ->
    case lamb:create(<<"chip_groups"/utf8>>, protected, bag, false) of
        {ok, Groups} ->
            Groups;

        {error, _} ->
            erlang:error(#{gleam_error => panic,
                    message => (<<"Unexpected error trying to initialize chip's subject store"/utf8>>),
                    module => <<"chip"/utf8>>,
                    function => <<"initialize_groups_store"/utf8>>,
                    line => 316})
    end.

-file("/Users/chouzar/Bench/Projects/chip/src/chip.gleam", 213).
-spec init(named()) -> gleam@otp@actor:init_result(state(ITC, ITD), message(ITC, ITD)).
init(Named) ->
    Self = gleam@erlang@process:new_subject(),
    Table = initialize_named_registries_store(),
    case Named of
        {named, Name} ->
            lamb:insert(Table, Name, Self);

        unnamed ->
            nil
    end,
    Concurrency = schedulers(),
    Monitors = initialize_monitors_store(),
    Groups = initialize_groups_store(),
    State = {state, Concurrency, Monitors, Groups},
    Selector = begin
        _pipe = gleam_erlang_ffi:new_selector(),
        _pipe@1 = gleam@erlang@process:selecting(
            _pipe,
            Self,
            fun gleam@function:identity/1
        ),
        gleam@erlang@process:selecting_anything(_pipe@1, fun process_down/1)
    end,
    {ready, State, Selector}.

-file("/Users/chouzar/Bench/Projects/chip/src/chip.gleam", 70).
-spec start(named()) -> {ok,
        gleam@erlang@process:subject(message(any(), any()))} |
    {error, gleam@otp@actor:start_error()}.
start(Named) ->
    Init = fun() -> init(Named) end,
    gleam@otp@actor:start_spec({spec, Init, 100, fun loop/2}).