-module(pgl@internal@encode).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/pgl/internal/encode.gleam").
-export([auth_scram_client_first/1, scram_response/1, startup/1, needs_sync/1, cached/4, uncached/2, with_sync/1, ssl_request/0, 'query'/1, password/1, parse/3, describe/2, flush/0, sync/0, execute/2, to_bit_array/1]).
-export_type([final/0, 'query'/2, describe/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).

-opaque final() :: flush | sync.

-type 'query'(KDN, KDO) :: {'query',
        binary(),
        list(KDN),
        list(KDO),
        gleam@option:option(fun((KDN, KDO) -> {ok, bitstring()} |
            {error, binary()})),
        describe(),
        boolean(),
        gleam@option:option(final())}.

-type describe() :: portal | statement.

-file("src/pgl/internal/encode.gleam", 10).
?DOC(false).
-spec auth_scram_client_first(bitstring()) -> bitstring().
auth_scram_client_first(Client_first) ->
    Size = erlang:byte_size(Client_first),
    Initial_response = begin
        _pipe = gleam_stdlib:wrap_list(<<"SCRAM-SHA-256"/utf8>>),
        _pipe@1 = gleam@bytes_tree:append(_pipe, <<0>>),
        _pipe@2 = gleam@bytes_tree:append(_pipe@1, <<Size:32/integer>>),
        gleam@bytes_tree:append(_pipe@2, Client_first)
    end,
    Sasl_size = erlang:iolist_size(Initial_response) + 4,
    _pipe@3 = gleam_stdlib:wrap_list(<<"p"/utf8>>),
    _pipe@4 = gleam@bytes_tree:append(_pipe@3, <<Sasl_size:32/integer>>),
    _pipe@5 = gleam_stdlib:iodata_append(_pipe@4, Initial_response),
    erlang:list_to_bitstring(_pipe@5).

-file("src/pgl/internal/encode.gleam", 27).
?DOC(false).
-spec scram_response(bitstring()) -> bitstring().
scram_response(Client_final) ->
    Size = erlang:byte_size(Client_final) + 4,
    _pipe = gleam_stdlib:wrap_list(<<"p"/utf8>>),
    _pipe@1 = gleam@bytes_tree:append(_pipe, <<Size:32/integer>>),
    _pipe@2 = gleam@bytes_tree:append(_pipe@1, Client_final),
    erlang:list_to_bitstring(_pipe@2).

-file("src/pgl/internal/encode.gleam", 36).
?DOC(false).
-spec startup(list({binary(), binary()})) -> bitstring().
startup(Params) ->
    Encoded_params = begin
        _pipe@4 = gleam@list:fold(
            Params,
            gleam@bytes_tree:new(),
            fun(Acc, Key_val) -> _pipe = Acc,
                _pipe@1 = gleam@bytes_tree:append_string(
                    _pipe,
                    erlang:element(1, Key_val)
                ),
                _pipe@2 = gleam@bytes_tree:append(_pipe@1, <<0>>),
                _pipe@3 = gleam@bytes_tree:append_string(
                    _pipe@2,
                    erlang:element(2, Key_val)
                ),
                gleam@bytes_tree:append(_pipe@3, <<0>>) end
        ),
        erlang:list_to_bitstring(_pipe@4)
    end,
    Packet = gleam_stdlib:bit_array_concat(
        [<<3:16/integer>>, <<0:16/integer>>, Encoded_params, <<0>>]
    ),
    Size = erlang:byte_size(Packet) + 4,
    <<Size:32/integer, Packet/bitstring>>.

-file("src/pgl/internal/encode.gleam", 60).
?DOC(false).
-spec bind(
    bitstring(),
    bitstring(),
    list(KDQ),
    list(KDS),
    fun((KDQ, KDS) -> {ok, bitstring()} | {error, binary()})
) -> {ok, bitstring()} | {error, binary()}.
bind(Portal_name, Statement_name, Params, Type_infos, Encoder) ->
    Param_count = erlang:length(Params),
    Param_count_bin = <<Param_count:16/integer>>,
    _pipe = gleam@list:strict_zip(Params, Type_infos),
    _pipe@1 = gleam@result:replace_error(
        _pipe,
        <<"Parameter list and cached types list are different lengths"/utf8>>
    ),
    _pipe@2 = gleam@result:'try'(
        _pipe@1,
        fun(Zipped) ->
            gleam@list:try_map(
                Zipped,
                fun(Zip) ->
                    {Param, Type_info} = Zip,
                    Encoder(Param, Type_info)
                end
            )
        end
    ),
    gleam@result:map(
        _pipe@2,
        fun(Param_values) ->
            Param_formats_bin = begin
                _pipe@3 = gleam@list:map(
                    Param_values,
                    fun(_) -> <<1:16/integer>> end
                ),
                _pipe@4 = gleam@list:prepend(_pipe@3, Param_count_bin),
                gleam_stdlib:bit_array_concat(_pipe@4)
            end,
            Results = <<1:16/integer, 1:16/integer>>,
            Packet = begin
                _pipe@5 = gleam@bytes_tree:from_bit_array(Portal_name),
                _pipe@6 = gleam@bytes_tree:append(_pipe@5, <<0>>),
                _pipe@7 = gleam@bytes_tree:append(_pipe@6, Statement_name),
                _pipe@8 = gleam@bytes_tree:append(_pipe@7, <<0>>),
                _pipe@9 = gleam@bytes_tree:append(_pipe@8, Param_formats_bin),
                _pipe@10 = gleam@bytes_tree:append(_pipe@9, Param_count_bin),
                _pipe@11 = gleam@bytes_tree:append(
                    _pipe@10,
                    gleam_stdlib:bit_array_concat(Param_values)
                ),
                _pipe@12 = gleam@bytes_tree:append(_pipe@11, Results),
                erlang:list_to_bitstring(_pipe@12)
            end,
            Packet_len = erlang:byte_size(Packet) + 4,
            _pipe@13 = gleam_stdlib:wrap_list(<<"B"/utf8>>),
            _pipe@14 = gleam@bytes_tree:append(
                _pipe@13,
                <<Packet_len:32/integer>>
            ),
            _pipe@15 = gleam@bytes_tree:append(_pipe@14, Packet),
            erlang:list_to_bitstring(_pipe@15)
        end
    ).

-file("src/pgl/internal/encode.gleam", 126).
?DOC(false).
-spec needs_sync('query'(any(), any())) -> boolean().
needs_sync(Msg) ->
    case erlang:element(8, Msg) of
        {some, sync} ->
            false;

        _ ->
            true
    end.

-file("src/pgl/internal/encode.gleam", 133).
?DOC(false).
-spec cached(
    binary(),
    list(KEC),
    list(KEE),
    fun((KEC, KEE) -> {ok, bitstring()} | {error, binary()})
) -> 'query'(KEC, KEE).
cached(Sql, Params, Type_infos, Encoder) ->
    {'query', Sql, Params, Type_infos, {some, Encoder}, portal, true, none}.

-file("src/pgl/internal/encode.gleam", 150).
?DOC(false).
-spec uncached(binary(), list(KEK)) -> 'query'(KEK, any()).
uncached(Sql, Params) ->
    {'query', Sql, Params, [], none, statement, false, {some, flush}}.

-file("src/pgl/internal/encode.gleam", 162).
?DOC(false).
-spec with_sync('query'(KEP, KEQ)) -> 'query'(KEP, KEQ).
with_sync(Msg) ->
    {'query',
        erlang:element(2, Msg),
        erlang:element(3, Msg),
        erlang:element(4, Msg),
        erlang:element(5, Msg),
        erlang:element(6, Msg),
        erlang:element(7, Msg),
        {some, sync}}.

-file("src/pgl/internal/encode.gleam", 199).
?DOC(false).
-spec ssl_request() -> bitstring().
ssl_request() ->
    <<8:32/integer, 1234:16/integer, 5679:16/integer>>.

-file("src/pgl/internal/encode.gleam", 211).
?DOC(false).
-spec encode_string(binary(), binary()) -> bitstring().
encode_string(Identifier, Message) ->
    Msg_bin = gleam_stdlib:identity(Message),
    Msg_len = erlang:byte_size(Msg_bin) + 5,
    _pipe = gleam_stdlib:wrap_list(Identifier),
    _pipe@1 = gleam@bytes_tree:append(_pipe, <<Msg_len:32/integer>>),
    _pipe@2 = gleam@bytes_tree:append(_pipe@1, Msg_bin),
    _pipe@3 = gleam@bytes_tree:append(_pipe@2, <<0>>),
    erlang:list_to_bitstring(_pipe@3).

-file("src/pgl/internal/encode.gleam", 203).
?DOC(false).
-spec 'query'(binary()) -> bitstring().
'query'(Query) ->
    encode_string(<<"Q"/utf8>>, Query).

-file("src/pgl/internal/encode.gleam", 207).
?DOC(false).
-spec password(binary()) -> bitstring().
password(Password) ->
    encode_string(<<"p"/utf8>>, Password).

-file("src/pgl/internal/encode.gleam", 222).
?DOC(false).
-spec parse(binary(), binary(), list(integer())) -> bitstring().
parse(Name, Query, Data_types) ->
    Dt_bin = gleam@list:map(Data_types, fun(Dt) -> <<Dt:32/integer>> end),
    Dt_count = erlang:length(Data_types),
    Start = begin
        _pipe = gleam_stdlib:wrap_list(Name),
        _pipe@1 = gleam@bytes_tree:append(_pipe, <<0>>),
        _pipe@2 = gleam@bytes_tree:append_string(_pipe@1, Query),
        _pipe@3 = gleam@bytes_tree:append(_pipe@2, <<0>>),
        _pipe@4 = gleam@bytes_tree:append(_pipe@3, <<Dt_count:16/integer>>),
        erlang:list_to_bitstring(_pipe@4)
    end,
    Packet = gleam_stdlib:bit_array_concat([Start | Dt_bin]),
    Packet_len = erlang:byte_size(Packet) + 4,
    _pipe@5 = gleam_stdlib:wrap_list(<<"P"/utf8>>),
    _pipe@6 = gleam@bytes_tree:append(_pipe@5, <<Packet_len:32/integer>>),
    _pipe@7 = gleam@bytes_tree:append(_pipe@6, Packet),
    erlang:list_to_bitstring(_pipe@7).

-file("src/pgl/internal/encode.gleam", 250).
?DOC(false).
-spec describe(describe(), binary()) -> bitstring().
describe(Pos, Name) ->
    Name_bits = gleam_stdlib:identity(Name),
    Msg_len = erlang:byte_size(Name_bits) + 6,
    What_byte = case Pos of
        portal ->
            <<"P"/utf8>>;

        statement ->
            <<"S"/utf8>>
    end,
    _pipe = gleam_stdlib:wrap_list(<<"D"/utf8>>),
    _pipe@1 = gleam@bytes_tree:append(_pipe, <<Msg_len:32/integer>>),
    _pipe@2 = gleam@bytes_tree:append_string(_pipe@1, What_byte),
    _pipe@3 = gleam@bytes_tree:append(_pipe@2, Name_bits),
    _pipe@4 = gleam@bytes_tree:append(_pipe@3, <<0>>),
    erlang:list_to_bitstring(_pipe@4).

-file("src/pgl/internal/encode.gleam", 266).
?DOC(false).
-spec flush() -> bitstring().
flush() ->
    <<"H"/utf8, 4:32/integer>>.

-file("src/pgl/internal/encode.gleam", 270).
?DOC(false).
-spec sync() -> bitstring().
sync() ->
    <<"S"/utf8, 4:32/integer>>.

-file("src/pgl/internal/encode.gleam", 274).
?DOC(false).
-spec execute(binary(), integer()) -> bitstring().
execute(Name, Num) ->
    Msg_len = begin
        _pipe = gleam_stdlib:identity(Name),
        erlang:byte_size(_pipe)
    end
    + 9,
    <<"E"/utf8, Msg_len:32/integer, Name/binary, 0, Num:32/integer>>.

-file("src/pgl/internal/encode.gleam", 166).
?DOC(false).
-spec to_bit_array('query'(any(), any())) -> {ok, bitstring()} |
    {error, pgl@internal:internal_error()}.
to_bit_array(Msg) ->
    _pipe@1 = case erlang:element(5, Msg) of
        none ->
            {ok, <<>>};

        {some, Encoder} ->
            _pipe = bind(
                <<>>,
                <<>>,
                erlang:element(3, Msg),
                erlang:element(4, Msg),
                Encoder
            ),
            gleam@result:map_error(
                _pipe,
                fun(Err) -> {protocol_error, encoding_error, Err} end
            )
    end,
    gleam@result:map(
        _pipe@1,
        fun(Bind) ->
            Describe = describe(erlang:element(6, Msg), <<""/utf8>>),
            Exec = case erlang:element(7, Msg) of
                true ->
                    execute(<<""/utf8>>, 0);

                false ->
                    <<>>
            end,
            Final = case erlang:element(8, Msg) of
                {some, flush} ->
                    flush();

                {some, sync} ->
                    sync();

                none ->
                    <<>>
            end,
            Parse = parse(<<""/utf8>>, erlang:element(2, Msg), []),
            gleam_stdlib:bit_array_concat([Parse, Bind, Describe, Exec, Final])
        end
    ).