-module(starmap@query).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([from/1, select1/2, select2/3, select3/4, select4/5, select5/6, select6/7, unwrap_converted_wheres/1, join/3, limit/2, order_by/2, order_by_desc/2, group_by/2, where/2]).
-export_type(['query'/2, table_column/0, where/3, where_columns/2, converted_where/1, converted_where_columns/1, join/0]).

-type 'query'(GSK, GSL) :: {'query',
        binary(),
        GSK,
        list(join()),
        list(converted_where(GSL)),
        list({table_column(), binary()}),
        list(table_column()),
        gleam@option:option(integer())}.

-type table_column() :: {table_column, binary(), binary()}.

-type where(GSM, GSN, GSO) :: {equal, where_columns(GSM, GSO)} |
    {not_equal, where_columns(GSM, GSO)} |
    {is_null, starmap@schema:column(gleam@option:option(GSM), GSO)} |
    {is_not_null, starmap@schema:column(gleam@option:option(GSM), GSO)} |
    {greater, where_columns(GSM, GSO)} |
    {greater_or_equal, where_columns(GSM, GSO)} |
    {lower, where_columns(GSM, GSO)} |
    {lower_or_equal, where_columns(GSM, GSO)} |
    {'or', where(GSM, GSN, GSO), where(GSN, GSM, GSO)}.

-type where_columns(GSP, GSQ) :: {column_value,
        starmap@schema:column(GSP, GSQ),
        GSP} |
    {columns, starmap@schema:column(GSP, GSQ), starmap@schema:column(GSP, GSQ)} |
    {columns_one_nullable,
        starmap@schema:column(GSP, GSQ),
        starmap@schema:column(gleam@option:option(GSP), GSQ)}.

-type converted_where(GSR) :: {converted_equal, converted_where_columns(GSR)} |
    {converted_not_equal, converted_where_columns(GSR)} |
    {converted_is_null, table_column()} |
    {converted_is_not_null, table_column()} |
    {converted_greater, converted_where_columns(GSR)} |
    {converted_greater_or_equal, converted_where_columns(GSR)} |
    {converted_lower, converted_where_columns(GSR)} |
    {converted_lower_or_equal, converted_where_columns(GSR)} |
    {converted_or, converted_where(GSR), converted_where(GSR)}.

-type converted_where_columns(GSS) :: {converted_column_value,
        table_column(),
        GSS} |
    {converted_columns, table_column(), table_column()}.

-type join() :: {join, table_column(), table_column()}.

-spec query_replace_columns('query'(nil, GST), GSW) -> 'query'(GSW, GST).
query_replace_columns(Query, Columns) ->
    {'query',
        erlang:element(2, Query),
        Columns,
        erlang:element(4, Query),
        erlang:element(5, Query),
        erlang:element(6, Query),
        erlang:element(7, Query),
        erlang:element(8, Query)}.

-spec from(binary()) -> 'query'(nil, any()).
from(Table) ->
    {'query', Table, nil, [], [], [], [], none}.

-spec select1('query'(nil, GTC), starmap@schema:column(GTF, GTG)) -> 'query'(starmap@schema:column(GTF, GTG), GTC).
select1(Query, Column1) ->
    _pipe = Query,
    query_replace_columns(_pipe, Column1).

-spec select2(
    'query'(nil, GTN),
    starmap@schema:column(GTQ, GTR),
    starmap@schema:column(GTU, GTR)
) -> 'query'({starmap@schema:column(GTQ, GTR), starmap@schema:column(GTU, GTR)}, GTN).
select2(Query, Column1, Column2) ->
    _pipe = Query,
    query_replace_columns(_pipe, {Column1, Column2}).

-spec select3(
    'query'(nil, GUD),
    starmap@schema:column(GUG, GUH),
    starmap@schema:column(GUK, GUH),
    starmap@schema:column(GUN, GUH)
) -> 'query'({starmap@schema:column(GUG, GUH),
    starmap@schema:column(GUK, GUH),
    starmap@schema:column(GUN, GUH)}, GUD).
select3(Query, Column1, Column2, Column3) ->
    _pipe = Query,
    query_replace_columns(_pipe, {Column1, Column2, Column3}).

-spec select4(
    'query'(nil, GUY),
    starmap@schema:column(GVB, GVC),
    starmap@schema:column(GVF, GVC),
    starmap@schema:column(GVI, GVC),
    starmap@schema:column(GVL, GVC)
) -> 'query'({starmap@schema:column(GVB, GVC),
    starmap@schema:column(GVF, GVC),
    starmap@schema:column(GVI, GVC),
    starmap@schema:column(GVL, GVC)}, GUY).
select4(Query, Column1, Column2, Column3, Column4) ->
    _pipe = Query,
    query_replace_columns(_pipe, {Column1, Column2, Column3, Column4}).

-spec select5(
    'query'(nil, GVY),
    starmap@schema:column(GWB, GWC),
    starmap@schema:column(GWF, GWC),
    starmap@schema:column(GWI, GWC),
    starmap@schema:column(GWL, GWC),
    starmap@schema:column(GWO, GWC)
) -> 'query'({starmap@schema:column(GWB, GWC),
    starmap@schema:column(GWF, GWC),
    starmap@schema:column(GWI, GWC),
    starmap@schema:column(GWL, GWC),
    starmap@schema:column(GWO, GWC)}, GVY).
select5(Query, Column1, Column2, Column3, Column4, Column5) ->
    _pipe = Query,
    query_replace_columns(_pipe, {Column1, Column2, Column3, Column4, Column5}).

-spec select6(
    'query'(nil, GXD),
    starmap@schema:column(GXG, GXH),
    starmap@schema:column(GXK, GXH),
    starmap@schema:column(GXN, GXH),
    starmap@schema:column(GXQ, GXH),
    starmap@schema:column(GXT, GXH),
    starmap@schema:column(GXW, GXH)
) -> 'query'({starmap@schema:column(GXG, GXH),
    starmap@schema:column(GXK, GXH),
    starmap@schema:column(GXN, GXH),
    starmap@schema:column(GXQ, GXH),
    starmap@schema:column(GXT, GXH),
    starmap@schema:column(GXW, GXH)}, GXD).
select6(Query, Column1, Column2, Column3, Column4, Column5, Column6) ->
    _pipe = Query,
    query_replace_columns(
        _pipe,
        {Column1, Column2, Column3, Column4, Column5, Column6}
    ).

-spec unwrap_converted_wheres(list(converted_where(GZF))) -> list(gleam@option:option(converted_where_columns(GZF))).
unwrap_converted_wheres(Converted_wheres) ->
    _pipe = Converted_wheres,
    _pipe@2 = gleam@list:map(
        _pipe,
        fun(Converted_where) -> case Converted_where of
                {converted_equal, Columns} ->
                    [{some, Columns}];

                {converted_not_equal, Columns@1} ->
                    [{some, Columns@1}];

                {converted_greater, Columns@2} ->
                    [{some, Columns@2}];

                {converted_greater_or_equal, Columns@3} ->
                    [{some, Columns@3}];

                {converted_lower, Columns@4} ->
                    [{some, Columns@4}];

                {converted_lower_or_equal, Columns@5} ->
                    [{some, Columns@5}];

                {converted_or, Where1, Where2} ->
                    _pipe@1 = [unwrap_converted_wheres([Where1, Where2])],
                    gleam@list:flatten(_pipe@1);

                _ ->
                    [none]
            end end
    ),
    gleam@list:flatten(_pipe@2).

-spec convert_where_columns(where_columns(any(), GZT)) -> converted_where_columns(GZT).
convert_where_columns(Where_columns) ->
    case Where_columns of
        {column_value, Column, Val} ->
            {converted_column_value,
                {table_column,
                    erlang:element(2, Column),
                    erlang:element(3, Column)},
                (erlang:element(2, erlang:element(4, erlang:element(4, Column))))(
                    Val
                )};

        {columns, Column1, Column2} ->
            {converted_columns,
                {table_column,
                    erlang:element(2, Column1),
                    erlang:element(3, Column1)},
                {table_column,
                    erlang:element(2, Column2),
                    erlang:element(3, Column2)}};

        {columns_one_nullable, Column1@1, Column2@1} ->
            {converted_columns,
                {table_column,
                    erlang:element(2, Column1@1),
                    erlang:element(3, Column1@1)},
                {table_column,
                    erlang:element(2, Column2@1),
                    erlang:element(3, Column2@1)}}
    end.

-spec join(
    'query'(GZX, GZY),
    starmap@schema:column(HAB, HAC),
    starmap@schema:column(HAB, HAC)
) -> 'query'(GZX, GZY).
join(Query, Column1, Column2) ->
    erlang:setelement(
        4,
        Query,
        begin
            _pipe = erlang:element(4, Query),
            lists:append(
                _pipe,
                [{join,
                        {table_column,
                            erlang:element(2, Column1),
                            erlang:element(3, Column1)},
                        {table_column,
                            erlang:element(2, Column2),
                            erlang:element(3, Column2)}}]
            )
        end
    ).

-spec limit('query'(HAJ, HAK), integer()) -> 'query'(HAJ, HAK).
limit(Query, Amount) ->
    erlang:setelement(8, Query, {some, Amount}).

-spec order_by('query'(HAP, HAQ), starmap@schema:column(any(), any())) -> 'query'(HAP, HAQ).
order_by(Query, Column) ->
    erlang:setelement(
        6,
        Query,
        begin
            _pipe = erlang:element(6, Query),
            lists:append(
                _pipe,
                [{{table_column,
                            erlang:element(2, Column),
                            erlang:element(3, Column)},
                        <<"ASC"/utf8>>}]
            )
        end
    ).

-spec order_by_desc('query'(HAZ, HBA), starmap@schema:column(any(), any())) -> 'query'(HAZ, HBA).
order_by_desc(Query, Column) ->
    erlang:setelement(
        6,
        Query,
        begin
            _pipe = erlang:element(6, Query),
            lists:append(
                _pipe,
                [{{table_column,
                            erlang:element(2, Column),
                            erlang:element(3, Column)},
                        <<"DESC"/utf8>>}]
            )
        end
    ).

-spec group_by('query'(HBJ, HBK), starmap@schema:column(any(), any())) -> 'query'(HBJ, HBK).
group_by(Query, Column) ->
    erlang:setelement(
        7,
        Query,
        begin
            _pipe = erlang:element(7, Query),
            lists:append(
                _pipe,
                [{table_column,
                        erlang:element(2, Column),
                        erlang:element(3, Column)}]
            )
        end
    ).

-spec convert_where_redirect(where(any(), any(), GZN)) -> converted_where(GZN).
convert_where_redirect(Where) ->
    convert_where(Where).

-spec convert_where(where(any(), any(), GZA)) -> converted_where(GZA).
convert_where(Where) ->
    case Where of
        {equal, Columns} ->
            {converted_equal, convert_where_columns(Columns)};

        {not_equal, Columns@1} ->
            {converted_not_equal, convert_where_columns(Columns@1)};

        {is_null, Column} ->
            {converted_is_null,
                {table_column,
                    erlang:element(2, Column),
                    erlang:element(3, Column)}};

        {is_not_null, Column@1} ->
            {converted_is_not_null,
                {table_column,
                    erlang:element(2, Column@1),
                    erlang:element(3, Column@1)}};

        {greater, Columns@2} ->
            {converted_greater, convert_where_columns(Columns@2)};

        {greater_or_equal, Columns@3} ->
            {converted_greater_or_equal, convert_where_columns(Columns@3)};

        {lower, Columns@4} ->
            {converted_lower, convert_where_columns(Columns@4)};

        {lower_or_equal, Columns@5} ->
            {converted_lower_or_equal, convert_where_columns(Columns@5)};

        {'or', Where1, Where2} ->
            {converted_or,
                convert_where(Where1),
                convert_where_redirect(Where2)}
    end.

-spec where('query'(GYN, GYO), where(any(), any(), GYO)) -> 'query'(GYN, GYO).
where(Query, Where) ->
    erlang:setelement(
        5,
        Query,
        begin
            _pipe = erlang:element(5, Query),
            lists:append(_pipe, [convert_where(Where)])
        end
    ).