bravo

-module(bravo@oset).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([new/3, insert/2, lookup/2, delete/1, delete_key/2, delete_all_objects/1, delete_object/2, tab2file/5, tab2list/1, file2tab/3, insert_new/2, take/2, member/2, first/1, last/1, next/2, prev/2]).
-export_type([o_set/1]).

-opaque o_set(HFX) :: {o_set, gleam@erlang@atom:atom_(), integer()} |
    {gleam_phantom, HFX}.

-spec new(binary(), integer(), bravo:access()) -> {ok, o_set(any())} |
    {error, bravo:bravo_error()}.
new(Name, Keypos, Access) ->
    Atom = erlang:binary_to_atom(Name),
    gleam@bool:guard(
        Keypos < 1,
        {error, non_positive_keypos},
        fun() ->
            gleam@result:'try'(
                bravo_ffi:try_new(Atom, [ordered_set, case Access of
                            public ->
                                public;

                            protected ->
                                protected;

                            private ->
                                private
                        end, named_table, {keypos, Keypos}, {write_concurrency,
                            auto}, {read_concurrency, true}, {decentralized_counters,
                            true}]),
                fun(A) -> {ok, {o_set, A, Keypos}} end
            )
        end
    ).

-spec insert(o_set(HGC), list(HGC)) -> boolean().
insert(Oset, Objects) ->
    gleam@bool:guard(
        gleam@list:is_empty(Objects),
        false,
        fun() ->
            bravo_ffi:try_insert(
                erlang:element(2, Oset),
                erlang:element(3, Oset),
                Objects
            )
        end
    ).

-spec lookup(o_set(HGF), any()) -> gleam@option:option(HGF).
lookup(Oset, Key) ->
    case bravo_ffi:try_lookup(erlang:element(2, Oset), Key) of
        [Res] ->
            {some, Res};

        _ ->
            none
    end.

-spec delete(o_set(any())) -> boolean().
delete(Oset) ->
    bravo_ffi:try_delete(erlang:element(2, Oset)).

-spec delete_key(o_set(any()), any()) -> nil.
delete_key(Oset, Key) ->
    bravo_ffi:try_delete_key(erlang:element(2, Oset), Key),
    nil.

-spec delete_all_objects(o_set(any())) -> nil.
delete_all_objects(Oset) ->
    bravo_ffi:try_delete_all_objects(erlang:element(2, Oset)),
    nil.

-spec delete_object(o_set(HGQ), HGQ) -> nil.
delete_object(Oset, Object) ->
    bravo_ffi:try_delete_object(erlang:element(2, Oset), Object),
    nil.

-spec tab2file(o_set(any()), binary(), boolean(), boolean(), boolean()) -> {ok,
        nil} |
    {error, bravo:bravo_error()}.
tab2file(Oset, Filename, Object_count, Md5sum, Sync) ->
    bravo_ffi:try_tab2file(
        erlang:element(2, Oset),
        gleam@string:to_utf_codepoints(Filename),
        Object_count,
        Md5sum,
        Sync
    ).

-spec tab2list(o_set(HHD)) -> list(HHD).
tab2list(Oset) ->
    bravo_ffi:try_tab2list(erlang:element(2, Oset)).

-spec file2tab(
    binary(),
    boolean(),
    fun((gleam@dynamic:dynamic_()) -> {ok, HGW} | {error, any()})
) -> {ok, o_set(HGW)} | {error, bravo:bravo_error()}.
file2tab(Filename, Verify, Decoder) ->
    gleam@result:'try'(
        bravo_ffi:try_file2tab(gleam@string:to_utf_codepoints(Filename), Verify),
        fun(Name) ->
            _assert_subject = gleam@dynamic:int(
                bravo_ffi:inform(Name, erlang:binary_to_atom(<<"keypos"/utf8>>))
            ),
            {ok, Keypos} = 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 => <<"bravo/oset"/utf8>>,
                                function => <<"file2tab"/utf8>>,
                                line => 158})
            end,
            Table = {o_set, Name, Keypos},
            gleam@list:map(
                tab2list(Table),
                fun(Obj) ->
                    delete_object(Table, Obj),
                    case erlang:tuple_size(Obj) of
                        1 ->
                            insert(Table, [erlang:element(1, Obj)]);

                        _ ->
                            insert(Table, [Obj])
                    end
                end
            ),
            gleam@bool:guard(
                (gleam@list:all(tab2list(Table), fun(Obj@1) -> _pipe = Obj@1,
                        _pipe@1 = gleam@dynamic:from(_pipe),
                        _pipe@2 = Decoder(_pipe@1),
                        gleam@result:is_ok(_pipe@2) end)),
                {ok, Table},
                fun() ->
                    delete(Table),
                    {error, decode_failure}
                end
            )
        end
    ).

-spec insert_new(o_set(HHG), list(HHG)) -> boolean().
insert_new(Oset, Objects) ->
    gleam@bool:guard(
        gleam@list:is_empty(Objects),
        false,
        fun() ->
            bravo_ffi:try_insert_new(
                erlang:element(2, Oset),
                erlang:element(3, Oset),
                Objects
            )
        end
    ).

-spec take(o_set(HHJ), any()) -> gleam@option:option(HHJ).
take(Oset, Key) ->
    case bravo_ffi:try_take(erlang:element(2, Oset), Key) of
        [Res] ->
            {some, Res};

        _ ->
            none
    end.

-spec member(o_set(any()), any()) -> boolean().
member(Oset, Key) ->
    bravo_ffi:try_member(erlang:element(2, Oset), Key).

-spec first(o_set(any())) -> gleam@option:option(any()).
first(Oset) ->
    bravo_ffi:try_first(erlang:element(2, Oset)).

-spec last(o_set(any())) -> gleam@option:option(any()).
last(Oset) ->
    bravo_ffi:try_last(erlang:element(2, Oset)).

-spec next(o_set(any()), HIA) -> gleam@option:option(HIA).
next(Oset, Key) ->
    bravo_ffi:try_next(erlang:element(2, Oset), Key).

-spec prev(o_set(any()), HIE) -> gleam@option:option(HIE).
prev(Oset, Key) ->
    bravo_ffi:try_prev(erlang:element(2, Oset), Key).