carpenter

-module(carpenter@table).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([build/1, privacy/2, write_concurrency/2, read_concurrency/2, decentralized_counters/2, compression/2, set/1, ordered_set/1, insert/2, insert_new/2, lookup/2, delete/2, delete_all/1, delete_object/2, drop/1, give_away/3, contains/2, ref/1, take/2]).
-export_type([table_builder/2, privacy/0, write_concurrency/0, table/2, set/2]).

-type table_builder(FXZ, FYA) :: {table_builder,
        binary(),
        gleam@option:option(privacy()),
        gleam@option:option(write_concurrency()),
        gleam@option:option(boolean()),
        gleam@option:option(boolean()),
        boolean()} |
    {gleam_phantom, FXZ, FYA}.

-type privacy() :: private | protected | public.

-type write_concurrency() :: write_concurrency |
    no_write_concurrency |
    auto_write_concurrency.

-type table(FYB, FYC) :: {table, gleam@erlang@atom:atom_()} |
    {gleam_phantom, FYB, FYC}.

-type set(FYD, FYE) :: {set, table(FYD, FYE)}.

-spec build(binary()) -> table_builder(any(), any()).
build(Name) ->
    {table_builder, Name, none, none, none, none, false}.

-spec privacy(table_builder(FYJ, FYK), privacy()) -> table_builder(FYJ, FYK).
privacy(Builder, Privacy) ->
    erlang:setelement(3, Builder, {some, Privacy}).

-spec write_concurrency(table_builder(FYP, FYQ), write_concurrency()) -> table_builder(FYP, FYQ).
write_concurrency(Builder, Con) ->
    erlang:setelement(4, Builder, {some, Con}).

-spec read_concurrency(table_builder(FYV, FYW), boolean()) -> table_builder(FYV, FYW).
read_concurrency(Builder, Con) ->
    erlang:setelement(5, Builder, {some, Con}).

-spec decentralized_counters(table_builder(FZB, FZC), boolean()) -> table_builder(FZB, FZC).
decentralized_counters(Builder, Counters) ->
    erlang:setelement(6, Builder, {some, Counters}).

-spec compression(table_builder(FZH, FZI), boolean()) -> table_builder(FZH, FZI).
compression(Builder, Compressed) ->
    erlang:setelement(7, Builder, Compressed).

-spec privacy_prop(privacy()) -> gleam@dynamic:dynamic_().
privacy_prop(Prop) ->
    _pipe = case Prop of
        private ->
            <<"private"/utf8>>;

        protected ->
            <<"protected"/utf8>>;

        public ->
            <<"public"/utf8>>
    end,
    _pipe@1 = erlang:binary_to_atom(_pipe),
    gleam@dynamic:from(_pipe@1).

-spec write_concurrency_prop(write_concurrency()) -> gleam@dynamic:dynamic_().
write_concurrency_prop(Prop) ->
    _pipe = case Prop of
        write_concurrency ->
            <<"true"/utf8>>;

        no_write_concurrency ->
            <<"false"/utf8>>;

        auto_write_concurrency ->
            <<"auto"/utf8>>
    end,
    _pipe@1 = erlang:binary_to_atom(_pipe),
    _pipe@2 = (fun(X) ->
        {erlang:binary_to_atom(<<"write_concurrency"/utf8>>), X}
    end)(_pipe@1),
    gleam@dynamic:from(_pipe@2).

-spec build_table(table_builder(any(), any()), binary()) -> {ok,
        gleam@erlang@atom:atom_()} |
    {error, nil}.
build_table(Builder, Table_type) ->
    Name = erlang:binary_to_atom(erlang:element(2, Builder)),
    Props = begin
        _pipe = [erlang:binary_to_atom(Table_type),
            erlang:binary_to_atom(<<"named_table"/utf8>>)],
        gleam@list:map(_pipe, fun gleam@dynamic:from/1)
    end,
    Props@1 = case erlang:element(3, Builder) of
        {some, X} ->
            [privacy_prop(X) | Props];

        _ ->
            Props
    end,
    Props@2 = case erlang:element(4, Builder) of
        {some, X@1} ->
            [write_concurrency_prop(X@1) | Props@1];

        _ ->
            Props@1
    end,
    Props@3 = case erlang:element(5, Builder) of
        {some, X@2} ->
            [begin
                    _pipe@1 = {erlang:binary_to_atom(
                            <<"read_concurrency"/utf8>>
                        ),
                        X@2},
                    gleam@dynamic:from(_pipe@1)
                end |
                Props@2];

        _ ->
            Props@2
    end,
    Props@4 = case erlang:element(7, Builder) of
        true ->
            [begin
                    _pipe@2 = erlang:binary_to_atom(<<"compressed"/utf8>>),
                    gleam@dynamic:from(_pipe@2)
                end |
                Props@3];

        false ->
            Props@3
    end,
    carpenter:new_table(
        Name,
        begin
            _pipe@3 = Props@4,
            gleam@list:map(_pipe@3, fun gleam@dynamic:from/1)
        end
    ).

-spec set(table_builder(FZT, FZU)) -> {ok, set(FZT, FZU)} | {error, nil}.
set(Builder) ->
    case build_table(Builder, <<"set"/utf8>>) of
        {ok, T} ->
            {ok, {set, {table, T}}};

        {error, _} ->
            {error, nil}
    end.

-spec ordered_set(table_builder(GAB, GAC)) -> {ok, set(GAB, GAC)} | {error, nil}.
ordered_set(Builder) ->
    case build_table(Builder, <<"ordered_set"/utf8>>) of
        {ok, T} ->
            {ok, {set, {table, T}}};

        {error, _} ->
            {error, nil}
    end.

-spec insert(set(GAJ, GAK), list({GAJ, GAK})) -> nil.
insert(Set, Objects) ->
    ets:insert(erlang:element(2, erlang:element(2, Set)), Objects).

-spec insert_new(set(GAO, GAP), list({GAO, GAP})) -> boolean().
insert_new(Set, Objects) ->
    ets:insert_new(erlang:element(2, erlang:element(2, Set)), Objects).

-spec lookup(set(GAT, GAU), GAT) -> list({GAT, GAU}).
lookup(Set, Key) ->
    ets:lookup(erlang:element(2, erlang:element(2, Set)), Key).

-spec delete(set(GAY, any()), GAY) -> nil.
delete(Set, Key) ->
    ets:delete(erlang:element(2, erlang:element(2, Set)), Key).

-spec delete_all(set(any(), any())) -> nil.
delete_all(Set) ->
    ets:delete_all_objects(erlang:element(2, erlang:element(2, Set))).

-spec delete_object(set(GBG, GBH), {GBG, GBH}) -> nil.
delete_object(Set, Object) ->
    ets:delete_object(erlang:element(2, erlang:element(2, Set)), Object).

-spec drop(set(any(), any())) -> nil.
drop(Set) ->
    ets:delete(erlang:element(2, erlang:element(2, Set))).

-spec give_away(set(any(), any()), gleam@erlang@process:pid_(), any()) -> nil.
give_away(Set, Pid, Gift_data) ->
    ets:give_way(erlang:element(2, erlang:element(2, Set)), Pid, Gift_data).

-spec contains(set(GBU, any()), GBU) -> boolean().
contains(Set, Key) ->
    ets:member(erlang:element(2, erlang:element(2, Set)), Key).

-spec ref(binary()) -> {ok, set(any(), any())} | {error, nil}.
ref(Name) ->
    case gleam_erlang_ffi:atom_from_string(Name) of
        {ok, T} ->
            {ok, {set, {table, T}}};

        {error, _} ->
            {error, nil}
    end.

-spec take(set(GCE, GCF), GCE) -> list({GCE, GCF}).
take(Set, Key) ->
    ets:take(erlang:element(2, erlang:element(2, Set)), Key).