glixir

-module(glixir@agent).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/glixir/agent.gleam").
-export([start/1, start_named/2, get/3, get_timeout/4, update/2, cast/2, get_and_update/3, stop/2, pid/1]).
-export_type([agent/1, agent_error/0]).

-opaque agent(EJR) :: {agent, gleam@erlang@process:pid_()} |
    {gleam_phantom, EJR}.

-type agent_error() :: {start_error, binary()} |
    timeout |
    agent_down |
    {decode_error, binary()}.

-file("src/glixir/agent.gleam", 44).
-spec start(fun(() -> EKC)) -> {ok, agent(EKC)} | {error, agent_error()}.
start(Initial_fun) ->
    case 'Elixir.Agent':start_link(Initial_fun, []) of
        {ok, Pid} ->
            {ok, {agent, Pid}};

        {error, Reason} ->
            {error, {start_error, gleam@string:inspect(Reason)}}
    end.

-file("src/glixir/agent.gleam", 51).
-spec start_named(gleam@erlang@atom:atom_(), fun(() -> EKG)) -> {ok, agent(EKG)} |
    {error, agent_error()}.
start_named(Name, Initial_fun) ->
    Options = [erlang:list_to_tuple(
            [gleam_erlang_ffi:identity(erlang:binary_to_atom(<<"name"/utf8>>)),
                gleam_erlang_ffi:identity(Name)]
        )],
    case 'Elixir.Agent':start_link(Initial_fun, Options) of
        {ok, Pid} ->
            {ok, {agent, Pid}};

        {error, Reason} ->
            {error, {start_error, gleam@string:inspect(Reason)}}
    end.

-file("src/glixir/agent.gleam", 64).
-spec get(agent(EKK), fun((EKK) -> EKM), gleam@dynamic@decode:decoder(EKM)) -> {ok,
        EKM} |
    {error, agent_error()}.
get(Agent, Fun, Decoder) ->
    {agent, Pid} = Agent,
    Result_dynamic = 'Elixir.Agent':get(Pid, Fun, 5000),
    _pipe = gleam@dynamic@decode:run(Result_dynamic, Decoder),
    _pipe@1 = gleam@result:map_error(_pipe, fun gleam@string:inspect/1),
    gleam@result:map_error(_pipe@1, fun(Field@0) -> {decode_error, Field@0} end).

-file("src/glixir/agent.gleam", 76).
-spec get_timeout(
    agent(EKQ),
    fun((EKQ) -> EKS),
    integer(),
    gleam@dynamic@decode:decoder(EKS)
) -> {ok, EKS} | {error, agent_error()}.
get_timeout(Agent, Fun, Timeout, Decoder) ->
    {agent, Pid} = Agent,
    Result_dynamic = 'Elixir.Agent':get(Pid, Fun, Timeout),
    _pipe = gleam@dynamic@decode:run(Result_dynamic, Decoder),
    _pipe@1 = gleam@result:map_error(_pipe, fun gleam@string:inspect/1),
    gleam@result:map_error(_pipe@1, fun(Field@0) -> {decode_error, Field@0} end).

-file("src/glixir/agent.gleam", 89).
-spec update(agent(EKW), fun((EKW) -> EKW)) -> {ok, nil} |
    {error, agent_error()}.
update(Agent, Fun) ->
    {agent, Pid} = Agent,
    case erlang:atom_to_binary('Elixir.Agent':update(Pid, Fun, 5000)) of
        <<"ok"/utf8>> ->
            {ok, nil};

        _ ->
            {error, agent_down}
    end.

-file("src/glixir/agent.gleam", 100).
-spec cast(agent(ELA), fun((ELA) -> ELA)) -> nil.
cast(Agent, Fun) ->
    {agent, Pid} = Agent,
    _ = 'Elixir.Agent':cast(Pid, Fun),
    nil.

-file("src/glixir/agent.gleam", 106).
-spec get_and_update(
    agent(ELC),
    fun((ELC) -> {ELE, ELC}),
    gleam@dynamic@decode:decoder(ELE)
) -> {ok, ELE} | {error, agent_error()}.
get_and_update(Agent, Fun, Decoder) ->
    {agent, Pid} = Agent,
    Result_dynamic = 'Elixir.Agent':get_and_update(Pid, Fun, 5000),
    _pipe = gleam@dynamic@decode:run(Result_dynamic, Decoder),
    _pipe@1 = gleam@result:map_error(_pipe, fun gleam@string:inspect/1),
    gleam@result:map_error(_pipe@1, fun(Field@0) -> {decode_error, Field@0} end).

-file("src/glixir/agent.gleam", 118).
-spec stop(agent(any()), gleam@erlang@atom:atom_()) -> {ok, nil} |
    {error, agent_error()}.
stop(Agent, Reason) ->
    {agent, Pid} = Agent,
    case erlang:atom_to_binary('Elixir.Agent':stop(Pid, Reason, 5000)) of
        <<"ok"/utf8>> ->
            {ok, nil};

        _ ->
            {error, agent_down}
    end.

-file("src/glixir/agent.gleam", 126).
-spec pid(agent(any())) -> gleam@erlang@process:pid_().
pid(Agent) ->
    {agent, P} = Agent,
    P.