distribute

-module(distribute@config).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/distribute/config.gleam").
-export([reset/0, config_error_to_string/1, default/0, configure/1, get/0]).
-export_type([config/0, config_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.

-type config() :: {config,
        integer(),
        integer(),
        integer(),
        integer(),
        integer(),
        integer(),
        integer(),
        integer(),
        integer()}.

-type config_error() :: already_configured |
    {invalid_timeout, binary(), integer()} |
    {invalid_payload_size, integer()} |
    {invalid_atom_budget, integer()} |
    {invalid_list_element_cap, integer()}.

-file("src/distribute/config.gleam", 51).
?DOC(false).
-spec reset() -> nil.
reset() ->
    config_ffi:reset_config().

-file("src/distribute/config.gleam", 132).
-spec config_error_to_string(config_error()) -> binary().
config_error_to_string(Err) ->
    case Err of
        already_configured ->
            <<"Configuration already loaded (persistent_term is immutable)"/utf8>>;

        {invalid_timeout, F, V} ->
            <<<<<<"Invalid timeout for "/utf8, F/binary>>/binary, ": "/utf8>>/binary,
                (erlang:integer_to_binary(V))/binary>>;

        {invalid_payload_size, V@1} ->
            <<"Invalid payload size: "/utf8,
                (erlang:integer_to_binary(V@1))/binary>>;

        {invalid_atom_budget, V@2} ->
            <<<<"Invalid atom budget: "/utf8,
                    (erlang:integer_to_binary(V@2))/binary>>/binary,
                " (must be > 0)"/utf8>>;

        {invalid_list_element_cap, V@3} ->
            <<<<"Invalid list element cap: "/utf8,
                    (erlang:integer_to_binary(V@3))/binary>>/binary,
                " (must be > 0)"/utf8>>
    end.

-file("src/distribute/config.gleam", 160).
?DOC(
    " Returns the built-in defaults:\n"
    " - `default_call_timeout_ms`: 5 000 ms\n"
    " - `default_init_timeout_ms`: 5 000 ms\n"
    " - `max_payload_size_bytes`: 4 MiB (4 * 1 024 * 1 024)\n"
    " - `max_distribution_atoms`: 10 000\n"
    " - `max_decoded_list_elements`: 10 000\n"
    " - `isolated_proxy_shutdown_grace_ms`: 5 000 ms\n"
    " - `resource_owner_poll_ms`: 5 000 ms\n"
    " - `health_proxy_shutdown_grace_ms`: 1 000 ms\n"
    " - `conflict_resolver_timeout_ms`: 1 000 ms\n"
).
-spec default() -> config().
default() ->
    {config,
        5000,
        5000,
        (4 * 1024) * 1024,
        10000,
        10000,
        5000,
        5000,
        1000,
        1000}.

-file("src/distribute/config.gleam", 222).
-spec check_positive_timeout(binary(), integer()) -> {ok, nil} |
    {error, config_error()}.
check_positive_timeout(Field, Value) ->
    case Value > 0 of
        true ->
            {ok, nil};

        false ->
            {error, {invalid_timeout, Field, Value}}
    end.

-file("src/distribute/config.gleam", 246).
-spec check_positive_list_cap(integer()) -> {ok, nil} | {error, config_error()}.
check_positive_list_cap(Value) ->
    case Value > 0 of
        true ->
            {ok, nil};

        false ->
            {error, {invalid_list_element_cap, Value}}
    end.

-file("src/distribute/config.gleam", 239).
-spec check_positive_atom_budget(integer()) -> {ok, nil} |
    {error, config_error()}.
check_positive_atom_budget(Value) ->
    case Value > 0 of
        true ->
            {ok, nil};

        false ->
            {error, {invalid_atom_budget, Value}}
    end.

-file("src/distribute/config.gleam", 232).
-spec check_positive_payload_size(integer()) -> {ok, nil} |
    {error, config_error()}.
check_positive_payload_size(Value) ->
    case Value > 0 of
        true ->
            {ok, nil};

        false ->
            {error, {invalid_payload_size, Value}}
    end.

-file("src/distribute/config.gleam", 188).
?DOC(
    " Store a custom configuration. Call once at startup.\n"
    "\n"
    " Returns `Error(ConfigError)` if any value is invalid (zero or negative)\n"
    " or if the configuration has already been loaded via a previous call.\n"
    "\n"
    " **Danger**: call this only during application boot. `persistent_term`\n"
    " writes trigger a global VM-wide heap invalidation pass; exposing this\n"
    " path to runtime traffic is an operational footgun and can cause\n"
    " heartbeat failures between nodes under load.\n"
    "\n"
    " Side-effect: also writes `max_distribution_atoms` to a separate\n"
    " `persistent_term` slot read by the FFI atom helpers, so the budget\n"
    " is observable from Erlang without needing to decode the Gleam\n"
    " Config tuple.\n"
).
-spec configure(config()) -> {ok, nil} | {error, config_error()}.
configure(Cfg) ->
    gleam@result:'try'(
        check_positive_timeout(
            <<"default_call_timeout_ms"/utf8>>,
            erlang:element(2, Cfg)
        ),
        fun(_) ->
            gleam@result:'try'(
                check_positive_timeout(
                    <<"default_init_timeout_ms"/utf8>>,
                    erlang:element(3, Cfg)
                ),
                fun(_) ->
                    gleam@result:'try'(
                        check_positive_payload_size(erlang:element(4, Cfg)),
                        fun(_) ->
                            gleam@result:'try'(
                                check_positive_atom_budget(
                                    erlang:element(5, Cfg)
                                ),
                                fun(_) ->
                                    gleam@result:'try'(
                                        check_positive_list_cap(
                                            erlang:element(6, Cfg)
                                        ),
                                        fun(_) ->
                                            gleam@result:'try'(
                                                check_positive_timeout(
                                                    <<"isolated_proxy_shutdown_grace_ms"/utf8>>,
                                                    erlang:element(7, Cfg)
                                                ),
                                                fun(_) ->
                                                    gleam@result:'try'(
                                                        check_positive_timeout(
                                                            <<"resource_owner_poll_ms"/utf8>>,
                                                            erlang:element(
                                                                8,
                                                                Cfg
                                                            )
                                                        ),
                                                        fun(_) ->
                                                            gleam@result:'try'(
                                                                check_positive_timeout(
                                                                    <<"health_proxy_shutdown_grace_ms"/utf8>>,
                                                                    erlang:element(
                                                                        9,
                                                                        Cfg
                                                                    )
                                                                ),
                                                                fun(_) ->
                                                                    gleam@result:'try'(
                                                                        check_positive_timeout(
                                                                            <<"conflict_resolver_timeout_ms"/utf8>>,
                                                                            erlang:element(
                                                                                10,
                                                                                Cfg
                                                                            )
                                                                        ),
                                                                        fun(_) ->
                                                                            gleam@result:'try'(
                                                                                config_ffi:put_config(
                                                                                    Cfg
                                                                                ),
                                                                                fun(
                                                                                    _
                                                                                ) ->
                                                                                    config_ffi:put_atom_budget(
                                                                                        erlang:element(
                                                                                            5,
                                                                                            Cfg
                                                                                        )
                                                                                    ),
                                                                                    config_ffi:put_conflict_resolver_timeout(
                                                                                        erlang:element(
                                                                                            10,
                                                                                            Cfg
                                                                                        )
                                                                                    ),
                                                                                    {ok,
                                                                                        nil}
                                                                                end
                                                                            )
                                                                        end
                                                                    )
                                                                end
                                                            )
                                                        end
                                                    )
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/distribute/config.gleam", 256).
?DOC(
    " Read the active configuration.\n"
    "\n"
    " Never fails: returns `default()` when `configure/1` has not been called.\n"
).
-spec get() -> config().
get() ->
    config_ffi:get_config(default()).