-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/3, lookup/2, delete/2, delete_all/1, drop/1, give_away/3]).
-export_type([table_builder/2, privacy/0, write_concurrency/0, table/2, set/2]).

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

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

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

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

-type set(FXB, FXC) :: {set, table(FXB, FXC)}.

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

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

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

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

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

-spec compression(table_builder(FYF, FYG), boolean()) -> table_builder(FYF, FYG).
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()) -> gleam@erlang@atom:atom_().
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,
    ets:new(
        Name,
        begin
            _pipe@3 = Props@4,
            gleam@list:map(_pipe@3, fun gleam@dynamic:from/1)
        end
    ),
    Name.

-spec set(table_builder(FYP, FYQ)) -> set(FYP, FYQ).
set(Builder) ->
    Table = build_table(Builder, <<"set"/utf8>>),
    {set, {table, Table}}.

-spec ordered_set(table_builder(FYV, FYW)) -> set(FYV, FYW).
ordered_set(Builder) ->
    Table = build_table(Builder, <<"ordered_set"/utf8>>),
    {set, {table, Table}}.

-spec insert(set(FZB, FZC), FZB, FZC) -> set(FZB, FZC).
insert(Set, Key, Value) ->
    ets:insert(erlang:element(2, erlang:element(2, Set)), {Key, Value}),
    Set.

-spec lookup(set(FZH, FZI), FZH) -> gleam@option:option(list({FZH, FZI})).
lookup(Set, Key) ->
    case ets:lookup(erlang:element(2, erlang:element(2, Set)), Key) of
        [] ->
            none;

        Kv ->
            {some, Kv}
    end.

-spec delete(set(FZN, FZO), FZN) -> set(FZN, FZO).
delete(Set, Key) ->
    ets:delete(erlang:element(2, erlang:element(2, Set)), Key),
    Set.

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

-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).