distribute

-module(distribute@groups).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/distribute/groups.gleam").
-export([join/2, leave/2, members/1, broadcast/2, join_typed/2, leave_typed/2, members_typed/1, broadcast_typed/3]).
-export_type([group_error/0, dynamic_/0]).

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

-type group_error() :: {group_failed, binary()} |
    {encode_failed, distribute@codec:encode_error()} |
    {member_conversion_failed, binary()}.

-type dynamic_() :: any().

-file("src/distribute/groups.gleam", 55).
?DOC(" Join a process to a named group.\n").
-spec join(binary(), gleam@erlang@process:pid_()) -> {ok, nil} |
    {error, group_error()}.
join(Group, Pid) ->
    Res = groups_ffi:join(Group, Pid),
    case groups_ffi:is_ok_atom(Res) of
        true ->
            {ok, nil};

        false ->
            {error, {group_failed, groups_ffi:get_error_reason(Res)}}
    end.

-file("src/distribute/groups.gleam", 64).
?DOC(" Remove a process from a named group.\n").
-spec leave(binary(), gleam@erlang@process:pid_()) -> {ok, nil} |
    {error, group_error()}.
leave(Group, Pid) ->
    Res = groups_ffi:leave(Group, Pid),
    case groups_ffi:is_ok_atom(Res) of
        true ->
            {ok, nil};

        false ->
            {error, {group_failed, groups_ffi:get_error_reason(Res)}}
    end.

-file("src/distribute/groups.gleam", 73).
?DOC(" Get the list of member pids in a group.\n").
-spec members(binary()) -> list(gleam@erlang@process:pid_()).
members(Group) ->
    Res = groups_ffi:members(Group),
    groups_ffi:unwrap_members(Res).

-file("src/distribute/groups.gleam", 82).
?DOC(
    " Broadcast a message to all members of a group.\n"
    "\n"
    " This function bypasses all type checking and encoding validation.\n"
).
-spec broadcast(binary(), any()) -> {ok, nil} | {error, group_error()}.
broadcast(Group, Msg) ->
    Res = groups_ffi:broadcast(Group, Msg),
    case groups_ffi:is_ok_atom(Res) of
        true ->
            {ok, nil};

        false ->
            {error, {group_failed, groups_ffi:get_error_reason(Res)}}
    end.

-file("src/distribute/groups.gleam", 95).
?DOC(" Join a typed subject to a named group.\n").
-spec join_typed(binary(), gleam@erlang@process:subject(any())) -> {ok, nil} |
    {error, group_error()}.
join_typed(Group, Subject) ->
    Pid@1 = case gleam@erlang@process:subject_owner(Subject) of
        {ok, Pid} -> Pid;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"distribute/groups"/utf8>>,
                        function => <<"join_typed"/utf8>>,
                        line => 99,
                        value => _assert_fail,
                        start => 3160,
                        'end' => 3211,
                        pattern_start => 3171,
                        pattern_end => 3178})
    end,
    join(Group, Pid@1).

-file("src/distribute/groups.gleam", 104).
?DOC(" Remove a typed subject from a named group.\n").
-spec leave_typed(binary(), gleam@erlang@process:subject(any())) -> {ok, nil} |
    {error, group_error()}.
leave_typed(Group, Subject) ->
    Pid@1 = case gleam@erlang@process:subject_owner(Subject) of
        {ok, Pid} -> Pid;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"distribute/groups"/utf8>>,
                        function => <<"leave_typed"/utf8>>,
                        line => 108,
                        value => _assert_fail,
                        start => 3376,
                        'end' => 3427,
                        pattern_start => 3387,
                        pattern_end => 3394})
    end,
    leave(Group, Pid@1).

-file("src/distribute/groups.gleam", 116).
?DOC(
    " Get the list of typed members in a group.\n"
    " Returns raw Pids as we cannot safely convert them to Subjects without\n"
    " knowing their message types. Use this with caution or create Subjects\n"
    " using process.unsafely_create_subject if you know the message type.\n"
).
-spec members_typed(binary()) -> list(gleam@erlang@process:pid_()).
members_typed(Group) ->
    members(Group).

-file("src/distribute/groups.gleam", 123).
?DOC(
    " Broadcast a typed message to all members of a group.\n"
    " The message is encoded using the provided encoder before sending.\n"
    " Members should be expecting BitArray messages.\n"
).
-spec broadcast_typed(
    binary(),
    IAS,
    fun((IAS) -> {ok, bitstring()} | {error, distribute@codec:encode_error()})
) -> {ok, nil} | {error, group_error()}.
broadcast_typed(Group, Msg, Encoder) ->
    case distribute@codec:encode(Encoder, Msg) of
        {ok, Binary_msg} ->
            Res = groups_ffi:broadcast_binary(Group, Binary_msg),
            case groups_ffi:is_ok_atom(Res) of
                true ->
                    {ok, nil};

                false ->
                    {error, {group_failed, groups_ffi:get_error_reason(Res)}}
            end;

        {error, Encode_error} ->
            {error, {encode_failed, Encode_error}}
    end.