-module(sqlode@codegen@params).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/sqlode/codegen/params.gleam").
-export([render/5]).

-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/sqlode/codegen/params.gleam", 89).
-spec queries_have_array_params(list(sqlode@model:analyzed_query())) -> boolean().
queries_have_array_params(Queries) ->
    gleam@list:any(
        Queries,
        fun(Q) ->
            gleam@list:any(
                erlang:element(3, Q),
                fun(P) -> case erlang:element(4, P) of
                        {array_type, _} ->
                            true;

                        _ ->
                            false
                    end end
            )
        end
    ).

-file("src/sqlode/codegen/params.gleam", 100).
-spec needs_option_import(list(sqlode@model:analyzed_query())) -> boolean().
needs_option_import(Queries) ->
    gleam@list:any(
        Queries,
        fun(Query) ->
            gleam@list:any(
                erlang:element(3, Query),
                fun(Param) -> erlang:element(5, Param) end
            )
        end
    ).

-file("src/sqlode/codegen/params.gleam", 152).
-spec param_fields(
    list(sqlode@model:query_param()),
    sqlode@model:type_mapping()
) -> list(binary()).
param_fields(Params, Type_mapping) ->
    _pipe = Params,
    gleam@list:map(
        _pipe,
        fun(Param) ->
            Base_type = sqlode@type_mapping:scalar_type_to_gleam_type(
                erlang:element(4, Param),
                Type_mapping
            ),
            Typed = case erlang:element(6, Param) of
                true ->
                    <<<<"List("/utf8, Base_type/binary>>/binary, ")"/utf8>>;

                false ->
                    case erlang:element(5, Param) of
                        true ->
                            <<<<"Option("/utf8, Base_type/binary>>/binary,
                                ")"/utf8>>;

                        false ->
                            Base_type
                    end
            end,
            <<<<(erlang:element(3, Param))/binary, ": "/utf8>>/binary,
                Typed/binary>>
        end
    ).

-file("src/sqlode/codegen/params.gleam", 234).
-spec strong_unwrap_expr(
    sqlode@model:scalar_type(),
    sqlode@model:type_mapping()
) -> gleam@option:option(binary()).
strong_unwrap_expr(Scalar_type, Type_mapping) ->
    case Type_mapping of
        strong_mapping ->
            case sqlode@type_mapping:strong_type_unwrap_fn(Scalar_type) of
                {some, Fn_name} ->
                    {some, <<"models."/utf8, Fn_name/binary>>};

                none ->
                    none
            end;

        _ ->
            none
    end.

-file("src/sqlode/codegen/params.gleam", 248).
-spec render_array_element_mapper(
    sqlode@model:scalar_type(),
    sqlode@model:type_mapping()
) -> binary().
render_array_element_mapper(Element, Type_mapping) ->
    Runtime_fn = sqlode@type_mapping:scalar_type_to_runtime_function(Element),
    case Element of
        {enum_type, Name} ->
            To_str = <<"models."/utf8,
                (sqlode@type_mapping:enum_to_string_fn(Name))/binary>>,
            <<<<<<<<"fn(v) { "/utf8, Runtime_fn/binary>>/binary, "("/utf8>>/binary,
                    To_str/binary>>/binary,
                "(v)) }"/utf8>>;

        _ ->
            Unwrap = strong_unwrap_expr(Element, Type_mapping),
            case Unwrap of
                none ->
                    Runtime_fn;

                {some, Fn_name} ->
                    <<<<<<<<"fn(v) { "/utf8, Runtime_fn/binary>>/binary,
                                "("/utf8>>/binary,
                            Fn_name/binary>>/binary,
                        "(v)) }"/utf8>>
            end
    end.

-file("src/sqlode/codegen/params.gleam", 180).
-spec render_param_value(
    sqlode@model:query_param(),
    sqlode@model:type_mapping()
) -> binary().
render_param_value(Param, Type_mapping) ->
    Value_expr = <<"params."/utf8, (erlang:element(3, Param))/binary>>,
    Runtime_fn = sqlode@type_mapping:scalar_type_to_runtime_function(
        erlang:element(4, Param)
    ),
    case erlang:element(4, Param) of
        {enum_type, Name} ->
            To_string_fn = <<"models."/utf8,
                (sqlode@type_mapping:enum_to_string_fn(Name))/binary>>,
            Encode_fn = <<<<<<<<"fn(v) { "/utf8, Runtime_fn/binary>>/binary,
                        "("/utf8>>/binary,
                    To_string_fn/binary>>/binary,
                "(v)) }"/utf8>>,
            case erlang:element(5, Param) of
                true ->
                    <<<<<<<<"runtime.nullable("/utf8, Value_expr/binary>>/binary,
                                ", "/utf8>>/binary,
                            Encode_fn/binary>>/binary,
                        ")"/utf8>>;

                false ->
                    <<<<<<<<<<Runtime_fn/binary, "("/utf8>>/binary,
                                    To_string_fn/binary>>/binary,
                                "("/utf8>>/binary,
                            Value_expr/binary>>/binary,
                        "))"/utf8>>
            end;

        {array_type, Element} ->
            Mapper = render_array_element_mapper(Element, Type_mapping),
            Array_expr = <<<<<<<<"runtime.array(list.map("/utf8,
                            Value_expr/binary>>/binary,
                        ", "/utf8>>/binary,
                    Mapper/binary>>/binary,
                "))"/utf8>>,
            case erlang:element(5, Param) of
                true ->
                    <<<<<<<<"runtime.nullable("/utf8, Value_expr/binary>>/binary,
                                ", fn(v) { runtime.array(list.map(v, "/utf8>>/binary,
                            Mapper/binary>>/binary,
                        ")) })"/utf8>>;

                false ->
                    Array_expr
            end;

        _ ->
            Unwrap = strong_unwrap_expr(erlang:element(4, Param), Type_mapping),
            case erlang:element(5, Param) of
                true ->
                    Encode_fn@1 = case Unwrap of
                        none ->
                            Runtime_fn;

                        {some, Fn_name} ->
                            <<<<<<<<"fn(v) { "/utf8, Runtime_fn/binary>>/binary,
                                        "("/utf8>>/binary,
                                    Fn_name/binary>>/binary,
                                "(v)) }"/utf8>>
                    end,
                    <<<<<<<<"runtime.nullable("/utf8, Value_expr/binary>>/binary,
                                ", "/utf8>>/binary,
                            Encode_fn@1/binary>>/binary,
                        ")"/utf8>>;

                false ->
                    case Unwrap of
                        none ->
                            <<<<<<Runtime_fn/binary, "("/utf8>>/binary,
                                    Value_expr/binary>>/binary,
                                ")"/utf8>>;

                        {some, Fn_name@1} ->
                            <<<<<<<<<<Runtime_fn/binary, "("/utf8>>/binary,
                                            Fn_name@1/binary>>/binary,
                                        "("/utf8>>/binary,
                                    Value_expr/binary>>/binary,
                                "))"/utf8>>
                    end
            end
    end.

-file("src/sqlode/codegen/params.gleam", 172).
-spec param_accessors(
    list(sqlode@model:query_param()),
    sqlode@model:type_mapping()
) -> list(binary()).
param_accessors(Params, Type_mapping) ->
    _pipe = Params,
    gleam@list:map(
        _pipe,
        fun(_capture) -> render_param_value(_capture, Type_mapping) end
    ).

-file("src/sqlode/codegen/params.gleam", 284).
-spec render_list_param_mapper(
    sqlode@model:query_param(),
    sqlode@model:type_mapping()
) -> binary().
render_list_param_mapper(Param, Type_mapping) ->
    Value_expr = <<"params."/utf8, (erlang:element(3, Param))/binary>>,
    Mapper = render_array_element_mapper(erlang:element(4, Param), Type_mapping),
    <<<<<<<<"list.map("/utf8, Value_expr/binary>>/binary, ", "/utf8>>/binary,
            Mapper/binary>>/binary,
        ")"/utf8>>.

-file("src/sqlode/codegen/params.gleam", 271).
?DOC(
    " Render param values for queries with slice params.\n"
    " Scalars are wrapped in singleton lists, slices are mapped.\n"
).
-spec param_accessors_flattened(
    list(sqlode@model:query_param()),
    sqlode@model:type_mapping()
) -> list(binary()).
param_accessors_flattened(Params, Type_mapping) ->
    _pipe = Params,
    gleam@list:map(_pipe, fun(Param) -> case erlang:element(6, Param) of
                true ->
                    render_list_param_mapper(Param, Type_mapping);

                false ->
                    <<<<"["/utf8,
                            (render_param_value(Param, Type_mapping))/binary>>/binary,
                        "]"/utf8>>
            end end).

-file("src/sqlode/codegen/params.gleam", 106).
-spec render_params_declaration(
    sqlode@naming:naming_context(),
    sqlode@model:analyzed_query(),
    sqlode@model:type_mapping()
) -> binary().
render_params_declaration(Naming_ctx, Query, Type_mapping) ->
    Type_name = <<(sqlode@naming:to_pascal_case(
            Naming_ctx,
            erlang:element(2, erlang:element(2, Query))
        ))/binary,
        "Params"/utf8>>,
    Function_name = <<(erlang:element(3, erlang:element(2, Query)))/binary,
        "_values"/utf8>>,
    case erlang:element(3, Query) of
        [] ->
            <<""/utf8>>;

        Params ->
            Has_slices = sqlode@codegen@common:has_slices(Params),
            Values_body = case Has_slices of
                true ->
                    <<<<"  list.flatten(["/utf8,
                            (gleam@string:join(
                                param_accessors_flattened(Params, Type_mapping),
                                <<", "/utf8>>
                            ))/binary>>/binary,
                        "])"/utf8>>;

                false ->
                    <<<<"  ["/utf8,
                            (gleam@string:join(
                                param_accessors(Params, Type_mapping),
                                <<", "/utf8>>
                            ))/binary>>/binary,
                        "]"/utf8>>
            end,
            gleam@string:join(
                [<<<<"pub type "/utf8, Type_name/binary>>/binary, " {"/utf8>>,
                    <<<<<<<<"  "/utf8, Type_name/binary>>/binary, "("/utf8>>/binary,
                            (gleam@string:join(
                                param_fields(Params, Type_mapping),
                                <<", "/utf8>>
                            ))/binary>>/binary,
                        ")"/utf8>>,
                    <<"}"/utf8>>,
                    <<""/utf8>>,
                    <<<<<<<<"pub fn "/utf8, Function_name/binary>>/binary,
                                "(params: "/utf8>>/binary,
                            Type_name/binary>>/binary,
                        ") -> List(Value) {"/utf8>>,
                    Values_body,
                    <<"}"/utf8>>],
                <<"\n"/utf8>>
            )
    end.

-file("src/sqlode/codegen/params.gleam", 9).
-spec render(
    sqlode@naming:naming_context(),
    list(sqlode@model:analyzed_query()),
    sqlode@model:type_mapping(),
    binary(),
    binary()
) -> binary().
render(Naming_ctx, Queries, Type_mapping, Module_path, Runtime_import) ->
    Has_slices = sqlode@codegen@common:queries_have_slices(Queries),
    Has_arrays = queries_have_array_params(Queries),
    Has_enums = sqlode@codegen@common:queries_have_enum_params(Queries),
    Custom_imports = begin
        _pipe = sqlode@codegen@common:param_scalar_types(Queries),
        sqlode@codegen@common:custom_type_imports(_pipe)
    end,
    Needs_models_for_strong = (Type_mapping =:= strong_mapping) andalso gleam@list:any(
        Queries,
        fun(Q) ->
            gleam@list:any(
                erlang:element(3, Q),
                fun(P) ->
                    sqlode@type_mapping:is_rich_type(erlang:element(4, P))
                end
            )
        end
    ),
    Runtime_import_line = <<<<"import "/utf8, Runtime_import/binary>>/binary,
        ".{type Value}"/utf8>>,
    Imports = case needs_option_import(Queries) of
        true ->
            lists:append([case Has_slices orelse Has_arrays of
                        true ->
                            [<<"import gleam/list"/utf8>>];

                        false ->
                            []
                    end, [<<"import gleam/option.{type Option, None, Some}"/utf8>>,
                        Runtime_import_line], case Has_enums orelse Needs_models_for_strong of
                        true ->
                            [<<<<"import "/utf8, Module_path/binary>>/binary,
                                    "/models"/utf8>>];

                        false ->
                            []
                    end, Custom_imports]);

        false ->
            lists:append([case Has_slices orelse Has_arrays of
                        true ->
                            [<<"import gleam/list"/utf8>>];

                        false ->
                            []
                    end, [Runtime_import_line], case Has_enums orelse Needs_models_for_strong of
                        true ->
                            [<<<<"import "/utf8, Module_path/binary>>/binary,
                                    "/models"/utf8>>];

                        false ->
                            []
                    end, Custom_imports])
    end,
    Queries_with_params = gleam@list:filter(
        Queries,
        fun(Q@1) -> not gleam@list:is_empty(erlang:element(3, Q@1)) end
    ),
    Declarations = begin
        _pipe@1 = Queries_with_params,
        _pipe@2 = gleam@list:map(
            _pipe@1,
            fun(_capture) ->
                render_params_declaration(Naming_ctx, _capture, Type_mapping)
            end
        ),
        gleam@string:join(_pipe@2, <<"\n\n"/utf8>>)
    end,
    Effective_imports = case Queries_with_params of
        [] ->
            [];

        _ ->
            Imports
    end,
    Lines = lists:append(
        [[<<"// Code generated by sqlode. DO NOT EDIT."/utf8>>, <<""/utf8>>],
            Effective_imports,
            case Declarations of
                <<""/utf8>> ->
                    [];

                _ ->
                    [<<""/utf8>>, Declarations]
            end]
    ),
    gleam@string:join(Lines, <<"\n"/utf8>>).