-module(glixir@registry).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/glixir/registry.gleam").
-export([start_registry/2, start_unique_registry/1, register_subject/4, lookup_subject/3, register_subject_string/3, lookup_subject_string/2, unregister_subject_string/2, unregister_subject/3, atom_key_encoder/1, string_key_encoder/1, int_key_encoder/1, user_id_encoder/1, session_key_encoder/1]).
-export_type([registry/2, 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(
    " Type-safe, phantom-typed Registry for Gleam/Elixir interop\n"
    "\n"
    " This module provides a *phantom-typed* interface to Elixir Registry.\n"
    " All registries are parameterized by their `key_type` and `message_type`,\n"
    " so misuse is a compile error, not a runtime surprise.\n"
).

-opaque registry(EXV, EXW) :: {registry, gleam@erlang@process:pid_()} |
    {gleam_phantom, EXV, EXW}.

-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(EXX) :: {registry_lookup_ok,
        gleam@erlang@process:subject(EXX)} |
    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", 82).
-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", 96).
?DOC(" Start a phantom-typed registry with bounded key and message types\n").
-spec start_registry(gleam@erlang@atom:atom_(), registry_keys()) -> {ok,
        registry(any(), any())} |
    {error, registry_error()}.
start_registry(Name, Keys) ->
    glixir@utils:debug_log_with_prefix(
        debug,
        <<"registry"/utf8>>,
        <<"Starting registry: "/utf8, (erlang:atom_to_binary(Name))/binary>>
    ),
    case 'Elixir.Glixir.Registry':start_registry(
        erlang:atom_to_binary(Name),
        keys_to_string(Keys)
    ) of
        {registry_start_ok, Pid} ->
            glixir@utils:debug_log_with_prefix(
                info,
                <<"registry"/utf8>>,
                <<"Registry started successfully"/utf8>>
            ),
            {ok, {registry, Pid}};

        {registry_start_error, Reason} ->
            glixir@utils:debug_log_with_prefix(
                error,
                <<"registry"/utf8>>,
                <<"Registry start failed"/utf8>>
            ),
            {error, {start_error, gleam@string:inspect(Reason)}}
    end.

-file("src/glixir/registry.gleam", 127).
?DOC(" Start a unique key registry (most common use case)\n").
-spec start_unique_registry(gleam@erlang@atom:atom_()) -> {ok,
        registry(any(), any())} |
    {error, registry_error()}.
start_unique_registry(Name) ->
    start_registry(Name, unique).

-file("src/glixir/registry.gleam", 134).
?DOC(" Register a Subject with a typed key in the phantom-typed registry\n").
-spec register_subject(
    gleam@erlang@atom:atom_(),
    EYP,
    gleam@erlang@process:subject(any()),
    fun((EYP) -> binary())
) -> {ok, nil} | {error, registry_error()}.
register_subject(Registry_name, Key, Subject, Encode_key) ->
    glixir@utils:debug_log_with_prefix(
        debug,
        <<"registry"/utf8>>,
        <<"Registering subject with key"/utf8>>
    ),
    case 'Elixir.Glixir.Registry':register_subject(
        erlang:atom_to_binary(Registry_name),
        Encode_key(Key),
        Subject
    ) of
        registry_register_ok ->
            glixir@utils:debug_log_with_prefix(
                info,
                <<"registry"/utf8>>,
                <<"Subject registered successfully"/utf8>>
            ),
            {ok, nil};

        {registry_register_error, Reason} ->
            glixir@utils:debug_log_with_prefix(
                error,
                <<"registry"/utf8>>,
                <<"Subject registration failed"/utf8>>
            ),
            {error, {register_error, gleam@string:inspect(Reason)}}
    end.

-file("src/glixir/registry.gleam", 173).
?DOC(" Look up a Subject by typed key in the phantom-typed registry\n").
-spec lookup_subject(gleam@erlang@atom:atom_(), EYV, fun((EYV) -> binary())) -> {ok,
        gleam@erlang@process:subject(any())} |
    {error, registry_error()}.
lookup_subject(Registry_name, Key, Encode_key) ->
    glixir@utils:debug_log_with_prefix(
        debug,
        <<"registry"/utf8>>,
        <<"Looking up subject by key"/utf8>>
    ),
    case 'Elixir.Glixir.Registry':lookup_subject(
        erlang:atom_to_binary(Registry_name),
        Encode_key(Key)
    ) of
        {registry_lookup_ok, Subject} ->
            glixir@utils:debug_log_with_prefix(
                info,
                <<"registry"/utf8>>,
                <<"Subject found successfully"/utf8>>
            ),
            {ok, Subject};

        registry_lookup_not_found ->
            glixir@utils:debug_log_with_prefix(
                warning,
                <<"registry"/utf8>>,
                <<"Subject not found"/utf8>>
            ),
            {error, not_found};

        {registry_lookup_error, Reason} ->
            glixir@utils:debug_log_with_prefix(
                error,
                <<"registry"/utf8>>,
                <<"Subject lookup failed"/utf8>>
            ),
            {error, {lookup_error, gleam@string:inspect(Reason)}}
    end.

-file("src/glixir/registry.gleam", 213).
?DOC(" SAFE: Register with string key (no dynamic atom creation)\n").
-spec register_subject_string(
    gleam@erlang@atom:atom_(),
    binary(),
    gleam@erlang@process:subject(any())
) -> {ok, nil} | {error, registry_error()}.
register_subject_string(Registry_name, Key, Subject) ->
    case 'Elixir.Glixir.Registry':register_subject(
        erlang:atom_to_binary(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", 227).
?DOC(" SAFE: Lookup with string key\n").
-spec lookup_subject_string(gleam@erlang@atom:atom_(), binary()) -> {ok,
        gleam@erlang@process:subject(any())} |
    {error, registry_error()}.
lookup_subject_string(Registry_name, Key) ->
    case 'Elixir.Glixir.Registry':lookup_subject(
        erlang:atom_to_binary(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", 239).
?DOC(" SAFE: Unregister with string key\n").
-spec unregister_subject_string(gleam@erlang@atom:atom_(), binary()) -> {ok,
        nil} |
    {error, registry_error()}.
unregister_subject_string(Registry_name, Key) ->
    case 'Elixir.Glixir.Registry':unregister_subject(
        erlang:atom_to_binary(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", 251).
?DOC(" Unregister a key from the phantom-typed registry\n").
-spec unregister_subject(gleam@erlang@atom:atom_(), EZL, fun((EZL) -> binary())) -> {ok,
        nil} |
    {error, registry_error()}.
unregister_subject(Registry_name, Key, Encode_key) ->
    glixir@utils:debug_log_with_prefix(
        debug,
        <<"registry"/utf8>>,
        <<"Unregistering subject"/utf8>>
    ),
    case 'Elixir.Glixir.Registry':unregister_subject(
        erlang:atom_to_binary(Registry_name),
        Encode_key(Key)
    ) of
        registry_unregister_ok ->
            glixir@utils:debug_log_with_prefix(
                info,
                <<"registry"/utf8>>,
                <<"Subject unregistered successfully"/utf8>>
            ),
            {ok, nil};

        {registry_unregister_error, Reason} ->
            glixir@utils:debug_log_with_prefix(
                error,
                <<"registry"/utf8>>,
                <<"Subject unregistration failed"/utf8>>
            ),
            {error, {unregister_error, gleam@string:inspect(Reason)}}
    end.

-file("src/glixir/registry.gleam", 285).
?DOC(" Encoder for Atom keys (most common case)\n").
-spec atom_key_encoder(gleam@erlang@atom:atom_()) -> binary().
atom_key_encoder(Key) ->
    erlang:atom_to_binary(Key).

-file("src/glixir/registry.gleam", 290).
?DOC(" Encoder for String keys\n").
-spec string_key_encoder(binary()) -> binary().
string_key_encoder(Key) ->
    Key.

-file("src/glixir/registry.gleam", 295).
?DOC(" Encoder for Int keys\n").
-spec int_key_encoder(integer()) -> binary().
int_key_encoder(Key) ->
    erlang:integer_to_binary(Key).

-file("src/glixir/registry.gleam", 300).
?DOC(" Encoder for user ID keys (common pattern)\n").
-spec user_id_encoder(integer()) -> binary().
user_id_encoder(User_id) ->
    <<"user_"/utf8, (erlang:integer_to_binary(User_id))/binary>>.

-file("src/glixir/registry.gleam", 305).
?DOC(" Encoder for session keys (common pattern)\n").
-spec session_key_encoder(binary()) -> binary().
session_key_encoder(Session_id) ->
    <<"session_"/utf8, Session_id/binary>>.