corrosion

-module(corrosion@query).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/corrosion/query.gleam").
-export(['query'/3]).
-export_type([query_result/1]).

-type query_result(IPB) :: {query_result, list(IPB), float()}.

-file("src/corrosion/query.gleam", 65).
-spec map_events(
    list(corrosion@query_event:query_event()),
    list(binary()),
    gleam@dynamic@decode:decoder(IPJ)
) -> {ok, query_result(IPJ)} | {error, binary()}.
map_events(Events, Columns, Decoder) ->
    gleam@bool:guard(
        gleam@list:is_empty(Events),
        {ok, {query_result, [], +0.0}},
        fun() ->
            {Event@1, Remaining_events@1} = case Events of
                [Event | Remaining_events] -> {Event, Remaining_events};
                _assert_fail ->
                    erlang:error(#{gleam_error => let_assert,
                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                file => <<?FILEPATH/utf8>>,
                                module => <<"corrosion/query"/utf8>>,
                                function => <<"map_events"/utf8>>,
                                line => 74,
                                value => _assert_fail,
                                start => 1910,
                                'end' => 1957,
                                pattern_start => 1921,
                                pattern_end => 1948})
            end,
            case Event@1 of
                {columns, Cols} ->
                    map_events(Remaining_events@1, Cols, Decoder);

                {row, _, Values} ->
                    Zipped = begin
                        _pipe = gleam@list:map(
                            Columns,
                            fun gleam_stdlib:identity/1
                        ),
                        _pipe@1 = gleam@list:strict_zip(_pipe, Values),
                        _pipe@2 = gleam@result:map(
                            _pipe@1,
                            fun gleam@dynamic:properties/1
                        ),
                        gleam@result:replace_error(
                            _pipe@2,
                            <<"Columns array is a different size from values."/utf8>>
                        )
                    end,
                    gleam@result:'try'(
                        Zipped,
                        fun(Dynamic) ->
                            Decode_result = begin
                                _pipe@3 = gleam@dynamic@decode:run(
                                    Dynamic,
                                    Decoder
                                ),
                                _pipe@4 = gleam@result:try_recover(
                                    _pipe@3,
                                    fun(_) ->
                                        gleam@dynamic@decode:run(
                                            gleam_stdlib:identity(Values),
                                            Decoder
                                        )
                                    end
                                ),
                                gleam@result:replace_error(
                                    _pipe@4,
                                    <<"Could not decode value from server."/utf8>>
                                )
                            end,
                            gleam@result:'try'(
                                Decode_result,
                                fun(Value) ->
                                    case map_events(
                                        Remaining_events@1,
                                        Columns,
                                        Decoder
                                    ) of
                                        {ok, Mapped} ->
                                            {ok,
                                                {query_result,
                                                    [Value |
                                                        erlang:element(
                                                            2,
                                                            Mapped
                                                        )],
                                                    erlang:element(3, Mapped)}};

                                        Error ->
                                            Error
                                    end
                                end
                            )
                        end
                    );

                {e_o_q, Time, _} ->
                    {ok, {query_result, [], Time}};

                {change, _, _, _, _} ->
                    {error, <<"/v1/query received a change event."/utf8>>};

                {query_error, Message} ->
                    {error, Message}
            end
        end
    ).

-file("src/corrosion/query.gleam", 21).
-spec 'query'(
    gleam@uri:uri(),
    corrosion@statement:statement(),
    gleam@dynamic@decode:decoder(IPC)
) -> {ok, query_result(IPC)} | {error, binary()}.
'query'(Corro_uri, Statement, Row_decoder) ->
    Uri = {uri,
        erlang:element(2, Corro_uri),
        erlang:element(3, Corro_uri),
        erlang:element(4, Corro_uri),
        erlang:element(5, Corro_uri),
        <<"/v1/queries"/utf8>>,
        erlang:element(7, Corro_uri),
        erlang:element(8, Corro_uri)},
    Body = begin
        _pipe = corrosion@internal@util:statement_to_json(Statement),
        _pipe@1 = gleam_json_ffi:json_to_iodata(_pipe),
        gleam_stdlib:wrap_list(_pipe@1)
    end,
    Base_request@1 = case gleam@http@request:from_uri(Uri) of
        {ok, Base_request} -> Base_request;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"corrosion/query"/utf8>>,
                        function => <<"query"/utf8>>,
                        line => 32,
                        value => _assert_fail,
                        start => 750,
                        'end' => 801,
                        pattern_start => 761,
                        pattern_end => 777})
    end,
    Request = begin
        _pipe@2 = Base_request@1,
        _pipe@3 = gleam@http@request:set_header(
            _pipe@2,
            <<"content-type"/utf8>>,
            <<"application/json"/utf8>>
        ),
        gleam@http@request:set_body(_pipe@3, Body)
    end,
    gleam@result:'try'(
        begin
            _pipe@4 = httpp@send:send_bits(Request),
            gleam@result:replace_error(
                _pipe@4,
                <<"Failed to send request to server."/utf8>>
            )
        end,
        fun(Response) ->
            gleam@result:'try'(
                begin
                    _pipe@5 = gleam@bit_array:to_string(
                        erlang:element(4, Response)
                    ),
                    gleam@result:replace_error(
                        _pipe@5,
                        <<"Server did not send utf-8 text back."/utf8>>
                    )
                end,
                fun(String) ->
                    Events = begin
                        _pipe@6 = String,
                        _pipe@7 = gleam@string:split(_pipe@6, <<"\n"/utf8>>),
                        _pipe@8 = gleam@list:map(
                            _pipe@7,
                            fun gleam@string:trim/1
                        ),
                        _pipe@10 = gleam@list:filter(
                            _pipe@8,
                            fun(Line) -> _pipe@9 = gleam@string:is_empty(Line),
                                gleam@bool:negate(_pipe@9) end
                        ),
                        _pipe@11 = gleam@list:map(
                            _pipe@10,
                            fun(Line@1) ->
                                case gleam@json:parse(
                                    Line@1,
                                    corrosion@query_event:decoder()
                                ) of
                                    {ok, Evt} ->
                                        {ok, Evt};

                                    {error, _} ->
                                        {error,
                                            <<"Failed to parse line from server: "/utf8,
                                                Line@1/binary>>}
                                end
                            end
                        ),
                        gleam@result:all(_pipe@11)
                    end,
                    gleam@result:'try'(
                        Events,
                        fun(Events@1) ->
                            map_events(Events@1, [], Row_decoder)
                        end
                    )
                end
            )
        end
    ).