distribute

-module(distribute@global).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/distribute/global.gleam").
-export([new/2, from_pid/3, from_subject/3, from_name/4, subject/1, owner/1, encoder/1, decoder/1, send/2, 'receive'/2, call/4, reply/3, call_error_to_string/1]).
-export_type([global_subject/1, call_error/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.

-opaque global_subject(FYC) :: {global_subject,
        gleam@erlang@process:subject(bitstring()),
        fun((FYC) -> {ok, bitstring()} |
            {error, distribute@codec:encode_error()}),
        fun((bitstring()) -> {ok, FYC} |
            {error, distribute@codec:decode_error()})}.

-type call_error() :: call_timeout |
    {call_encode_failed, distribute@codec:encode_error()} |
    {call_decode_failed, distribute@codec:decode_error()}.

-file("src/distribute/global.gleam", 46).
?DOC(" New subject owned by the current process, with a unique tag.\n").
-spec new(
    fun((FYF) -> {ok, bitstring()} | {error, distribute@codec:encode_error()}),
    fun((bitstring()) -> {ok, FYF} | {error, distribute@codec:decode_error()})
) -> global_subject(FYF).
new(Encoder, Decoder) ->
    Subject = distribute_ffi_utils:create_subject(
        erlang:self(),
        erlang:make_ref()
    ),
    {global_subject, Subject, Encoder, Decoder}.

-file("src/distribute/global.gleam", 56).
?DOC(
    " Subject from a remote PID. Nil tag, send-only — you can't\n"
    " receive on it from the calling process.\n"
).
-spec from_pid(
    gleam@erlang@process:pid_(),
    fun((FYJ) -> {ok, bitstring()} | {error, distribute@codec:encode_error()}),
    fun((bitstring()) -> {ok, FYJ} | {error, distribute@codec:decode_error()})
) -> global_subject(FYJ).
from_pid(Pid, Encoder, Decoder) ->
    Subject = distribute_ffi_utils:create_subject(Pid, gleam@dynamic:nil()),
    {global_subject, Subject, Encoder, Decoder}.

-file("src/distribute/global.gleam", 66).
?DOC(" Wrap an existing `Subject(BitArray)`, keeping its tag.\n").
-spec from_subject(
    gleam@erlang@process:subject(bitstring()),
    fun((FYO) -> {ok, bitstring()} | {error, distribute@codec:encode_error()}),
    fun((bitstring()) -> {ok, FYO} | {error, distribute@codec:decode_error()})
) -> global_subject(FYO).
from_subject(Subject, Encoder, Decoder) ->
    {global_subject, Subject, Encoder, Decoder}.

-file("src/distribute/global.gleam", 76).
?DOC(
    " Subject from a name and PID. The name is the tag, so any node\n"
    " that knows the name can reconstruct the same Subject.\n"
).
-spec from_name(
    binary(),
    gleam@erlang@process:pid_(),
    fun((FYS) -> {ok, bitstring()} | {error, distribute@codec:encode_error()}),
    fun((bitstring()) -> {ok, FYS} | {error, distribute@codec:decode_error()})
) -> global_subject(FYS).
from_name(Name, Pid, Encoder, Decoder) ->
    Subject = distribute_ffi_utils:create_subject(
        Pid,
        gleam_stdlib:identity(Name)
    ),
    {global_subject, Subject, Encoder, Decoder}.

-file("src/distribute/global.gleam", 90).
-spec subject(global_subject(any())) -> gleam@erlang@process:subject(bitstring()).
subject(Global) ->
    erlang:element(2, Global).

-file("src/distribute/global.gleam", 94).
-spec owner(global_subject(any())) -> {ok, gleam@erlang@process:pid_()} |
    {error, nil}.
owner(Global) ->
    gleam@erlang@process:subject_owner(erlang:element(2, Global)).

-file("src/distribute/global.gleam", 98).
-spec encoder(global_subject(FZD)) -> fun((FZD) -> {ok, bitstring()} |
    {error, distribute@codec:encode_error()}).
encoder(Global) ->
    erlang:element(3, Global).

-file("src/distribute/global.gleam", 102).
-spec decoder(global_subject(FZG)) -> fun((bitstring()) -> {ok, FZG} |
    {error, distribute@codec:decode_error()}).
decoder(Global) ->
    erlang:element(4, Global).

-file("src/distribute/global.gleam", 111).
?DOC(" Encode and send a message.\n").
-spec send(global_subject(FZJ), FZJ) -> {ok, nil} |
    {error, distribute@codec:encode_error()}.
send(Global, Message) ->
    case distribute@codec:encode(erlang:element(3, Global), Message) of
        {ok, Binary} ->
            gleam@erlang@process:send(erlang:element(2, Global), Binary),
            {ok, nil};

        {error, Err} ->
            {error, Err}
    end.

-file("src/distribute/global.gleam", 125).
?DOC(" Receive and decode a message. Only works on subjects you own.\n").
-spec 'receive'(global_subject(FZN), integer()) -> {ok, FZN} |
    {error, distribute@codec:decode_error()}.
'receive'(Global, Timeout_ms) ->
    case gleam@erlang@process:'receive'(erlang:element(2, Global), Timeout_ms) of
        {ok, Binary} ->
            distribute@codec:decode(erlang:element(4, Global), Binary);

        {error, nil} ->
            {error, decode_timeout}
    end.

-file("src/distribute/global.gleam", 148).
?DOC(
    " Synchronous request/response. Creates a temporary subject, sends\n"
    " the request (built by `make_request`), waits for the reply.\n"
    " The handler must call `reply` with the same subject.\n"
).
-spec call(
    global_subject(FZR),
    fun((gleam@erlang@process:subject(bitstring())) -> FZR),
    fun((bitstring()) -> {ok, FZU} | {error, distribute@codec:decode_error()}),
    integer()
) -> {ok, FZU} | {error, call_error()}.
call(Target, Make_request, Response_decoder, Timeout_ms) ->
    Reply_subject = gleam@erlang@process:new_subject(),
    Request = Make_request(Reply_subject),
    case send(Target, Request) of
        {error, E} ->
            {error, {call_encode_failed, E}};

        {ok, nil} ->
            case gleam@erlang@process:'receive'(Reply_subject, Timeout_ms) of
                {error, nil} ->
                    {error, call_timeout};

                {ok, Bits} ->
                    case distribute@codec:decode(Response_decoder, Bits) of
                        {ok, Value} ->
                            {ok, Value};

                        {error, E@1} ->
                            {error, {call_decode_failed, E@1}}
                    end
            end
    end.

-file("src/distribute/global.gleam", 174).
?DOC(
    " Send a response through a reply subject. Used by the handler\n"
    " to answer a `call`.\n"
).
-spec reply(
    gleam@erlang@process:subject(bitstring()),
    FZZ,
    fun((FZZ) -> {ok, bitstring()} | {error, distribute@codec:encode_error()})
) -> {ok, nil} | {error, distribute@codec:encode_error()}.
reply(Reply_to, Response, Encoder) ->
    case distribute@codec:encode(Encoder, Response) of
        {ok, Bits} ->
            gleam@erlang@process:send(Reply_to, Bits),
            {ok, nil};

        {error, E} ->
            {error, E}
    end.

-file("src/distribute/global.gleam", 188).
-spec call_error_to_string(call_error()) -> binary().
call_error_to_string(Error) ->
    case Error of
        call_timeout ->
            <<"Call timed out"/utf8>>;

        {call_encode_failed, E} ->
            <<"Call encode failed: "/utf8,
                (distribute@codec:encode_error_to_string(E))/binary>>;

        {call_decode_failed, E@1} ->
            <<"Call decode failed: "/utf8,
                (distribute@codec:decode_error_to_string(E@1))/binary>>
    end.