-module(glixir).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-define(FILEPATH, "src/glixir.gleam").
-export([pubsub_start/1, pubsub_subscribe/4, pubsub_subscribe_with_registry_key/5, pubsub_broadcast/4, pubsub_unsubscribe/2, start_registry/1, start_registry_with_keys/2, register_subject/4, lookup_subject/3, unregister_subject/3, start_dynamic_supervisor_named/1, child_spec/8, start_dynamic_child/4, terminate_dynamic_child/2, which_dynamic_children/1, count_dynamic_children/1, call_genserver/3, call_genserver_timeout/4, cast_genserver/2, start_genserver/2, start_genserver_named/3, ping_genserver/3, get_genserver_state/3, call_genserver_named/3, cast_genserver_named/2, lookup_genserver/1, stop_genserver/1, genserver_pid/1, start_agent/1, get_agent/3, get_agent_timeout/4, update_agent/2, cast_agent/2, get_and_update_agent/3, stop_agent/2, agent_pid/1, main/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(
    "\n"
    " glixir - Unified OTP interface for Gleam, now type safe!\n"
    " Bounded, phantom-typed supervisors! No more runtime surprises.\n"
    "\n"
).

-file("src/glixir.gleam", 118).
?DOC(" Start a phantom-typed PubSub system\n").
-spec pubsub_start(gleam@erlang@atom:atom_()) -> {ok,
        glixir@pubsub:pub_sub(any())} |
    {error, glixir@pubsub:pub_sub_error()}.
pubsub_start(Name) ->
    glixir@pubsub:start(Name).

-file("src/glixir.gleam", 123).
?DOC(" Subscribe to a topic with message handling\n").
-spec pubsub_subscribe(gleam@erlang@atom:atom_(), binary(), binary(), binary()) -> {ok,
        nil} |
    {error, glixir@pubsub:pub_sub_error()}.
pubsub_subscribe(Pubsub_name, Topic, Gleam_module, Gleam_function) ->
    glixir@pubsub:subscribe(Pubsub_name, Topic, Gleam_module, Gleam_function).

-file("src/glixir.gleam", 132).
-spec pubsub_subscribe_with_registry_key(
    gleam@erlang@atom:atom_(),
    binary(),
    binary(),
    binary(),
    binary()
) -> {ok, nil} | {error, glixir@pubsub:pub_sub_error()}.
pubsub_subscribe_with_registry_key(
    Pubsub_name,
    Topic,
    Gleam_module,
    Gleam_function,
    Registry_key
) ->
    glixir@pubsub:subscribe_with_registry_key(
        Pubsub_name,
        Topic,
        Gleam_module,
        Gleam_function,
        Registry_key
    ).

-file("src/glixir.gleam", 149).
?DOC(" Broadcast a message to all subscribers\n").
-spec pubsub_broadcast(
    gleam@erlang@atom:atom_(),
    binary(),
    FHZ,
    fun((FHZ) -> binary())
) -> {ok, nil} | {error, glixir@pubsub:pub_sub_error()}.
pubsub_broadcast(Pubsub_name, Topic, Message, Encode) ->
    glixir@pubsub:broadcast(Pubsub_name, Topic, Message, Encode).

-file("src/glixir.gleam", 159).
?DOC(" Unsubscribe from a topic\n").
-spec pubsub_unsubscribe(gleam@erlang@atom:atom_(), binary()) -> {ok, nil} |
    {error, glixir@pubsub:pub_sub_error()}.
pubsub_unsubscribe(Pubsub_name, Topic) ->
    glixir@pubsub:unsubscribe(Pubsub_name, Topic).

-file("src/glixir.gleam", 171).
?DOC(" Start a phantom-typed unique registry (you must specify key_type, message_type)\n").
-spec start_registry(gleam@erlang@atom:atom_()) -> {ok,
        glixir@registry:registry(any(), any())} |
    {error, glixir@registry:registry_error()}.
start_registry(Name) ->
    glixir@registry:start_unique_registry(Name).

-file("src/glixir.gleam", 178).
?DOC(" Start a registry with specific keys configuration\n").
-spec start_registry_with_keys(
    gleam@erlang@atom:atom_(),
    glixir@registry:registry_keys()
) -> {ok, glixir@registry:registry(any(), any())} |
    {error, glixir@registry:registry_error()}.
start_registry_with_keys(Name, Keys) ->
    glixir@registry:start_registry(Name, Keys).

-file("src/glixir.gleam", 186).
?DOC(" Register a subject with a typed key (requires key encoder)\n").
-spec register_subject(
    gleam@erlang@atom:atom_(),
    FIR,
    gleam@erlang@process:subject(any()),
    fun((FIR) -> binary())
) -> {ok, nil} | {error, glixir@registry:registry_error()}.
register_subject(Registry_name, Key, Subject, Encode_key) ->
    glixir@registry:register_subject(Registry_name, Key, Subject, Encode_key).

-file("src/glixir.gleam", 196).
?DOC(" Look up a subject by typed key (requires key encoder)\n").
-spec lookup_subject(gleam@erlang@atom:atom_(), FIX, fun((FIX) -> binary())) -> {ok,
        gleam@erlang@process:subject(any())} |
    {error, glixir@registry:registry_error()}.
lookup_subject(Registry_name, Key, Encode_key) ->
    glixir@registry:lookup_subject(Registry_name, Key, Encode_key).

-file("src/glixir.gleam", 205).
?DOC(" Unregister a subject by typed key (requires key encoder)\n").
-spec unregister_subject(gleam@erlang@atom:atom_(), FJD, fun((FJD) -> binary())) -> {ok,
        nil} |
    {error, glixir@registry:registry_error()}.
unregister_subject(Registry_name, Key, Encode_key) ->
    glixir@registry:unregister_subject(Registry_name, Key, Encode_key).

-file("src/glixir.gleam", 234).
?DOC(" Start a named dynamic supervisor (you must always specify child_args, child_reply types)\n").
-spec start_dynamic_supervisor_named(gleam@erlang@atom:atom_()) -> {ok,
        glixir@supervisor:dynamic_supervisor(any(), any())} |
    {error, glixir@supervisor:supervisor_error()}.
start_dynamic_supervisor_named(Name) ->
    glixir@utils:debug_log(
        info,
        <<"[glixir] Starting dynamic supervisor: "/utf8,
            (erlang:atom_to_binary(Name))/binary>>
    ),
    case glixir@supervisor:start_dynamic_supervisor_named(Name) of
        {ok, Sup} ->
            glixir@utils:debug_log(
                info,
                <<"[glixir] Dynamic supervisor started successfully"/utf8>>
            ),
            {ok, Sup};

        {error, Error} ->
            glixir@utils:debug_log(
                error,
                <<"[glixir] Dynamic supervisor start failed: "/utf8,
                    (gleam@string:inspect(Error))/binary>>
            ),
            {error, Error}
    end.

-file("src/glixir.gleam", 260).
?DOC(" Build a bounded, type-safe child spec\n").
-spec child_spec(
    binary(),
    binary(),
    binary(),
    FJN,
    glixir@supervisor:restart_strategy(),
    integer(),
    glixir@supervisor:child_type(),
    fun((FJN) -> list(gleam@dynamic:dynamic_()))
) -> glixir@supervisor:child_spec(FJN, any()).
child_spec(
    Id,
    Module,
    Function,
    Args,
    Restart,
    Shutdown_timeout,
    Child_type,
    Encode
) ->
    glixir@supervisor:child_spec(
        Id,
        Module,
        Function,
        Args,
        Restart,
        Shutdown_timeout,
        Child_type,
        Encode
    ).

-file("src/glixir.gleam", 283).
?DOC(" Start a child process in the supervisor (requires encoder/decoder)\n").
-spec start_dynamic_child(
    glixir@supervisor:dynamic_supervisor(FJS, FJT),
    glixir@supervisor:child_spec(FJS, FJT),
    fun((FJS) -> list(gleam@dynamic:dynamic_())),
    fun((gleam@dynamic:dynamic_()) -> {ok, FJT} | {error, binary()})
) -> glixir@supervisor:start_child_result(FJT).
start_dynamic_child(Sup, Spec, Encode, Decode) ->
    glixir@utils:debug_log(
        info,
        <<"[glixir] Starting child: "/utf8, (erlang:element(2, Spec))/binary>>
    ),
    Result = glixir@supervisor:start_dynamic_child(Sup, Spec, Encode, Decode),
    case Result of
        {child_started, Pid, Reply} ->
            glixir@utils:debug_log(
                info,
                <<"[glixir] Child started successfully: "/utf8,
                    (erlang:element(2, Spec))/binary>>
            );

        {start_child_error, E} ->
            glixir@utils:debug_log(
                error,
                <<<<<<"[glixir] Child start failed: "/utf8,
                            (erlang:element(2, Spec))/binary>>/binary,
                        " - "/utf8>>/binary,
                    E/binary>>
            )
    end,
    Result.

-file("src/glixir.gleam", 306).
-spec terminate_dynamic_child(
    glixir@supervisor:dynamic_supervisor(any(), any()),
    gleam@erlang@process:pid_()
) -> {ok, nil} | {error, binary()}.
terminate_dynamic_child(Sup, Child_pid) ->
    glixir@utils:debug_log(
        info,
        <<"[glixir] Terminating child: "/utf8,
            (gleam@string:inspect(Child_pid))/binary>>
    ),
    Result = glixir@supervisor:terminate_dynamic_child(Sup, Child_pid),
    case Result of
        {ok, _} ->
            glixir@utils:debug_log(
                info,
                <<"[glixir] Child terminated successfully"/utf8>>
            );

        {error, E} ->
            glixir@utils:debug_log(
                error,
                <<"[glixir] Child termination failed: "/utf8, E/binary>>
            )
    end,
    Result.

-file("src/glixir.gleam", 328).
?DOC(" Get all dynamic children of the supervisor\n").
-spec which_dynamic_children(glixir@supervisor:dynamic_supervisor(any(), any())) -> list(gleam@dynamic:dynamic_()).
which_dynamic_children(Sup) ->
    glixir@utils:debug_log(info, <<"[glixir] Querying dynamic children"/utf8>>),
    glixir@supervisor:which_dynamic_children(Sup).

-file("src/glixir.gleam", 336).
?DOC(" Get the count of dynamic children\n").
-spec count_dynamic_children(glixir@supervisor:dynamic_supervisor(any(), any())) -> {ok,
        glixir@supervisor:child_counts()} |
    {error, binary()}.
count_dynamic_children(Sup) ->
    glixir@utils:debug_log(info, <<"[glixir] Counting dynamic children"/utf8>>),
    glixir@supervisor:count_dynamic_children(Sup).

-file("src/glixir.gleam", 346).
-spec call_genserver(
    glixir@genserver:gen_server(gleam@dynamic:dynamic_(), FKT),
    gleam@dynamic:dynamic_(),
    gleam@dynamic@decode:decoder(FKT)
) -> {ok, FKT} | {error, glixir@genserver:gen_server_error()}.
call_genserver(Server, Request, Decoder) ->
    glixir@genserver:call(Server, Request, Decoder).

-file("src/glixir.gleam", 354).
-spec call_genserver_timeout(
    glixir@genserver:gen_server(gleam@dynamic:dynamic_(), FKZ),
    gleam@dynamic:dynamic_(),
    integer(),
    gleam@dynamic@decode:decoder(FKZ)
) -> {ok, FKZ} | {error, glixir@genserver:gen_server_error()}.
call_genserver_timeout(Server, Request, Timeout, Decoder) ->
    glixir@genserver:call_timeout(Server, Request, Timeout, Decoder).

-file("src/glixir.gleam", 363).
-spec cast_genserver(
    glixir@genserver:gen_server(gleam@dynamic:dynamic_(), any()),
    gleam@dynamic:dynamic_()
) -> {ok, nil} | {error, glixir@genserver:gen_server_error()}.
cast_genserver(Server, Request) ->
    glixir@genserver:cast(Server, Request).

-file("src/glixir.gleam", 370).
-spec start_genserver(binary(), gleam@dynamic:dynamic_()) -> {ok,
        glixir@genserver:gen_server(gleam@dynamic:dynamic_(), any())} |
    {error, glixir@genserver:gen_server_error()}.
start_genserver(Module, Args) ->
    glixir@genserver:start_link(Module, Args).

-file("src/glixir.gleam", 377).
-spec start_genserver_named(
    binary(),
    gleam@erlang@atom:atom_(),
    gleam@dynamic:dynamic_()
) -> {ok, glixir@genserver:gen_server(gleam@dynamic:dynamic_(), any())} |
    {error, glixir@genserver:gen_server_error()}.
start_genserver_named(Module, Name, Args) ->
    glixir@genserver:start_link_named(Module, erlang:atom_to_binary(Name), Args).

-file("src/glixir.gleam", 385).
-spec ping_genserver(
    glixir@genserver:gen_server(gleam@dynamic:dynamic_(), FLU),
    gleam@dynamic:dynamic_(),
    gleam@dynamic@decode:decoder(FLU)
) -> {ok, FLU} | {error, glixir@genserver:gen_server_error()}.
ping_genserver(Server, Msg, Decoder) ->
    glixir@genserver:call(Server, Msg, Decoder).

-file("src/glixir.gleam", 393).
-spec get_genserver_state(
    glixir@genserver:gen_server(gleam@dynamic:dynamic_(), FMA),
    gleam@dynamic:dynamic_(),
    gleam@dynamic@decode:decoder(FMA)
) -> {ok, FMA} | {error, glixir@genserver:gen_server_error()}.
get_genserver_state(Server, Msg, Decoder) ->
    glixir@genserver:call(Server, Msg, Decoder).

-file("src/glixir.gleam", 401).
-spec call_genserver_named(
    gleam@erlang@atom:atom_(),
    gleam@dynamic:dynamic_(),
    gleam@dynamic@decode:decoder(FMG)
) -> {ok, FMG} | {error, glixir@genserver:gen_server_error()}.
call_genserver_named(Name, Request, Decoder) ->
    glixir@genserver:call_named(Name, Request, Decoder).

-file("src/glixir.gleam", 409).
-spec cast_genserver_named(gleam@erlang@atom:atom_(), gleam@dynamic:dynamic_()) -> {ok,
        nil} |
    {error, glixir@genserver:gen_server_error()}.
cast_genserver_named(Name, Request) ->
    glixir@genserver:cast_named(Name, Request).

-file("src/glixir.gleam", 416).
-spec lookup_genserver(gleam@erlang@atom:atom_()) -> {ok,
        glixir@genserver:gen_server(gleam@dynamic:dynamic_(), any())} |
    {error, glixir@genserver:gen_server_error()}.
lookup_genserver(Name) ->
    glixir@genserver:lookup_name(Name).

-file("src/glixir.gleam", 422).
-spec stop_genserver(
    glixir@genserver:gen_server(gleam@dynamic:dynamic_(), any())
) -> {ok, nil} | {error, glixir@genserver:gen_server_error()}.
stop_genserver(Server) ->
    glixir@genserver:stop(Server).

-file("src/glixir.gleam", 428).
-spec genserver_pid(
    glixir@genserver:gen_server(gleam@dynamic:dynamic_(), any())
) -> gleam@erlang@process:pid_().
genserver_pid(Server) ->
    glixir@genserver:pid(Server).

-file("src/glixir.gleam", 435).
-spec start_agent(fun(() -> FMZ)) -> {ok, glixir@agent:agent(FMZ)} |
    {error, glixir@agent:agent_error()}.
start_agent(State) ->
    glixir@agent:start(State).

-file("src/glixir.gleam", 439).
-spec get_agent(
    glixir@agent:agent(FND),
    fun((FND) -> FNF),
    gleam@dynamic@decode:decoder(FNF)
) -> {ok, FNF} | {error, glixir@agent:agent_error()}.
get_agent(Agent, Fun, Decoder) ->
    glixir@agent:get(Agent, Fun, Decoder).

-file("src/glixir.gleam", 447).
-spec get_agent_timeout(
    glixir@agent:agent(FNJ),
    fun((FNJ) -> FNL),
    integer(),
    gleam@dynamic@decode:decoder(FNL)
) -> {ok, FNL} | {error, glixir@agent:agent_error()}.
get_agent_timeout(Agent, Fun, Timeout, Decoder) ->
    glixir@agent:get_timeout(Agent, Fun, Timeout, Decoder).

-file("src/glixir.gleam", 456).
-spec update_agent(glixir@agent:agent(FNP), fun((FNP) -> FNP)) -> {ok, nil} |
    {error, glixir@agent:agent_error()}.
update_agent(Agent, Fun) ->
    glixir@agent:update(Agent, Fun).

-file("src/glixir.gleam", 460).
-spec cast_agent(glixir@agent:agent(FNT), fun((FNT) -> FNT)) -> nil.
cast_agent(Agent, Fun) ->
    glixir@agent:cast(Agent, Fun).

-file("src/glixir.gleam", 464).
-spec get_and_update_agent(
    glixir@agent:agent(FNV),
    fun((FNV) -> {FNX, FNV}),
    gleam@dynamic@decode:decoder(FNX)
) -> {ok, FNX} | {error, glixir@agent:agent_error()}.
get_and_update_agent(Agent, Fun, Decoder) ->
    glixir@agent:get_and_update(Agent, Fun, Decoder).

-file("src/glixir.gleam", 472).
-spec stop_agent(glixir@agent:agent(any()), gleam@erlang@atom:atom_()) -> {ok,
        nil} |
    {error, glixir@agent:agent_error()}.
stop_agent(Agent, Reason) ->
    glixir@agent:stop(Agent, Reason).

-file("src/glixir.gleam", 476).
-spec agent_pid(glixir@agent:agent(any())) -> gleam@erlang@process:pid_().
agent_pid(Agent) ->
    glixir@agent:pid(Agent).

-file("src/glixir.gleam", 483).
-spec main() -> nil.
main() ->
    logging_ffi:configure().