-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_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", 133).
?DOC(" Broadcast a message to all subscribers\n").
-spec pubsub_broadcast(
    gleam@erlang@atom:atom_(),
    binary(),
    FHO,
    fun((FHO) -> 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", 143).
?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", 155).
?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", 162).
?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", 170).
?DOC(" Register a subject with a typed key (requires key encoder)\n").
-spec register_subject(
    gleam@erlang@atom:atom_(),
    FIG,
    gleam@erlang@process:subject(any()),
    fun((FIG) -> 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", 180).
?DOC(" Look up a subject by typed key (requires key encoder)\n").
-spec lookup_subject(gleam@erlang@atom:atom_(), FIM, fun((FIM) -> 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", 189).
?DOC(" Unregister a subject by typed key (requires key encoder)\n").
-spec unregister_subject(gleam@erlang@atom:atom_(), FIS, fun((FIS) -> 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", 218).
?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", 244).
?DOC(" Build a bounded, type-safe child spec\n").
-spec child_spec(
    binary(),
    binary(),
    binary(),
    FJC,
    glixir@supervisor:restart_strategy(),
    integer(),
    glixir@supervisor:child_type(),
    fun((FJC) -> list(gleam@dynamic:dynamic_()))
) -> glixir@supervisor:child_spec(FJC, 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", 267).
?DOC(" Start a child process in the supervisor (requires encoder/decoder)\n").
-spec start_dynamic_child(
    glixir@supervisor:dynamic_supervisor(FJH, FJI),
    glixir@supervisor:child_spec(FJH, FJI),
    fun((FJH) -> list(gleam@dynamic:dynamic_())),
    fun((gleam@dynamic:dynamic_()) -> {ok, FJI} | {error, binary()})
) -> glixir@supervisor:start_child_result(FJI).
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", 290).
-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", 312).
?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", 320).
?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", 330).
-spec call_genserver(
    glixir@genserver:gen_server(gleam@dynamic:dynamic_(), FKI),
    gleam@dynamic:dynamic_(),
    gleam@dynamic@decode:decoder(FKI)
) -> {ok, FKI} | {error, glixir@genserver:gen_server_error()}.
call_genserver(Server, Request, Decoder) ->
    glixir@genserver:call(Server, Request, Decoder).

-file("src/glixir.gleam", 338).
-spec call_genserver_timeout(
    glixir@genserver:gen_server(gleam@dynamic:dynamic_(), FKO),
    gleam@dynamic:dynamic_(),
    integer(),
    gleam@dynamic@decode:decoder(FKO)
) -> {ok, FKO} | {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", 347).
-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", 354).
-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", 361).
-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", 369).
-spec ping_genserver(
    glixir@genserver:gen_server(gleam@dynamic:dynamic_(), FLJ),
    gleam@dynamic:dynamic_(),
    gleam@dynamic@decode:decoder(FLJ)
) -> {ok, FLJ} | {error, glixir@genserver:gen_server_error()}.
ping_genserver(Server, Msg, Decoder) ->
    glixir@genserver:call(Server, Msg, Decoder).

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

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

-file("src/glixir.gleam", 393).
-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", 400).
-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", 406).
-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", 412).
-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", 419).
-spec start_agent(fun(() -> FMO)) -> {ok, glixir@agent:agent(FMO)} |
    {error, glixir@agent:agent_error()}.
start_agent(State) ->
    glixir@agent:start(State).

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

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

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

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

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

-file("src/glixir.gleam", 456).
-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", 460).
-spec agent_pid(glixir@agent:agent(any())) -> gleam@erlang@process:pid_().
agent_pid(Agent) ->
    glixir@agent:pid(Agent).

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