-module(common_sql_sqlite).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/common_sql_sqlite.gleam").
-export([convert_portable/2, driver/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.

-file("src/common_sql_sqlite.gleam", 10).
-spec param_to_value(common_sql:param()) -> sqlight:value().
param_to_value(Param) ->
    case Param of
        {p_int, N} ->
            sqlight:int(N);

        {p_string, S} ->
            sqlight:text(S);

        {p_float, F} ->
            sqlight:float(F);

        {p_bool, B} ->
            sqlight:bool(B);

        p_null ->
            sqlight_ffi:null()
    end.

-file("src/common_sql_sqlite.gleam", 20).
-spec sqlight_error_to_connect_error(sqlight:error()) -> common_sql:db_error().
sqlight_error_to_connect_error(Err) ->
    {sqlight_error, _, Message, _} = Err,
    {connection_error, Message}.

-file("src/common_sql_sqlite.gleam", 25).
-spec sqlight_error_to_query_error(sqlight:error()) -> common_sql:db_error().
sqlight_error_to_query_error(Err) ->
    {sqlight_error, _, Message, _} = Err,
    {query_error, Message}.

-file("src/common_sql_sqlite.gleam", 40).
?DOC(false).
-spec convert_portable(binary(), list(sqlight:value())) -> {binary(),
    list(sqlight:value())}.
convert_portable(Sql, Values) ->
    Re@1 = case gleam@regexp:from_string(<<"\\$([0-9]+)"/utf8>>) of
        {ok, Re} -> Re;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"common_sql_sqlite"/utf8>>,
                        function => <<"convert_portable"/utf8>>,
                        line => 44,
                        value => _assert_fail,
                        start => 1379,
                        'end' => 1432,
                        pattern_start => 1390,
                        pattern_end => 1396})
    end,
    Reordered = begin
        _pipe@1 = gleam@list:map(
            gleam@regexp:scan(Re@1, Sql),
            fun(M) -> case erlang:element(3, M) of
                    [{some, N_str} | _] ->
                        case gleam_stdlib:parse_int(N_str) of
                            {ok, N} ->
                                _pipe = gleam@list:drop(Values, N - 1),
                                gleam@list:first(_pipe);

                            {error, nil} ->
                                {error, nil}
                        end;

                    _ ->
                        {error, nil}
                end end
        ),
        gleam@result:values(_pipe@1)
    end,
    {gleam_regexp_ffi:replace(Re@1, Sql, <<"?"/utf8>>), Reordered}.

-file("src/common_sql_sqlite.gleam", 61).
?DOC(" Returns a `common_sql.Driver` backed by SQLite via the `sqlight` library.\n").
-spec driver() -> common_sql:driver(sqlight:connection()).
driver() ->
    {driver, <<"sqlite"/utf8>>, fun(Url) -> _pipe = sqlight:open(Url),
            gleam@result:map_error(_pipe, fun sqlight_error_to_connect_error/1) end, fun(
            Conn,
            Query,
            Params
        ) ->
            Values = gleam@list:map(Params, fun param_to_value/1),
            {Sql, Ordered_values} = case Query of
                {sql, S} ->
                    {S, Values};

                {portable, S@1} ->
                    convert_portable(S@1, Values)
            end,
            _pipe@1 = sqlight:'query'(
                Sql,
                Conn,
                Ordered_values,
                {decoder, fun gleam@dynamic@decode:decode_dynamic/1}
            ),
            gleam@result:map_error(_pipe@1, fun sqlight_error_to_query_error/1)
        end, fun(Conn@1) ->
            _ = sqlight:close(Conn@1),
            nil
        end}.