glixir

-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_simple_genserver/2, ping_genserver/1, get_genserver_state/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, main/0, 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", 62).
?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_dynamic_supervisor_simple().

-file("src/glixir.gleam", 67).
?DOC(" Start a simple supervisor with defaults\n").
-spec start_supervisor_simple() -> {ok, glixir@supervisor:supervisor()} |
    {error, glixir@supervisor:supervisor_error()}.
start_supervisor_simple() ->
    logging:log(debug, <<"Starting simple supervisor"/utf8>>),
    Result = glixir@supervisor:start_dynamic_supervisor_simple(),
    case Result of
        {ok, Sup} ->
            logging:log(info, <<"Simple supervisor started successfully"/utf8>>),
            {ok, Sup};

        {error, Error} ->
            logging:log(
                error,
                <<"Simple supervisor start failed: "/utf8,
                    (gleam@string:inspect(Error))/binary>>
            ),
            {error, Error}
    end.

-file("src/glixir.gleam", 87).
?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, _) ->
    logging:log(debug, <<"Starting named supervisor: "/utf8, Name/binary>>),
    Result = glixir@supervisor:start_dynamic_supervisor_named(Name),
    case Result of
        {ok, Sup} ->
            logging:log(
                info,
                <<<<"Named supervisor '"/utf8, Name/binary>>/binary,
                    "' started successfully"/utf8>>
            ),
            {ok, Sup};

        {error, Error} ->
            logging:log(
                error,
                <<<<<<"Named supervisor '"/utf8, Name/binary>>/binary,
                        "' start failed: "/utf8>>/binary,
                    (gleam@string:inspect(Error))/binary>>
            ),
            {error, Error}
    end.

-file("src/glixir.gleam", 116).
?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", 126).
?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_instance, Spec) ->
    logging:log(
        debug,
        <<"Starting child with id: "/utf8, (erlang:element(2, Spec))/binary>>
    ),
    Result = glixir@supervisor:start_dynamic_child(Supervisor_instance, Spec),
    case Result of
        {ok, Pid} ->
            logging:log(
                info,
                <<<<"Child '"/utf8, (erlang:element(2, Spec))/binary>>/binary,
                    "' started successfully"/utf8>>
            ),
            {ok, Pid};

        {error, Error} ->
            logging:log(
                error,
                <<<<<<"Child '"/utf8, (erlang:element(2, Spec))/binary>>/binary,
                        "' start failed: "/utf8>>/binary,
                    Error/binary>>
            ),
            {error, Error}
    end.

-file("src/glixir.gleam", 152).
?DOC(" Terminate a child process\n").
-spec terminate_child(glixir@supervisor:supervisor(), binary()) -> {ok, nil} |
    {error, glixir@supervisor:child_operation_error()}.
terminate_child(Supervisor_instance, Child_id) ->
    logging:log(debug, <<"Terminating child: "/utf8, Child_id/binary>>),
    case glixir@supervisor:terminate_child(Supervisor_instance, Child_id) of
        terminate_child_ok ->
            logging:log(
                info,
                <<<<"Child '"/utf8, Child_id/binary>>/binary,
                    "' terminated successfully"/utf8>>
            ),
            {ok, nil};

        {terminate_child_error, Error} ->
            logging:log(
                error,
                <<<<"Failed to terminate child '"/utf8, Child_id/binary>>/binary,
                    "'"/utf8>>
            ),
            {error, Error}
    end.

-file("src/glixir.gleam", 177).
?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_instance, Child_id) ->
    logging:log(debug, <<"Restarting child: "/utf8, Child_id/binary>>),
    case glixir@supervisor:restart_child(Supervisor_instance, Child_id) of
        {restart_child_ok, Pid} ->
            logging:log(
                info,
                <<<<"Child '"/utf8, Child_id/binary>>/binary,
                    "' restarted successfully"/utf8>>
            ),
            {ok, Pid};

        {restart_child_ok_already_started, Pid@1} ->
            logging:log(
                info,
                <<<<"Child '"/utf8, Child_id/binary>>/binary,
                    "' was already started"/utf8>>
            ),
            {ok, Pid@1};

        {restart_child_error, Error} ->
            logging:log(
                error,
                <<<<"Failed to restart child '"/utf8, Child_id/binary>>/binary,
                    "'"/utf8>>
            ),
            {error, Error}
    end.

-file("src/glixir.gleam", 206).
?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_instance, Child_id) ->
    logging:log(debug, <<"Deleting child spec: "/utf8, Child_id/binary>>),
    case glixir@supervisor:delete_child(Supervisor_instance, Child_id) of
        delete_child_ok ->
            logging:log(
                info,
                <<<<"Child spec '"/utf8, Child_id/binary>>/binary,
                    "' deleted successfully"/utf8>>
            ),
            {ok, nil};

        {delete_child_error, Error} ->
            logging:log(
                error,
                <<<<"Failed to delete child spec '"/utf8, Child_id/binary>>/binary,
                    "'"/utf8>>
            ),
            {error, Error}
    end.

-file("src/glixir.gleam", 231).
?DOC(" Get list of child processes\n").
-spec which_children(glixir@supervisor:supervisor()) -> list(glixir@supervisor:child_info_result()).
which_children(Supervisor_instance) ->
    logging:log(debug, <<"Querying supervisor children"/utf8>>),
    glixir@supervisor:which_dynamic_children(Supervisor_instance).

-file("src/glixir.gleam", 239).
?DOC(" Count children by status\n").
-spec count_children(glixir@supervisor:supervisor()) -> glixir@supervisor:child_counts().
count_children(Supervisor_instance) ->
    logging:log(debug, <<"Counting supervisor children"/utf8>>),
    glixir@supervisor:count_dynamic_children(Supervisor_instance).

-file("src/glixir.gleam", 251).
?DOC(" Start a simple GenServer with one argument\n").
-spec start_simple_genserver(binary(), binary()) -> {ok,
        glixir@genserver:gen_server()} |
    {error, glixir@genserver:gen_server_error()}.
start_simple_genserver(Module, Initial_state) ->
    glixir@genserver:start_link(Module, Initial_state).

-file("src/glixir.gleam", 259).
?DOC(" Ping a GenServer (returns :pong if successful)\n").
-spec ping_genserver(glixir@genserver:gen_server()) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, glixir@genserver:gen_server_error()}.
ping_genserver(Server) ->
    glixir@genserver:call(
        Server,
        begin
            _pipe = erlang:binary_to_atom(<<"ping"/utf8>>),
            gleam_erlang_ffi:identity(_pipe)
        end
    ).

-file("src/glixir.gleam", 264).
?DOC(" Get state from a GenServer\n").
-spec get_genserver_state(glixir@genserver:gen_server()) -> {ok,
        gleam@dynamic:dynamic_()} |
    {error, glixir@genserver:gen_server_error()}.
get_genserver_state(Server) ->
    glixir@genserver:call(
        Server,
        begin
            _pipe = erlang:binary_to_atom(<<"get_state"/utf8>>),
            gleam_erlang_ffi:identity(_pipe)
        end
    ).

-file("src/glixir.gleam", 269).
?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) ->
    logging:log(debug, <<"Starting GenServer: "/utf8, Module/binary>>),
    glixir@genserver:start_link(Module, Args).

-file("src/glixir.gleam", 278).
?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) ->
    logging:log(
        debug,
        <<<<<<"Starting named GenServer: "/utf8, Module/binary>>/binary,
                " as "/utf8>>/binary,
            Name/binary>>
    ),
    glixir@genserver:start_link_named(Module, Name, Args).

-file("src/glixir.gleam", 291).
?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", 299).
?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", 308).
?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", 316).
?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", 324).
?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", 332).
?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", 337).
?DOC(" Stop a GenServer gracefully\n").
-spec stop_genserver(glixir@genserver:gen_server()) -> {ok, nil} |
    {error, glixir@genserver:gen_server_error()}.
stop_genserver(Server) ->
    logging:log(debug, <<"Stopping GenServer"/utf8>>),
    glixir@genserver:stop(Server).

-file("src/glixir.gleam", 343).
?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", 352).
?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) ->
    logging:log(debug, <<"Starting Agent"/utf8>>),
    glixir@agent:start(Initial_fun).

-file("src/glixir.gleam", 358).
?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) ->
    logging:log(debug, <<"Starting named Agent: "/utf8, Name/binary>>),
    glixir@agent:start_named(Name, Initial_fun).

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

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

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

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

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

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

-file("src/glixir.gleam", 411).
?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", 454).
?DOC(" Main function for when glixir is run directly (demo/testing)\n").
-spec main() -> nil.
main() ->
    logging_ffi:configure().

-file("src/glixir.gleam", 420).
?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", 437).
?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}.