-module(glixir).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-define(FILEPATH, "src/glixir.gleam").
-export([start_supervisor/0, start_supervisor_simple/0, start_supervisor_named/2, child_spec/4, start_child/2, terminate_child/2, restart_child/2, delete_child/2, which_children/1, count_children/1, start_genserver/2, start_genserver_named/3, call_genserver/2, call_genserver_timeout/3, call_genserver_named/2, cast_genserver/2, cast_genserver_named/2, lookup_genserver/1, stop_genserver/1, genserver_pid/1, start_agent/1, start_agent_named/2, get_agent/3, get_agent_timeout/4, update_agent/2, cast_agent/2, get_and_update_agent/3, stop_agent/1, agent_pid/1, worker_spec/3, supervisor_spec/3]).

-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(
    " glixir - Seamless OTP interop between Gleam and Elixir/Erlang\n"
    " \n"
    " This module provides a unified API for working with OTP processes from Gleam.\n"
    " Import this module to get access to Supervisors, GenServers, and Agents.\n"
).

-file("src/glixir.gleam", 63).
?DOC(" Start a supervisor with default options\n").
-spec start_supervisor() -> {ok, glixir@supervisor:supervisor()} |
    {error, glixir@supervisor:supervisor_error()}.
start_supervisor() ->
    glixir@supervisor:start_link_default().

-file("src/glixir.gleam", 68).
?DOC(" Start a simple supervisor with defaults\n").
-spec start_supervisor_simple() -> {ok, glixir@supervisor:supervisor()} |
    {error, glixir@supervisor:supervisor_error()}.
start_supervisor_simple() ->
    gleam_stdlib:println(<<"DEBUG: start_supervisor_simple called"/utf8>>),
    Result = glixir@supervisor:start_dynamic_supervisor_simple(),
    case Result of
        {ok, Sup} ->
            gleam_stdlib:println(
                <<"DEBUG: simple supervisor started successfully"/utf8>>
            ),
            {ok, Sup};

        {error, Error} ->
            gleam_stdlib:println(
                <<"DEBUG: simple supervisor start failed with error: "/utf8,
                    (gleam@string:inspect(Error))/binary>>
            ),
            {error, Error}
    end.

-file("src/glixir.gleam", 88).
?DOC(" Start a named supervisor using DynamicSupervisor\n").
-spec start_supervisor_named(
    binary(),
    list({binary(), gleam@dynamic:dynamic_()})
) -> {ok, glixir@supervisor:supervisor()} |
    {error, glixir@supervisor:supervisor_error()}.
start_supervisor_named(Name, _) ->
    gleam_stdlib:println(
        <<"DEBUG: start_supervisor_named called with name: "/utf8, Name/binary>>
    ),
    Result = glixir@supervisor:start_dynamic_supervisor_named(Name),
    case Result of
        {ok, Sup} ->
            gleam_stdlib:println(
                <<"DEBUG: supervisor started successfully"/utf8>>
            ),
            {ok, Sup};

        {error, Error} ->
            gleam_stdlib:println(
                <<"DEBUG: supervisor start failed with error: "/utf8,
                    (gleam@string:inspect(Error))/binary>>
            ),
            {error, Error}
    end.

-file("src/glixir.gleam", 110).
?DOC(" Create a child specification\n").
-spec child_spec(binary(), binary(), binary(), list(gleam@dynamic:dynamic_())) -> glixir@supervisor:simple_child_spec().
child_spec(Id, Module, Function, Args) ->
    glixir@supervisor:child_spec(Id, Module, Function, Args).

-file("src/glixir.gleam", 120).
?DOC(" Start a child process in the supervisor\n").
-spec start_child(
    glixir@supervisor:supervisor(),
    glixir@supervisor:simple_child_spec()
) -> {ok, gleam@erlang@process:pid_()} | {error, binary()}.
start_child(Supervisor, Spec) ->
    gleam_stdlib:println(
        <<"DEBUG: start_child called with spec id: "/utf8,
            (erlang:element(2, Spec))/binary>>
    ),
    Result = glixir@supervisor:start_child_simple(Supervisor, Spec),
    case Result of
        {ok, Pid} ->
            gleam_stdlib:println(
                <<"DEBUG: child started successfully with PID"/utf8>>
            ),
            {ok, Pid};

        {error, Error} ->
            gleam_stdlib:println(
                <<"DEBUG: child start failed with error: "/utf8, Error/binary>>
            ),
            {error, Error}
    end.

-file("src/glixir.gleam", 140).
?DOC(" Terminate a child process\n").
-spec terminate_child(glixir@supervisor:supervisor(), binary()) -> {ok, nil} |
    {error, glixir@supervisor:child_operation_error()}.
terminate_child(Supervisor, Child_id) ->
    case glixir@supervisor:terminate_child(Supervisor, Child_id) of
        terminate_child_ok ->
            {ok, nil};

        {terminate_child_error, Error} ->
            {error, Error}
    end.

-file("src/glixir.gleam", 151).
?DOC(" Restart a child process\n").
-spec restart_child(glixir@supervisor:supervisor(), binary()) -> {ok,
        gleam@erlang@process:pid_()} |
    {error, glixir@supervisor:child_operation_error()}.
restart_child(Supervisor, Child_id) ->
    case glixir@supervisor:restart_child(Supervisor, Child_id) of
        {restart_child_ok, Pid} ->
            {ok, Pid};

        {restart_child_ok_already_started, Pid@1} ->
            {ok, Pid@1};

        {restart_child_error, Error} ->
            {error, Error}
    end.

-file("src/glixir.gleam", 163).
?DOC(" Delete a child specification from the supervisor\n").
-spec delete_child(glixir@supervisor:supervisor(), binary()) -> {ok, nil} |
    {error, glixir@supervisor:child_operation_error()}.
delete_child(Supervisor, Child_id) ->
    case glixir@supervisor:delete_child(Supervisor, Child_id) of
        delete_child_ok ->
            {ok, nil};

        {delete_child_error, Error} ->
            {error, Error}
    end.

-file("src/glixir.gleam", 174).
?DOC(" Get list of child processes\n").
-spec which_children(glixir@supervisor:supervisor()) -> list(glixir@supervisor:child_info_result()).
which_children(Supervisor) ->
    glixir@supervisor:which_children(Supervisor).

-file("src/glixir.gleam", 181).
?DOC(" Count children by status\n").
-spec count_children(glixir@supervisor:supervisor()) -> glixir@supervisor:child_counts().
count_children(Supervisor) ->
    glixir@supervisor:count_children(Supervisor).

-file("src/glixir.gleam", 190).
?DOC(" Start a GenServer using Module.start_link/1\n").
-spec start_genserver(binary(), any()) -> {ok, glixir@genserver:gen_server()} |
    {error, glixir@genserver:gen_server_error()}.
start_genserver(Module, Args) ->
    glixir@genserver:start_link(Module, Args).

-file("src/glixir.gleam", 198).
?DOC(" Start a named GenServer\n").
-spec start_genserver_named(binary(), binary(), any()) -> {ok,
        glixir@genserver:gen_server()} |
    {error, glixir@genserver:gen_server_error()}.
start_genserver_named(Module, Name, Args) ->
    glixir@genserver:start_link_named(Module, Name, Args).

-file("src/glixir.gleam", 207).
?DOC(" Send a synchronous call to the GenServer (5s timeout)\n").
-spec call_genserver(glixir@genserver:gen_server(), any()) -> {ok, any()} |
    {error, glixir@genserver:gen_server_error()}.
call_genserver(Server, Request) ->
    glixir@genserver:call(Server, Request).

-file("src/glixir.gleam", 215).
?DOC(" Send a synchronous call with custom timeout\n").
-spec call_genserver_timeout(glixir@genserver:gen_server(), any(), integer()) -> {ok,
        any()} |
    {error, glixir@genserver:gen_server_error()}.
call_genserver_timeout(Server, Request, Timeout) ->
    glixir@genserver:call_timeout(Server, Request, Timeout).

-file("src/glixir.gleam", 224).
?DOC(" Call a named GenServer\n").
-spec call_genserver_named(binary(), any()) -> {ok, any()} |
    {error, glixir@genserver:gen_server_error()}.
call_genserver_named(Name, Request) ->
    glixir@genserver:call_named(Name, Request).

-file("src/glixir.gleam", 232).
?DOC(" Send an asynchronous cast to the GenServer\n").
-spec cast_genserver(glixir@genserver:gen_server(), any()) -> {ok, nil} |
    {error, glixir@genserver:gen_server_error()}.
cast_genserver(Server, Request) ->
    glixir@genserver:cast(Server, Request).

-file("src/glixir.gleam", 240).
?DOC(" Cast to a named GenServer\n").
-spec cast_genserver_named(binary(), any()) -> {ok, nil} |
    {error, glixir@genserver:gen_server_error()}.
cast_genserver_named(Name, Request) ->
    glixir@genserver:cast_named(Name, Request).

-file("src/glixir.gleam", 248).
?DOC(" Look up a GenServer by registered name\n").
-spec lookup_genserver(binary()) -> {ok, glixir@genserver:gen_server()} |
    {error, glixir@genserver:gen_server_error()}.
lookup_genserver(Name) ->
    glixir@genserver:lookup_name(Name).

-file("src/glixir.gleam", 253).
?DOC(" Stop a GenServer gracefully\n").
-spec stop_genserver(glixir@genserver:gen_server()) -> {ok, nil} |
    {error, glixir@genserver:gen_server_error()}.
stop_genserver(Server) ->
    glixir@genserver:stop(Server).

-file("src/glixir.gleam", 258).
?DOC(" Get the PID of a GenServer\n").
-spec genserver_pid(glixir@genserver:gen_server()) -> gleam@erlang@process:pid_().
genserver_pid(Server) ->
    glixir@genserver:pid(Server).

-file("src/glixir.gleam", 267).
?DOC(" Start a new Agent with initial state\n").
-spec start_agent(fun(() -> any())) -> {ok, glixir@agent:agent()} |
    {error, glixir@agent:agent_error()}.
start_agent(Initial_fun) ->
    glixir@agent:start(Initial_fun).

-file("src/glixir.gleam", 272).
?DOC(" Start an Agent with a name\n").
-spec start_agent_named(binary(), fun(() -> any())) -> {ok,
        glixir@agent:agent()} |
    {error, glixir@agent:agent_error()}.
start_agent_named(Name, Initial_fun) ->
    glixir@agent:start_named(Name, Initial_fun).

-file("src/glixir.gleam", 280).
?DOC(" Get the current state from an Agent\n").
-spec get_agent(
    glixir@agent:agent(),
    fun((any()) -> EQW),
    gleam@dynamic@decode:decoder(EQW)
) -> {ok, EQW} | {error, glixir@agent:agent_error()}.
get_agent(Agent, Fun, Decoder) ->
    glixir@agent:get(Agent, Fun, Decoder).

-file("src/glixir.gleam", 289).
?DOC(" Get with custom timeout\n").
-spec get_agent_timeout(
    glixir@agent:agent(),
    fun((any()) -> ERB),
    integer(),
    gleam@dynamic@decode:decoder(ERB)
) -> {ok, ERB} | {error, glixir@agent:agent_error()}.
get_agent_timeout(Agent, Fun, Timeout, Decoder) ->
    glixir@agent:get_timeout(Agent, Fun, Timeout, Decoder).

-file("src/glixir.gleam", 299).
?DOC(" Update the Agent state synchronously\n").
-spec update_agent(glixir@agent:agent(), fun((ERF) -> ERF)) -> {ok, nil} |
    {error, glixir@agent:agent_error()}.
update_agent(Agent, Fun) ->
    glixir@agent:update(Agent, Fun).

-file("src/glixir.gleam", 304).
?DOC(" Update the Agent state asynchronously\n").
-spec cast_agent(glixir@agent:agent(), fun((ERI) -> ERI)) -> nil.
cast_agent(Agent, Fun) ->
    glixir@agent:cast(Agent, Fun).

-file("src/glixir.gleam", 309).
?DOC(" Get and update in one operation\n").
-spec get_and_update_agent(
    glixir@agent:agent(),
    fun((ERJ) -> {ERK, ERJ}),
    gleam@dynamic@decode:decoder(ERK)
) -> {ok, ERK} | {error, glixir@agent:agent_error()}.
get_and_update_agent(Agent, Fun, Decoder) ->
    glixir@agent:get_and_update(Agent, Fun, Decoder).

-file("src/glixir.gleam", 318).
?DOC(" Stop an Agent\n").
-spec stop_agent(glixir@agent:agent()) -> {ok, nil} |
    {error, glixir@agent:agent_error()}.
stop_agent(Agent) ->
    glixir@agent:stop(Agent).

-file("src/glixir.gleam", 323).
?DOC(" Get the PID of an Agent\n").
-spec agent_pid(glixir@agent:agent()) -> gleam@erlang@process:pid_().
agent_pid(Agent) ->
    glixir@agent:pid(Agent).

-file("src/glixir.gleam", 332).
?DOC(" Create a simple worker child spec with defaults\n").
-spec worker_spec(binary(), binary(), list(gleam@dynamic:dynamic_())) -> glixir@supervisor:simple_child_spec().
worker_spec(Id, Module, Args) ->
    {simple_child_spec,
        Id,
        erlang:binary_to_atom(Module),
        erlang:binary_to_atom(<<"start_link"/utf8>>),
        Args,
        permanent,
        5000,
        worker}.

-file("src/glixir.gleam", 349).
?DOC(" Create a supervisor child spec\n").
-spec supervisor_spec(binary(), binary(), list(gleam@dynamic:dynamic_())) -> glixir@supervisor:simple_child_spec().
supervisor_spec(Id, Module, Args) ->
    {simple_child_spec,
        Id,
        erlang:binary_to_atom(Module),
        erlang:binary_to_atom(<<"start_link"/utf8>>),
        Args,
        permanent,
        5000,
        supervisor_child}.