-module(shelf@internal).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/shelf/internal.gleam").
-export([build_entry_decoder/2, stream_validate_and_load/3, generic_reload/3, rescue/1, generic_with_table/3, open_no_load/3, cleanup/3, generic_open/4, close/3, insert/3, insert_list/3, member/2, to_list/1, fold/3, generic_fold/3, size/1, delete_key/2, delete_object/3, delete_all/1, save/2, sync_dets/2, dets_insert/2, generic_insert/5, dets_insert_list/2, generic_insert_list/4, dets_delete_key/2, generic_delete_key/4, dets_delete_object/3, generic_delete_object/5, dets_delete_all/1, generic_delete_all/3]).
-export_type([ets_ref/0, dets_ref/0, guardian_ref/0]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(false).

-type ets_ref() :: any().

-type dets_ref() :: any().

-type guardian_ref() :: any().

-file("src/shelf/internal.gleam", 26).
?DOC(false).
-spec build_entry_decoder(
    gleam@dynamic@decode:decoder(LNL),
    gleam@dynamic@decode:decoder(LNN)
) -> gleam@dynamic@decode:decoder({LNL, LNN}).
build_entry_decoder(Key_decoder, Value_decoder) ->
    gleam@dynamic@decode:field(
        0,
        Key_decoder,
        fun(Key) ->
            gleam@dynamic@decode:field(
                1,
                Value_decoder,
                fun(Value) -> gleam@dynamic@decode:success({Key, Value}) end
            )
        end
    ).

-file("src/shelf/internal.gleam", 41).
?DOC(false).
-spec stream_validate_and_load(
    ets_ref(),
    dets_ref(),
    gleam@dynamic@decode:decoder({any(), any()})
) -> {ok, nil} | {error, shelf:shelf_error()}.
stream_validate_and_load(Ets, Dets, Entry_decoder) ->
    Decoder_fn = fun(Entry) ->
        gleam@dynamic@decode:run(Entry, Entry_decoder)
    end,
    shelf_ffi:dets_fold_into_ets_strict(Dets, Ets, Decoder_fn).

-file("src/shelf/internal.gleam", 186).
?DOC(false).
-spec generic_reload(
    ets_ref(),
    dets_ref(),
    gleam@dynamic@decode:decoder({any(), any()})
) -> {ok, nil} | {error, shelf:shelf_error()}.
generic_reload(Ets, Dets, Entry_decoder) ->
    Decoder_fn = fun(Entry) ->
        gleam@dynamic@decode:run(Entry, Entry_decoder)
    end,
    shelf_ffi:reload_atomic(Ets, Dets, Decoder_fn).

-file("src/shelf/internal.gleam", 231).
?DOC(false).
-spec rescue(fun(() -> LPX)) -> {ok, LPX} | {error, binary()}.
rescue(Fun) ->
    shelf_rescue_ffi:rescue(Fun).

-file("src/shelf/internal.gleam", 210).
?DOC(false).
-spec generic_with_table(
    fun(() -> {ok, LPN} | {error, shelf:shelf_error()}),
    fun((LPN) -> {ok, nil} | {error, shelf:shelf_error()}),
    fun((LPN) -> {ok, LPS} | {error, shelf:shelf_error()})
) -> {ok, LPS} | {error, shelf:shelf_error()}.
generic_with_table(Open_fn, Close_fn, Fun) ->
    gleam@result:'try'(
        Open_fn(),
        fun(Table) ->
            Callback_result = case shelf_rescue_ffi:rescue(
                fun() -> Fun(Table) end
            ) of
                {ok, Result} ->
                    Result;

                {error, Crash_detail} ->
                    {error, {erlang_error, Crash_detail}}
            end,
            case Close_fn(Table) of
                {ok, nil} ->
                    Callback_result;

                {error, Close_err} ->
                    case Callback_result of
                        {ok, _} ->
                            {error, Close_err};

                        {error, _} ->
                            Callback_result
                    end
            end
        end
    ).

-file("src/shelf/internal.gleam", 250).
?DOC(false).
-spec open_no_load(binary(), binary(), binary()) -> {ok,
        {ets_ref(), dets_ref(), guardian_ref()}} |
    {error, shelf:shelf_error()}.
open_no_load(Name, Path, Table_type) ->
    shelf_ffi:open_no_load(Name, Path, Table_type).

-file("src/shelf/internal.gleam", 258).
?DOC(false).
-spec cleanup(ets_ref(), dets_ref(), guardian_ref()) -> {ok, nil} |
    {error, shelf:shelf_error()}.
cleanup(Ets, Dets, Guardian) ->
    shelf_ffi:cleanup(Ets, Dets, Guardian).

-file("src/shelf/internal.gleam", 67).
?DOC(false).
-spec generic_open(
    shelf:config(),
    binary(),
    gleam@dynamic@decode:decoder(LOC),
    gleam@dynamic@decode:decoder(LOE)
) -> {ok,
        {ets_ref(),
            dets_ref(),
            guardian_ref(),
            shelf:write_mode(),
            gleam@dynamic@decode:decoder({LOC, LOE})}} |
    {error, shelf:shelf_error()}.
generic_open(Config, Table_type, Key_decoder, Value_decoder) ->
    Name = shelf:get_name(Config),
    Path = shelf:get_path(Config),
    Base_directory = shelf:get_base_directory(Config),
    Write_mode = shelf:get_write_mode(Config),
    gleam@result:'try'(
        shelf:validate_path(Path, Base_directory),
        fun(Resolved_path) ->
            gleam@result:'try'(
                shelf_ffi:open_no_load(Name, Resolved_path, Table_type),
                fun(Refs) ->
                    Ets = erlang:element(1, Refs),
                    Dets = erlang:element(2, Refs),
                    Guardian = erlang:element(3, Refs),
                    Entry_decoder = build_entry_decoder(
                        Key_decoder,
                        Value_decoder
                    ),
                    case stream_validate_and_load(Ets, Dets, Entry_decoder) of
                        {ok, nil} ->
                            {ok,
                                {Ets, Dets, Guardian, Write_mode, Entry_decoder}};

                        {error, E} ->
                            _ = shelf_ffi:cleanup(Ets, Dets, Guardian),
                            {error, E}
                    end
                end
            )
        end
    ).

-file("src/shelf/internal.gleam", 266).
?DOC(false).
-spec close(ets_ref(), dets_ref(), guardian_ref()) -> {ok, nil} |
    {error, shelf:shelf_error()}.
close(Ets, Dets, Guardian) ->
    shelf_ffi:close(Ets, Dets, Guardian).

-file("src/shelf/internal.gleam", 274).
?DOC(false).
-spec insert(ets_ref(), dets_ref(), {any(), any()}) -> {ok, nil} |
    {error, shelf:shelf_error()}.
insert(Ets, Dets, Object) ->
    shelf_ffi:insert(Ets, Dets, Object).

-file("src/shelf/internal.gleam", 282).
?DOC(false).
-spec insert_list(ets_ref(), dets_ref(), list({any(), any()})) -> {ok, nil} |
    {error, shelf:shelf_error()}.
insert_list(Ets, Dets, Objects) ->
    shelf_ffi:insert_list(Ets, Dets, Objects).

-file("src/shelf/internal.gleam", 290).
?DOC(false).
-spec member(ets_ref(), any()) -> {ok, boolean()} | {error, shelf:shelf_error()}.
member(Ets, Key) ->
    shelf_ffi:member(Ets, Key).

-file("src/shelf/internal.gleam", 294).
?DOC(false).
-spec to_list(ets_ref()) -> {ok, list({any(), any()})} |
    {error, shelf:shelf_error()}.
to_list(Ets) ->
    shelf_ffi:to_list(Ets).

-file("src/shelf/internal.gleam", 298).
?DOC(false).
-spec fold(ets_ref(), fun(({any(), any()}, LRE) -> LRE), LRE) -> {ok, LRE} |
    {error, shelf:shelf_error()}.
fold(Ets, Fun, Acc) ->
    shelf_ffi:fold(Ets, Fun, Acc).

-file("src/shelf/internal.gleam", 235).
?DOC(false).
-spec generic_fold(ets_ref(), LQA, fun((LQA, any(), any()) -> LQA)) -> {ok, LQA} |
    {error, shelf:shelf_error()}.
generic_fold(Ets, Initial, Fun) ->
    Wrapper = fun(Entry, Acc) ->
        Fun(Acc, erlang:element(1, Entry), erlang:element(2, Entry))
    end,
    shelf_ffi:fold(Ets, Wrapper, Initial).

-file("src/shelf/internal.gleam", 306).
?DOC(false).
-spec size(ets_ref()) -> {ok, integer()} | {error, shelf:shelf_error()}.
size(Ets) ->
    shelf_ffi:size(Ets).

-file("src/shelf/internal.gleam", 310).
?DOC(false).
-spec delete_key(ets_ref(), any()) -> {ok, nil} | {error, shelf:shelf_error()}.
delete_key(Ets, Key) ->
    shelf_ffi:delete_key(Ets, Key).

-file("src/shelf/internal.gleam", 314).
?DOC(false).
-spec delete_object(ets_ref(), any(), any()) -> {ok, nil} |
    {error, shelf:shelf_error()}.
delete_object(Ets, Key, Value) ->
    shelf_ffi:delete_object(Ets, Key, Value).

-file("src/shelf/internal.gleam", 318).
?DOC(false).
-spec delete_all(ets_ref()) -> {ok, nil} | {error, shelf:shelf_error()}.
delete_all(Ets) ->
    shelf_ffi:delete_all(Ets).

-file("src/shelf/internal.gleam", 322).
?DOC(false).
-spec save(ets_ref(), dets_ref()) -> {ok, nil} | {error, shelf:shelf_error()}.
save(Ets, Dets) ->
    shelf_ffi:save(Ets, Dets).

-file("src/shelf/internal.gleam", 326).
?DOC(false).
-spec sync_dets(ets_ref(), dets_ref()) -> {ok, nil} |
    {error, shelf:shelf_error()}.
sync_dets(Ets, Dets) ->
    shelf_ffi:sync_dets(Ets, Dets).

-file("src/shelf/internal.gleam", 332).
?DOC(false).
-spec dets_insert(dets_ref(), {any(), any()}) -> {ok, nil} |
    {error, shelf:shelf_error()}.
dets_insert(Dets, Object) ->
    shelf_ffi:dets_insert(Dets, Object).

-file("src/shelf/internal.gleam", 99).
?DOC(false).
-spec generic_insert(ets_ref(), dets_ref(), shelf:write_mode(), any(), any()) -> {ok,
        nil} |
    {error, shelf:shelf_error()}.
generic_insert(Ets, Dets, Write_mode, Key, Value) ->
    case Write_mode of
        write_through ->
            gleam@result:'try'(
                shelf_ffi:dets_insert(Dets, {Key, Value}),
                fun(_) -> shelf_ffi:insert(Ets, Dets, {Key, Value}) end
            );

        write_back ->
            shelf_ffi:insert(Ets, Dets, {Key, Value})
    end.

-file("src/shelf/internal.gleam", 336).
?DOC(false).
-spec dets_insert_list(dets_ref(), list({any(), any()})) -> {ok, nil} |
    {error, shelf:shelf_error()}.
dets_insert_list(Dets, Objects) ->
    shelf_ffi:dets_insert_list(Dets, Objects).

-file("src/shelf/internal.gleam", 117).
?DOC(false).
-spec generic_insert_list(
    ets_ref(),
    dets_ref(),
    shelf:write_mode(),
    list({any(), any()})
) -> {ok, nil} | {error, shelf:shelf_error()}.
generic_insert_list(Ets, Dets, Write_mode, Entries) ->
    case Write_mode of
        write_through ->
            gleam@result:'try'(
                shelf_ffi:dets_insert_list(Dets, Entries),
                fun(_) -> shelf_ffi:insert_list(Ets, Dets, Entries) end
            );

        write_back ->
            shelf_ffi:insert_list(Ets, Dets, Entries)
    end.

-file("src/shelf/internal.gleam", 343).
?DOC(false).
-spec dets_delete_key(dets_ref(), any()) -> {ok, nil} |
    {error, shelf:shelf_error()}.
dets_delete_key(Dets, Key) ->
    shelf_ffi:dets_delete_key(Dets, Key).

-file("src/shelf/internal.gleam", 134).
?DOC(false).
-spec generic_delete_key(ets_ref(), dets_ref(), shelf:write_mode(), any()) -> {ok,
        nil} |
    {error, shelf:shelf_error()}.
generic_delete_key(Ets, Dets, Write_mode, Key) ->
    case Write_mode of
        write_through ->
            gleam@result:'try'(
                shelf_ffi:dets_delete_key(Dets, Key),
                fun(_) -> shelf_ffi:delete_key(Ets, Key) end
            );

        write_back ->
            shelf_ffi:delete_key(Ets, Key)
    end.

-file("src/shelf/internal.gleam", 347).
?DOC(false).
-spec dets_delete_object(dets_ref(), any(), any()) -> {ok, nil} |
    {error, shelf:shelf_error()}.
dets_delete_object(Dets, Key, Value) ->
    shelf_ffi:dets_delete_object(Dets, Key, Value).

-file("src/shelf/internal.gleam", 151).
?DOC(false).
-spec generic_delete_object(
    ets_ref(),
    dets_ref(),
    shelf:write_mode(),
    any(),
    any()
) -> {ok, nil} | {error, shelf:shelf_error()}.
generic_delete_object(Ets, Dets, Write_mode, Key, Value) ->
    case Write_mode of
        write_through ->
            gleam@result:'try'(
                shelf_ffi:dets_delete_object(Dets, Key, Value),
                fun(_) -> shelf_ffi:delete_object(Ets, Key, Value) end
            );

        write_back ->
            shelf_ffi:delete_object(Ets, Key, Value)
    end.

-file("src/shelf/internal.gleam", 355).
?DOC(false).
-spec dets_delete_all(dets_ref()) -> {ok, nil} | {error, shelf:shelf_error()}.
dets_delete_all(Dets) ->
    shelf_ffi:dets_delete_all(Dets).

-file("src/shelf/internal.gleam", 169).
?DOC(false).
-spec generic_delete_all(ets_ref(), dets_ref(), shelf:write_mode()) -> {ok, nil} |
    {error, shelf:shelf_error()}.
generic_delete_all(Ets, Dets, Write_mode) ->
    case Write_mode of
        write_through ->
            gleam@result:'try'(
                shelf_ffi:dets_delete_all(Dets),
                fun(_) -> shelf_ffi:delete_all(Ets) end
            );

        write_back ->
            shelf_ffi:delete_all(Ets)
    end.