-module(parrot@internal@codegen).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-define(FILEPATH, "src/parrot/internal/codegen.gleam").
-export([gleam_type_to_string/1, sqlc_col_to_gleam/2, gen_column_name/2, gen_query_type/2, gen_query_function/2, gen_query_decoder/2, comment_dont_edit/0, gen_gleam_module/1, codegen_from_config/1]).
-export_type([codegen/0, gleam_type/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).

-type codegen() :: {codegen, list(binary())}.

-type gleam_type() :: gleam_string |
    gleam_int |
    gleam_float |
    gleam_bool |
    gleam_timestamp |
    gleam_bit_array |
    {gleam_list, gleam_type()} |
    {gleam_enum, binary()} |
    gleam_dynamic.

-file("src/parrot/internal/codegen.gleam", 79).
?DOC(false).
-spec gleam_type_to_string(gleam_type()) -> binary().
gleam_type_to_string(Gleamtype) ->
    case Gleamtype of
        gleam_bool ->
            <<"Bool"/utf8>>;

        gleam_float ->
            <<"Float"/utf8>>;

        gleam_int ->
            <<"Int"/utf8>>;

        gleam_string ->
            <<"String"/utf8>>;

        gleam_timestamp ->
            <<"Timestamp"/utf8>>;

        gleam_bit_array ->
            <<"BitArray"/utf8>>;

        {gleam_list, Sub} ->
            <<<<"List("/utf8, (gleam_type_to_string(Sub))/binary>>/binary,
                ")"/utf8>>;

        {gleam_enum, Name} ->
            parrot@internal@string_case:pascal_case(Name);

        gleam_dynamic ->
            <<"decode.Dynamic"/utf8>>
    end.

-file("src/parrot/internal/codegen.gleam", 93).
?DOC(false).
-spec normalise_col_type(parrot@internal@sqlc:table_column()) -> binary().
normalise_col_type(Col) ->
    Type_ = erlang:element(4, erlang:element(16, Col)),
    case Type_ of
        <<"pg_catalog."/utf8, X/binary>> ->
            X;

        X@1 ->
            X@1
    end.

-file("src/parrot/internal/codegen.gleam", 101).
?DOC(false).
-spec find_col_schema(
    parrot@internal@sqlc:table_column(),
    parrot@internal@sqlc:s_q_l_c()
) -> parrot@internal@sqlc:schema().
find_col_schema(Col, Context) ->
    Schema_name = erlang:element(3, erlang:element(16, Col)),
    Schema_name@1 = case Schema_name of
        <<""/utf8>> ->
            erlang:element(3, erlang:element(5, Context));

        <<"pg_catalog"/utf8>> ->
            erlang:element(3, erlang:element(5, Context));

        _ ->
            Schema_name
    end,
    Schema@1 = case gleam@list:find(
        erlang:element(5, erlang:element(5, Context)),
        fun(S) -> erlang:element(3, S) =:= Schema_name@1 end
    ) of
        {ok, Schema} -> Schema;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"parrot/internal/codegen"/utf8>>,
                        function => <<"find_col_schema"/utf8>>,
                        line => 109,
                        value => _assert_fail,
                        start => 2704,
                        'end' => 2799,
                        pattern_start => 2715,
                        pattern_end => 2725})
    end,
    Schema@1.

-file("src/parrot/internal/codegen.gleam", 115).
?DOC(false).
-spec sqlc_col_to_gleam(
    parrot@internal@sqlc:table_column(),
    parrot@internal@sqlc:s_q_l_c()
) -> gleam_type().
sqlc_col_to_gleam(Col, Context) ->
    given:that(
        erlang:element(4, Col),
        fun() ->
            Col@1 = begin
                _record = Col,
                {table_column,
                    erlang:element(2, _record),
                    erlang:element(3, _record),
                    false,
                    erlang:element(5, _record),
                    erlang:element(6, _record),
                    erlang:element(7, _record),
                    erlang:element(8, _record),
                    erlang:element(9, _record),
                    erlang:element(10, _record),
                    erlang:element(11, _record),
                    erlang:element(12, _record),
                    erlang:element(13, _record),
                    erlang:element(14, _record),
                    erlang:element(15, _record),
                    erlang:element(16, _record)}
            end,
            Type_ = sqlc_col_to_gleam(Col@1, Context),
            {gleam_list, Type_}
        end,
        fun() ->
            Sqltype = normalise_col_type(Col),
            Schema = find_col_schema(Col, Context),
            Enum = begin
                _pipe = erlang:element(5, Schema),
                gleam@list:find(
                    _pipe,
                    fun(E) -> erlang:element(2, E) =:= Sqltype end
                )
            end,
            given:that(
                gleam@result:is_ok(Enum),
                fun() ->
                    Enum@2 = case Enum of
                        {ok, Enum@1} -> Enum@1;
                        _assert_fail ->
                            erlang:error(#{gleam_error => let_assert,
                                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                        file => <<?FILEPATH/utf8>>,
                                        module => <<"parrot/internal/codegen"/utf8>>,
                                        function => <<"sqlc_col_to_gleam"/utf8>>,
                                        line => 129,
                                        value => _assert_fail,
                                        start => 3291,
                                        'end' => 3317,
                                        pattern_start => 3302,
                                        pattern_end => 3310})
                    end,
                    {gleam_enum, erlang:element(2, Enum@2)}
                end,
                fun() -> case string:lowercase(Sqltype) of
                        <<"int"/utf8, _/binary>> ->
                            gleam_int;

                        <<"tinyint"/utf8>> ->
                            gleam_int;

                        <<"smallint"/utf8>> ->
                            gleam_int;

                        <<"mediumint"/utf8>> ->
                            gleam_int;

                        <<"bigint"/utf8>> ->
                            gleam_int;

                        <<"serial"/utf8, _/binary>> ->
                            gleam_int;

                        <<"smallserial"/utf8>> ->
                            gleam_int;

                        <<"bigserial"/utf8>> ->
                            gleam_int;

                        <<"year"/utf8>> ->
                            gleam_int;

                        <<"float"/utf8, _/binary>> ->
                            gleam_float;

                        <<"dec"/utf8, _/binary>> ->
                            gleam_float;

                        <<"fixed"/utf8>> ->
                            gleam_float;

                        <<"real"/utf8>> ->
                            gleam_float;

                        <<"numeric"/utf8>> ->
                            gleam_float;

                        <<"double"/utf8>> ->
                            gleam_float;

                        <<"money"/utf8, _/binary>> ->
                            gleam_float;

                        <<"char"/utf8, _/binary>> ->
                            gleam_string;

                        <<"varchar"/utf8, _/binary>> ->
                            gleam_string;

                        <<"text"/utf8, _/binary>> ->
                            gleam_string;

                        <<"mediumtext"/utf8, _/binary>> ->
                            gleam_string;

                        <<"longtext"/utf8, _/binary>> ->
                            gleam_string;

                        <<"json"/utf8, _/binary>> ->
                            gleam_string;

                        <<"uuid"/utf8>> ->
                            gleam_bit_array;

                        <<"bit"/utf8>> ->
                            gleam_bit_array;

                        <<"blob"/utf8>> ->
                            gleam_bit_array;

                        <<"tinyblob"/utf8>> ->
                            gleam_bit_array;

                        <<"smallblob"/utf8>> ->
                            gleam_bit_array;

                        <<"mediumblob"/utf8>> ->
                            gleam_bit_array;

                        <<"longblob"/utf8>> ->
                            gleam_bit_array;

                        <<"binary"/utf8>> ->
                            gleam_bit_array;

                        <<"varbinary"/utf8>> ->
                            gleam_bit_array;

                        <<"byte"/utf8, _/binary>> ->
                            gleam_bit_array;

                        <<"date"/utf8, _/binary>> ->
                            gleam_timestamp;

                        <<"time"/utf8, _/binary>> ->
                            gleam_timestamp;

                        <<"bool"/utf8, _/binary>> ->
                            gleam_bool;

                        _ ->
                            gleam_dynamic
                    end end
            )
        end
    ).

-file("src/parrot/internal/codegen.gleam", 172).
?DOC(false).
-spec gen_column_name(
    parrot@internal@sqlc:'query'(),
    parrot@internal@sqlc:table_column()
) -> binary().
gen_column_name(Query, Col) ->
    Occ = begin
        _pipe = erlang:element(6, Query),
        gleam@list:count(
            _pipe,
            fun(Col2) -> erlang:element(2, Col) =:= erlang:element(2, Col2) end
        )
    end,
    Result = case Occ of
        0 ->
            erlang:error(#{gleam_error => panic,
                    message => (<<"could not find column name: "/utf8,
                        (erlang:element(2, Col))/binary>>),
                    file => <<?FILEPATH/utf8>>,
                    module => <<"parrot/internal/codegen"/utf8>>,
                    function => <<"gen_column_name"/utf8>>,
                    line => 177});

        1 ->
            erlang:element(2, Col);

        _ ->
            case erlang:element(15, Col) of
                none ->
                    erlang:element(2, Col);

                {some, T} ->
                    <<<<(erlang:element(4, T))/binary, "_"/utf8>>/binary,
                        (erlang:element(2, Col))/binary>>
            end
    end,
    parrot@internal@string_case:snake_case(Result).

-file("src/parrot/internal/codegen.gleam", 189).
?DOC(false).
-spec gen_query_type(
    parrot@internal@sqlc:'query'(),
    parrot@internal@sqlc:s_q_l_c()
) -> binary().
gen_query_type(Query, Context) ->
    Name = parrot@internal@string_case:pascal_case(erlang:element(3, Query)),
    Args = begin
        _pipe = erlang:element(6, Query),
        _pipe@1 = gleam@list:map(
            _pipe,
            fun(Col) ->
                Gleam_type = sqlc_col_to_gleam(Col, Context),
                Col_type = gleam_type_to_string(Gleam_type),
                Col_type@1 = case erlang:element(3, Col) of
                    true ->
                        Col_type;

                    false ->
                        <<<<"Option("/utf8, Col_type/binary>>/binary, ")"/utf8>>
                end,
                Col_name = gen_column_name(Query, Col),
                <<<<Col_name/binary, ": "/utf8>>/binary, Col_type@1/binary>>
            end
        ),
        _pipe@2 = gleam@list:map(
            _pipe@1,
            fun(Str) -> <<"    "/utf8, Str/binary>> end
        ),
        gleam@string:join(_pipe@2, <<",\n"/utf8>>)
    end,
    _pipe@3 = [<<<<"pub type "/utf8, Name/binary>>/binary, " {"/utf8>>,
        <<<<"  "/utf8, Name/binary>>/binary, "("/utf8>>,
        Args,
        <<"  )"/utf8>>,
        <<"}"/utf8>>],
    gleam@string:join(_pipe@3, <<"\n"/utf8>>).

-file("src/parrot/internal/codegen.gleam", 211).
?DOC(false).
-spec gleam_type_to_param(gleam_type()) -> binary().
gleam_type_to_param(Gtype) ->
    case Gtype of
        gleam_int ->
            <<"dev.ParamInt"/utf8>>;

        gleam_string ->
            <<"dev.ParamString"/utf8>>;

        gleam_float ->
            <<"dev.ParamFloat"/utf8>>;

        gleam_bool ->
            <<"dev.ParamBool"/utf8>>;

        gleam_timestamp ->
            <<"dev.ParamTimestamp"/utf8>>;

        gleam_bit_array ->
            <<"dev.ParamBitArray"/utf8>>;

        gleam_dynamic ->
            <<"dev.ParamDynamic"/utf8>>;

        {gleam_enum, _} ->
            <<"dev.ParamString"/utf8>>;

        {gleam_list, Sub} ->
            <<<<"dev.ParamList("/utf8, (gleam_type_to_param(Sub))/binary>>/binary,
                ")"/utf8>>
    end.

-file("src/parrot/internal/codegen.gleam", 225).
?DOC(false).
-spec gen_query_function(
    parrot@internal@sqlc:'query'(),
    parrot@internal@sqlc:s_q_l_c()
) -> binary().
gen_query_function(Query, Context) ->
    Fn_name = parrot@internal@string_case:snake_case(erlang:element(3, Query)),
    Def_fn_args = begin
        _pipe = erlang:element(9, Query),
        _pipe@1 = gleam@list:map(
            _pipe,
            fun(P) ->
                Gleam_type = sqlc_col_to_gleam(erlang:element(3, P), Context),
                <<<<<<<<(erlang:element(2, erlang:element(3, P)))/binary,
                                " "/utf8>>/binary,
                            (erlang:element(2, erlang:element(3, P)))/binary>>/binary,
                        ": "/utf8>>/binary,
                    (gleam_type_to_string(Gleam_type))/binary>>
            end
        ),
        gleam@string:join(_pipe@1, <<", "/utf8>>)
    end,
    Def_return_params = case erlang:element(9, Query) of
        [] ->
            <<"[]"/utf8>>;

        Args ->
            <<<<"["/utf8,
                    (begin
                        _pipe@2 = Args,
                        _pipe@3 = gleam@list:map(
                            _pipe@2,
                            fun(Arg) ->
                                Arg_type = sqlc_col_to_gleam(
                                    erlang:element(3, Arg),
                                    Context
                                ),
                                Param = gleam_type_to_param(Arg_type),
                                Value = case Arg_type of
                                    {gleam_enum, Name} ->
                                        Name@1 = parrot@internal@string_case:snake_case(
                                            Name
                                        ),
                                        <<<<<<Name@1/binary,
                                                    "_to_string("/utf8>>/binary,
                                                (erlang:element(
                                                    2,
                                                    erlang:element(3, Arg)
                                                ))/binary>>/binary,
                                            ")"/utf8>>;

                                    _ ->
                                        erlang:element(
                                            2,
                                            erlang:element(3, Arg)
                                        )
                                end,
                                <<<<<<Param/binary, "("/utf8>>/binary,
                                        Value/binary>>/binary,
                                    ")"/utf8>>
                            end
                        ),
                        gleam@string:join(_pipe@3, <<", "/utf8>>)
                    end)/binary>>/binary,
                "]"/utf8>>
    end,
    Def_fn = <<<<<<<<"pub fn "/utf8, Fn_name/binary>>/binary, "("/utf8>>/binary,
            Def_fn_args/binary>>/binary,
        ")"/utf8>>,
    Def_sql = <<<<"let sql = \""/utf8, (erlang:element(2, Query))/binary>>/binary,
        "\""/utf8>>,
    Def_exp = case erlang:element(4, Query) of
        exec ->
            <<""/utf8>>;

        exec_result ->
            <<""/utf8>>;

        many ->
            <<Fn_name/binary, "_decoder()"/utf8>>;

        one ->
            <<Fn_name/binary, "_decoder()"/utf8>>
    end,
    Def_return = <<<<<<<<"#(sql, "/utf8, Def_return_params/binary>>/binary,
                ", "/utf8>>/binary,
            Def_exp/binary>>/binary,
        ")"/utf8>>,
    _pipe@4 = [<<Def_fn/binary, "{"/utf8>>,
        <<"  "/utf8, Def_sql/binary>>,
        <<"  "/utf8, Def_return/binary>>,
        <<"}"/utf8>>],
    gleam@string:join(_pipe@4, <<"\n"/utf8>>).

-file("src/parrot/internal/codegen.gleam", 273).
?DOC(false).
-spec gleam_type_to_decoder(gleam_type()) -> binary().
gleam_type_to_decoder(Gtype) ->
    case Gtype of
        gleam_int ->
            <<"decode.int"/utf8>>;

        gleam_string ->
            <<"decode.string"/utf8>>;

        gleam_bool ->
            <<"decode.bool"/utf8>>;

        gleam_float ->
            <<"decode.float"/utf8>>;

        gleam_timestamp ->
            <<"dev.datetime_decoder()"/utf8>>;

        gleam_bit_array ->
            <<"decode.bit_array"/utf8>>;

        {gleam_list, X} ->
            <<<<"decode.list(of: "/utf8, (gleam_type_to_decoder(X))/binary>>/binary,
                ")"/utf8>>;

        {gleam_enum, Name} ->
            Name@1 = parrot@internal@string_case:snake_case(Name),
            <<Name@1/binary, "_decoder()"/utf8>>;

        gleam_dynamic ->
            <<"decode.dynamic"/utf8>>
    end.

-file("src/parrot/internal/codegen.gleam", 290).
?DOC(false).
-spec gen_query_decoder(
    parrot@internal@sqlc:'query'(),
    parrot@internal@sqlc:s_q_l_c()
) -> binary().
gen_query_decoder(Query, Context) ->
    case erlang:length(erlang:element(6, Query)) of
        0 ->
            <<""/utf8>>;

        _ ->
            Type_name = parrot@internal@string_case:pascal_case(
                erlang:element(3, Query)
            ),
            Fn_name = <<(parrot@internal@string_case:snake_case(
                    erlang:element(3, Query)
                ))/binary,
                "_decoder"/utf8>>,
            Decoder_fields = begin
                _pipe = erlang:element(6, Query),
                _pipe@1 = gleam@list:index_map(
                    _pipe,
                    fun(Col, Index) ->
                        Col_type = sqlc_col_to_gleam(Col, Context),
                        Decoder_type = gleam_type_to_decoder(Col_type),
                        Decoder = case erlang:element(3, Col) of
                            true ->
                                Decoder_type;

                            false ->
                                <<<<"decode.optional("/utf8,
                                        Decoder_type/binary>>/binary,
                                    ")"/utf8>>
                        end,
                        Col_name = gen_column_name(Query, Col),
                        <<<<<<<<<<<<"  use "/utf8, Col_name/binary>>/binary,
                                            " <- decode.field("/utf8>>/binary,
                                        (erlang:integer_to_binary(Index))/binary>>/binary,
                                    ", "/utf8>>/binary,
                                Decoder/binary>>/binary,
                            ")"/utf8>>
                    end
                ),
                gleam@string:join(_pipe@1, <<"\n"/utf8>>)
            end,
            Constructor_args = begin
                _pipe@2 = erlang:element(6, Query),
                _pipe@3 = gleam@list:map(
                    _pipe@2,
                    fun(Col@1) ->
                        <<(gen_column_name(Query, Col@1))/binary, ": "/utf8>>
                    end
                ),
                gleam@string:join(_pipe@3, <<", "/utf8>>)
            end,
            Success_line = <<<<<<<<"  decode.success("/utf8, Type_name/binary>>/binary,
                        "("/utf8>>/binary,
                    Constructor_args/binary>>/binary,
                "))"/utf8>>,
            <<<<<<<<<<<<<<<<"\n\npub fn "/utf8, Fn_name/binary>>/binary,
                                        "() -> decode.Decoder("/utf8>>/binary,
                                    Type_name/binary>>/binary,
                                ") {\n"/utf8>>/binary,
                            Decoder_fields/binary>>/binary,
                        "\n"/utf8>>/binary,
                    Success_line/binary>>/binary,
                "\n}"/utf8>>
    end.

-file("src/parrot/internal/codegen.gleam", 56).
?DOC(false).
-spec gen_query(parrot@internal@sqlc:'query'(), parrot@internal@sqlc:s_q_l_c()) -> binary().
gen_query(Query, Context) ->
    Type_str = case erlang:length(erlang:element(6, Query)) of
        0 ->
            <<""/utf8>>;

        _ ->
            <<(gen_query_type(Query, Context))/binary, "\n\n"/utf8>>
    end,
    Func = gen_query_function(Query, Context),
    Deco = gen_query_decoder(Query, Context),
    <<<<Type_str/binary, Func/binary>>/binary, Deco/binary>>.

-file("src/parrot/internal/codegen.gleam", 480).
?DOC(false).
-spec comment_dont_edit() -> binary().
comment_dont_edit() ->
    _pipe = <<"
//// Code generated by parrot. DO NOT EDIT.
////
  "/utf8>>,
    gleam@string:trim(_pipe).

-file("src/parrot/internal/codegen.gleam", 340).
?DOC(false).
-spec gen_gleam_module(parrot@internal@sqlc:s_q_l_c()) -> binary().
gen_gleam_module(Context) ->
    Queries = begin
        _pipe = erlang:element(6, Context),
        _pipe@1 = gleam@list:map(
            _pipe,
            fun(_capture) -> gen_query(_capture, Context) end
        ),
        gleam@string:join(_pipe@1, <<"\n\n"/utf8>>)
    end,
    Uses_timestamp = gleam@list:any(
        erlang:element(6, Context),
        fun(Query) ->
            Col_ts = gleam@list:any(
                erlang:element(6, Query),
                fun(Col) -> case sqlc_col_to_gleam(Col, Context) of
                        gleam_timestamp ->
                            true;

                        _ ->
                            false
                    end end
            ),
            Param_ts = gleam@list:any(
                erlang:element(9, Query),
                fun(Param) ->
                    case sqlc_col_to_gleam(erlang:element(3, Param), Context) of
                        gleam_timestamp ->
                            true;

                        _ ->
                            false
                    end
                end
            ),
            gleam@bool:'or'(Col_ts, Param_ts)
        end
    ),
    Timestamp_import = case Uses_timestamp of
        false ->
            <<""/utf8>>;

        true ->
            <<"import gleam/time/timestamp.{type Timestamp}\n"/utf8>>
    end,
    Imports = <<<<<<<<<<"import gleam/dynamic/decode"/utf8, "\n"/utf8>>/binary,
                    "import gleam/option.{type Option}"/utf8>>/binary,
                "\n"/utf8>>/binary,
            Timestamp_import/binary>>/binary,
        "import parrot/dev"/utf8>>,
    Enums = begin
        _pipe@4 = gleam@list:flat_map(
            erlang:element(6, Context),
            fun(Query@1) ->
                Columns = gleam@list:filter_map(
                    erlang:element(6, Query@1),
                    fun(Col@1) -> case sqlc_col_to_gleam(Col@1, Context) of
                            {gleam_enum, _} ->
                                Type_ = normalise_col_type(Col@1),
                                Schema = find_col_schema(Col@1, Context),
                                Enum@1 = case begin
                                    _pipe@2 = erlang:element(5, Schema),
                                    gleam@list:find(
                                        _pipe@2,
                                        fun(E) ->
                                            erlang:element(2, E) =:= Type_
                                        end
                                    )
                                end of
                                    {ok, Enum} -> Enum;
                                    _assert_fail ->
                                        erlang:error(
                                                #{gleam_error => let_assert,
                                                    message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                    file => <<?FILEPATH/utf8>>,
                                                    module => <<"parrot/internal/codegen"/utf8>>,
                                                    function => <<"gen_gleam_module"/utf8>>,
                                                    line => 388,
                                                    value => _assert_fail,
                                                    start => 10072,
                                                    'end' => 10178,
                                                    pattern_start => 10083,
                                                    pattern_end => 10091}
                                            )
                                end,
                                {ok, Enum@1};

                            _ ->
                                {error, nil}
                        end end
                ),
                Params = gleam@list:filter_map(
                    erlang:element(9, Query@1),
                    fun(Param@1) ->
                        case sqlc_col_to_gleam(
                            erlang:element(3, Param@1),
                            Context
                        ) of
                            {gleam_enum, _} ->
                                Type_@1 = normalise_col_type(
                                    erlang:element(3, Param@1)
                                ),
                                Schema@1 = find_col_schema(
                                    erlang:element(3, Param@1),
                                    Context
                                ),
                                Enum@3 = case begin
                                    _pipe@3 = erlang:element(5, Schema@1),
                                    gleam@list:find(
                                        _pipe@3,
                                        fun(E@1) ->
                                            erlang:element(2, E@1) =:= Type_@1
                                        end
                                    )
                                end of
                                    {ok, Enum@2} -> Enum@2;
                                    _assert_fail@1 ->
                                        erlang:error(
                                                #{gleam_error => let_assert,
                                                    message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                    file => <<?FILEPATH/utf8>>,
                                                    module => <<"parrot/internal/codegen"/utf8>>,
                                                    function => <<"gen_gleam_module"/utf8>>,
                                                    line => 404,
                                                    value => _assert_fail@1,
                                                    start => 10565,
                                                    'end' => 10671,
                                                    pattern_start => 10576,
                                                    pattern_end => 10584}
                                            )
                                end,
                                {ok, Enum@3};

                            _ ->
                                {error, nil}
                        end
                    end
                ),
                lists:append(Columns, Params)
            end
        ),
        _pipe@5 = gleam@list:unique(_pipe@4),
        _pipe@6 = gleam@list:map(
            _pipe@5,
            fun(Enum@4) ->
                Record_name = parrot@internal@string_case:pascal_case(
                    erlang:element(2, Enum@4)
                ),
                Fn_name = parrot@internal@string_case:snake_case(
                    erlang:element(2, Enum@4)
                ),
                Values = gleam@list:map(
                    erlang:element(3, Enum@4),
                    fun(Val) ->
                        <<"  "/utf8,
                            (parrot@internal@string_case:pascal_case(Val))/binary>>
                    end
                ),
                To_str_vals = gleam@list:map(
                    erlang:element(3, Enum@4),
                    fun(Val@1) ->
                        Type_@2 = parrot@internal@string_case:pascal_case(Val@1),
                        <<<<<<<<<<"    "/utf8, Type_@2/binary>>/binary,
                                        " -> "/utf8>>/binary,
                                    "\""/utf8>>/binary,
                                Val@1/binary>>/binary,
                            "\""/utf8>>
                    end
                ),
                Decode_str_vals = gleam@list:map(
                    erlang:element(3, Enum@4),
                    fun(Val@2) ->
                        Type_@3 = parrot@internal@string_case:pascal_case(Val@2),
                        <<<<<<<<<<"    \""/utf8, Val@2/binary>>/binary,
                                        "\" -> "/utf8>>/binary,
                                    "decode.success("/utf8>>/binary,
                                Type_@3/binary>>/binary,
                            ")"/utf8>>
                    end
                ),
                First_value@1 = case gleam@list:first(erlang:element(3, Enum@4)) of
                    {ok, First_value} -> First_value;
                    _assert_fail@2 ->
                        erlang:error(#{gleam_error => let_assert,
                                    message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                    file => <<?FILEPATH/utf8>>,
                                    module => <<"parrot/internal/codegen"/utf8>>,
                                    function => <<"gen_gleam_module"/utf8>>,
                                    line => 436,
                                    value => _assert_fail@2,
                                    start => 11458,
                                    'end' => 11508,
                                    pattern_start => 11469,
                                    pattern_end => 11484})
                end,
                Zero_value = parrot@internal@string_case:pascal_case(
                    First_value@1
                ),
                <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"pub type "/utf8,
                                                                                                                        Record_name/binary>>/binary,
                                                                                                                    " {\n"/utf8>>/binary,
                                                                                                                (gleam@string:join(
                                                                                                                    Values,
                                                                                                                    <<"\n"/utf8>>
                                                                                                                ))/binary>>/binary,
                                                                                                            "\n}\n\n"/utf8>>/binary,
                                                                                                        "pub fn "/utf8>>/binary,
                                                                                                    Fn_name/binary>>/binary,
                                                                                                "_decoder() {\n"/utf8>>/binary,
                                                                                            "  use variant <- decode.then(decode.string)\n"/utf8>>/binary,
                                                                                        "  case variant {\n"/utf8>>/binary,
                                                                                    (gleam@string:join(
                                                                                        Decode_str_vals,
                                                                                        <<"\n"/utf8>>
                                                                                    ))/binary>>/binary,
                                                                                "\n    _ -> decode.failure("/utf8>>/binary,
                                                                            Zero_value/binary>>/binary,
                                                                        ", \""/utf8>>/binary,
                                                                    Record_name/binary>>/binary,
                                                                "\")\n"/utf8>>/binary,
                                                            "  }\n"/utf8>>/binary,
                                                        "}\n\n"/utf8>>/binary,
                                                    "pub fn "/utf8>>/binary,
                                                Fn_name/binary>>/binary,
                                            "_to_string(val: "/utf8>>/binary,
                                        Record_name/binary>>/binary,
                                    ") {\n"/utf8>>/binary,
                                "  case val {\n"/utf8>>/binary,
                            (gleam@string:join(To_str_vals, <<"\n"/utf8>>))/binary>>/binary,
                        "\n  }\n"/utf8>>/binary,
                    "}"/utf8>>
            end
        ),
        gleam@string:join(_pipe@6, <<"\n\n"/utf8>>)
    end,
    <<<<<<<<<<<<(comment_dont_edit())/binary, "\n\n"/utf8>>/binary,
                        Imports/binary>>/binary,
                    "\n\n"/utf8>>/binary,
                Enums/binary>>/binary,
            "\n\n"/utf8>>/binary,
        Queries/binary>>.

-file("src/parrot/internal/codegen.gleam", 22).
?DOC(false).
-spec codegen_from_config(parrot@internal@config:config()) -> {ok, codegen()} |
    {error, nil}.
codegen_from_config(Config) ->
    parrot@internal@lib:try_nil(
        parrot@internal@config:get_json_file(Config),
        fun(Json_string) ->
            parrot@internal@lib:try_nil(
                gleam@json:parse(
                    Json_string,
                    {decoder, fun gleam@dynamic@decode:decode_dynamic/1}
                ),
                fun(Dyn_json) ->
                    Context@1 = case parrot@internal@sqlc:decode_sqlc(Dyn_json) of
                        {ok, Context} -> Context;
                        _assert_fail ->
                            erlang:error(#{gleam_error => let_assert,
                                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                        file => <<?FILEPATH/utf8>>,
                                        module => <<"parrot/internal/codegen"/utf8>>,
                                        function => <<"codegen_from_config"/utf8>>,
                                        line => 27,
                                        value => _assert_fail,
                                        start => 670,
                                        'end' => 721,
                                        pattern_start => 681,
                                        pattern_end => 692})
                    end,
                    Unknowns = begin
                        _pipe = gleam@list:flat_map(
                            erlang:element(6, Context@1),
                            fun(Query) ->
                                gleam@list:map(
                                    erlang:element(6, Query),
                                    fun(Col) ->
                                        case sqlc_col_to_gleam(Col, Context@1) of
                                            gleam_dynamic ->
                                                {some,
                                                    erlang:element(
                                                        4,
                                                        erlang:element(16, Col)
                                                    )};

                                            _ ->
                                                none
                                        end
                                    end
                                )
                            end
                        ),
                        _pipe@1 = gleam@list:filter(
                            _pipe,
                            fun gleam@option:is_some/1
                        ),
                        gleam@list:map(
                            _pipe@1,
                            fun(_capture) ->
                                gleam@option:unwrap(_capture, <<""/utf8>>)
                            end
                        )
                    end,
                    Module_contents = gen_gleam_module(Context@1),
                    _ = begin
                        _pipe@2 = parrot@internal@config:get_module_directory(
                            Config
                        ),
                        simplifile:create_directory_all(_pipe@2)
                    end,
                    _ = simplifile:write(
                        parrot@internal@config:get_module_path(Config),
                        Module_contents
                    ),
                    {ok, {codegen, Unknowns}}
                end
            )
        end
    ).