battlesnake

-module(battlesnake@internal@cache).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([insert/3, get/2, remove/2, new/0]).
-export_type([cache_message/1]).

-type cache_message(TVB) :: {insert, binary(), TVB} |
    {get, binary(), gleam@erlang@process:subject({ok, TVB} | {error, nil})} |
    {remove, binary()}.

-spec insert(gleam@erlang@process:subject(cache_message(TVD)), binary(), TVD) -> nil.
insert(Cache, Game_id, Actor) ->
    gleam@otp@actor:send(Cache, {insert, Game_id, Actor}).

-spec get(gleam@erlang@process:subject(cache_message(TVG)), binary()) -> {ok,
        TVG} |
    {error, nil}.
get(Cache, Game_id) ->
    _pipe = gleam@erlang@process:try_call(
        Cache,
        fun(_capture) -> {get, Game_id, _capture} end,
        10
    ),
    _pipe@1 = gleam@result:nil_error(_pipe),
    gleam@result:flatten(_pipe@1).

-spec remove(gleam@erlang@process:subject(cache_message(any())), binary()) -> nil.
remove(Cache, Game_id) ->
    gleam@otp@actor:send(Cache, {remove, Game_id}).

-spec handle_message(cache_message(TVO), gleam@dict:dict(binary(), TVO)) -> gleam@otp@actor:next(cache_message(TVO), gleam@dict:dict(binary(), TVO)).
handle_message(Message, Games) ->
    case Message of
        {insert, Game_id, Actor} ->
            Games@1 = gleam@dict:insert(Games, Game_id, Actor),
            gleam@otp@actor:continue(Games@1);

        {get, Game_id@1, Client} ->
            case gleam@dict:get(Games, Game_id@1) of
                {error, _} ->
                    gleam@erlang@process:send(Client, {error, nil}),
                    gleam@otp@actor:continue(Games);

                {ok, Actor@1} ->
                    gleam@erlang@process:send(Client, {ok, Actor@1}),
                    gleam@otp@actor:continue(Games)
            end;

        {remove, Game_id@2} ->
            Games@2 = gleam@dict:delete(Games, Game_id@2),
            gleam@otp@actor:continue(Games@2)
    end.

-spec new() -> gleam@erlang@process:subject(cache_message(any())).
new() ->
    _assert_subject = gleam@otp@actor:start(
        gleam@dict:new(),
        fun handle_message/2
    ),
    {ok, Actor} = case _assert_subject of
        {ok, _} -> _assert_subject;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"battlesnake/internal/cache"/utf8>>,
                        function => <<"new"/utf8>>,
                        line => 7})
    end,
    Actor.