bath

-module(bath).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([shutdown/3, force_shutdown/2, apply/3, init/2]).
-export_type([msg/1, pool_state/1, pool/1, init_error/1, shutdown_error/0, apply_error/0]).

-type msg(HLY) :: {check_in, HLY} |
    {check_out,
        gleam@erlang@process:subject({ok, HLY} | {error, apply_error()})} |
    {shutdown,
        fun((HLY) -> nil),
        gleam@erlang@process:subject({ok, nil} | {error, shutdown_error()})} |
    {force_shutdown, fun((HLY) -> nil)}.

-type pool_state(HLZ) :: {pool_state, list(HLZ), list(HLZ)}.

-opaque pool(HMA) :: {pool, integer(), gleam@erlang@process:subject(msg(HMA))}.

-type init_error(HMB) :: {start_error, gleam@otp@actor:start_error()} |
    {resource_create_error, HMB}.

-type shutdown_error() :: resources_in_use |
    shutdown_timeout |
    {callee_down, gleam@dynamic:dynamic_()}.

-type apply_error() :: no_resources_available | checkout_timeout.

-file("/Users/isaac/repos/bath/src/bath.gleam", 109).
-spec shutdown(pool(HMR), fun((HMR) -> nil), integer()) -> {ok, nil} |
    {error, shutdown_error()}.
shutdown(Pool, Resource_shutdown_function, Timeout) ->
    _pipe = gleam@erlang@process:try_call(
        erlang:element(3, Pool),
        fun(_capture) -> {shutdown, Resource_shutdown_function, _capture} end,
        Timeout
    ),
    _pipe@1 = gleam@result:map_error(_pipe, fun(Err) -> case Err of
                call_timeout ->
                    shutdown_timeout;

                {callee_down, Reason} ->
                    {callee_down, Reason}
            end end),
    gleam@result:flatten(_pipe@1).

-file("/Users/isaac/repos/bath/src/bath.gleam", 133).
-spec force_shutdown(pool(HMU), fun((HMU) -> nil)) -> nil.
force_shutdown(Pool, Resource_shutdown_function) ->
    gleam@erlang@process:send(
        erlang:element(3, Pool),
        {force_shutdown, Resource_shutdown_function}
    ).

-file("/Users/isaac/repos/bath/src/bath.gleam", 140).
-spec check_out(gleam@erlang@process:subject(msg(HMX)), integer()) -> {ok, HMX} |
    {error, apply_error()}.
check_out(Pool_subject, Timeout) ->
    _pipe = gleam@erlang@process:try_call(
        Pool_subject,
        fun(Field@0) -> {check_out, Field@0} end,
        Timeout
    ),
    _pipe@1 = gleam@result:replace_error(_pipe, checkout_timeout),
    gleam@result:flatten(_pipe@1).

-file("/Users/isaac/repos/bath/src/bath.gleam", 146).
-spec check_in(gleam@erlang@process:subject(msg(HNA)), HNA) -> nil.
check_in(Pool_subject, Item) ->
    gleam@erlang@process:send(Pool_subject, {check_in, Item}).

-file("/Users/isaac/repos/bath/src/bath.gleam", 94).
-spec apply(pool(HMN), integer(), fun((HMN) -> HMP)) -> {ok, HMP} |
    {error, apply_error()}.
apply(Pool, Timeout, Next) ->
    gleam@result:'try'(
        check_out(erlang:element(3, Pool), Timeout),
        fun(Resource) ->
            Result = Next(Resource),
            check_in(erlang:element(3, Pool), Resource),
            {ok, Result}
        end
    ).

-file("/Users/isaac/repos/bath/src/bath.gleam", 153).
-spec handle_message(msg(HNC), pool_state(HNC)) -> gleam@otp@actor:next(any(), pool_state(HNC)).
handle_message(Msg, Pool_state) ->
    case Msg of
        {check_in, Resource} ->
            Checked_out = begin
                _pipe = erlang:element(3, Pool_state),
                gleam@list:filter(_pipe, fun(Item) -> Item /= Resource end)
            end,
            Checked_in = [Resource | erlang:element(2, Pool_state)],
            gleam@otp@actor:continue({pool_state, Checked_in, Checked_out});

        {check_out, Client} ->
            case erlang:element(2, Pool_state) of
                [] ->
                    gleam@otp@actor:send(
                        Client,
                        {error, no_resources_available}
                    ),
                    gleam@otp@actor:continue(Pool_state);

                [Chosen | Checked_in@1] ->
                    gleam@otp@actor:send(Client, {ok, Chosen}),
                    gleam@otp@actor:continue(
                        {pool_state,
                            Checked_in@1,
                            [Chosen | erlang:element(3, Pool_state)]}
                    )
            end;

        {shutdown, Resource_shutdown_function, Reply_to} ->
            case erlang:element(3, Pool_state) of
                [] ->
                    _pipe@1 = erlang:element(2, Pool_state),
                    gleam@list:each(_pipe@1, Resource_shutdown_function),
                    gleam@erlang@process:send(Reply_to, {ok, nil}),
                    {stop, normal};

                _ ->
                    gleam@erlang@process:send(
                        Reply_to,
                        {error, resources_in_use}
                    ),
                    gleam@otp@actor:continue(Pool_state)
            end;

        {force_shutdown, Resource_shutdown_function@1} ->
            _pipe@2 = lists:append(
                erlang:element(2, Pool_state),
                erlang:element(3, Pool_state)
            ),
            gleam@list:each(_pipe@2, Resource_shutdown_function@1),
            {stop, normal}
    end.

-file("/Users/isaac/repos/bath/src/bath.gleam", 62).
-spec init(integer(), fun(() -> {ok, HMF} | {error, HMG})) -> {ok, pool(HMF)} |
    {error, init_error(HMG)}.
init(Size, Resource_create_function) ->
    Resources_result = begin
        _pipe = gleam@list:repeat(<<""/utf8>>, Size),
        gleam@list:try_map(
            _pipe,
            fun(_) -> _pipe@1 = Resource_create_function(),
                gleam@result:map_error(
                    _pipe@1,
                    fun(Field@0) -> {resource_create_error, Field@0} end
                ) end
        )
    end,
    gleam@result:'try'(
        Resources_result,
        fun(Resources) ->
            Actor_result = begin
                _pipe@2 = gleam@otp@actor:start(
                    {pool_state, Resources, []},
                    fun handle_message/2
                ),
                gleam@result:map_error(
                    _pipe@2,
                    fun(Field@0) -> {start_error, Field@0} end
                )
            end,
            gleam@result:'try'(
                Actor_result,
                fun(Subject) -> {ok, {pool, Size, Subject}} end
            )
        end
    ).