glixir

-module(glixir@registry).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-define(FILEPATH, "src/glixir/registry.gleam").
-export([start_registry/2, start_unique_registry/1, register_subject/3, lookup_subject/2, unregister_subject/2, register_with_key/3, lookup_with_key/2, unregister_with_key/2]).
-export_type([registry/0, registry_keys/0, registry_error/0, registry_start_result/0, registry_register_result/0, registry_lookup_result/1, registry_unregister_result/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.

?MODULEDOC(
    " Registry support for Subject lookup with dynamic spawning\n"
    " \n"
    " This module provides a Gleam-friendly interface to Elixir's Registry,\n"
    " using our Elixir helper module for clean data conversion.\n"
).

-opaque registry() :: {registry, gleam@erlang@process:pid_()}.

-type registry_keys() :: unique | duplicate.

-type registry_error() :: {start_error, binary()} |
    {register_error, binary()} |
    {lookup_error, binary()} |
    {unregister_error, binary()} |
    already_exists |
    not_found.

-type registry_start_result() :: {registry_start_ok,
        gleam@erlang@process:pid_()} |
    {registry_start_error, gleam@dynamic:dynamic_()}.

-type registry_register_result() :: registry_register_ok |
    {registry_register_error, gleam@dynamic:dynamic_()}.

-type registry_lookup_result(EOQ) :: {registry_lookup_ok,
        gleam@erlang@process:subject(EOQ)} |
    registry_lookup_not_found |
    {registry_lookup_error, gleam@dynamic:dynamic_()}.

-type registry_unregister_result() :: registry_unregister_ok |
    {registry_unregister_error, gleam@dynamic:dynamic_()}.

-file("src/glixir/registry.gleam", 88).
-spec keys_to_string(registry_keys()) -> binary().
keys_to_string(Keys) ->
    case Keys of
        unique ->
            <<"unique"/utf8>>;

        duplicate ->
            <<"duplicate"/utf8>>
    end.

-file("src/glixir/registry.gleam", 100).
?DOC(" Start a new Registry with the given name and key type\n").
-spec start_registry(binary(), registry_keys()) -> {ok, registry()} |
    {error, registry_error()}.
start_registry(Name, Keys) ->
    case 'Elixir.Glixir.Registry':start_registry(Name, keys_to_string(Keys)) of
        {registry_start_ok, Pid} ->
            {ok, {registry, Pid}};

        {registry_start_error, Reason} ->
            {error, {start_error, gleam@string:inspect(Reason)}}
    end.

-file("src/glixir/registry.gleam", 111).
?DOC(" Start a unique key registry (most common use case)\n").
-spec start_unique_registry(binary()) -> {ok, registry()} |
    {error, registry_error()}.
start_unique_registry(Name) ->
    start_registry(Name, unique).

-file("src/glixir/registry.gleam", 116).
?DOC(" Register a Subject with a key in the registry\n").
-spec register_subject(binary(), binary(), gleam@erlang@process:subject(any())) -> {ok,
        nil} |
    {error, registry_error()}.
register_subject(Registry_name, Key, Subject) ->
    case 'Elixir.Glixir.Registry':register_subject(Registry_name, Key, Subject) of
        registry_register_ok ->
            {ok, nil};

        {registry_register_error, Reason} ->
            {error, {register_error, gleam@string:inspect(Reason)}}
    end.

-file("src/glixir/registry.gleam", 129).
?DOC(" Look up a Subject by key in the registry\n").
-spec lookup_subject(binary(), binary()) -> {ok,
        gleam@erlang@process:subject(any())} |
    {error, registry_error()}.
lookup_subject(Registry_name, Key) ->
    case 'Elixir.Glixir.Registry':lookup_subject(Registry_name, Key) of
        {registry_lookup_ok, Subject} ->
            {ok, Subject};

        registry_lookup_not_found ->
            {error, not_found};

        {registry_lookup_error, Reason} ->
            {error, {lookup_error, gleam@string:inspect(Reason)}}
    end.

-file("src/glixir/registry.gleam", 141).
?DOC(" Unregister a key from the registry\n").
-spec unregister_subject(binary(), binary()) -> {ok, nil} |
    {error, registry_error()}.
unregister_subject(Registry_name, Key) ->
    case 'Elixir.Glixir.Registry':unregister_subject(Registry_name, Key) of
        registry_unregister_ok ->
            {ok, nil};

        {registry_unregister_error, Reason} ->
            {error, {unregister_error, gleam@string:inspect(Reason)}}
    end.

-file("src/glixir/registry.gleam", 157).
?DOC(" Register a subject with a custom key\n").
-spec register_with_key(binary(), binary(), gleam@erlang@process:subject(any())) -> {ok,
        nil} |
    {error, registry_error()}.
register_with_key(Registry_name, Key, Subject) ->
    register_subject(Registry_name, Key, Subject).

-file("src/glixir/registry.gleam", 166).
?DOC(" Look up a subject by custom key\n").
-spec lookup_with_key(binary(), binary()) -> {ok,
        gleam@erlang@process:subject(any())} |
    {error, registry_error()}.
lookup_with_key(Registry_name, Key) ->
    lookup_subject(Registry_name, Key).

-file("src/glixir/registry.gleam", 174).
?DOC(" Unregister a subject by custom key\n").
-spec unregister_with_key(binary(), binary()) -> {ok, nil} |
    {error, registry_error()}.
unregister_with_key(Registry_name, Key) ->
    unregister_subject(Registry_name, Key).