-module(oaspec@internal@codegen@client_ir).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/oaspec/internal/codegen/client_ir.gleam").
-export([imports/2, analyze/1]).
-export_type([client_requirements/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 client_requirements() :: {client_requirements,
        boolean(),
        boolean(),
        boolean(),
        boolean(),
        boolean(),
        boolean(),
        boolean(),
        boolean(),
        boolean(),
        boolean(),
        boolean(),
        boolean(),
        boolean(),
        boolean(),
        boolean(),
        boolean(),
        boolean(),
        boolean()}.

-file("src/oaspec/internal/codegen/client_ir.gleam", 288).
?DOC(false).
-spec option_import(client_requirements()) -> gleam@option:option(binary()).
option_import(Requirements) ->
    case {erlang:element(12, Requirements),
        erlang:element(13, Requirements),
        erlang:element(14, Requirements)} of
        {true, _, _} ->
            {some, <<"gleam/option.{type Option, None, Some}"/utf8>>};

        {false, true, true} ->
            {some, <<"gleam/option.{None, Some}"/utf8>>};

        {false, true, false} ->
            {some, <<"gleam/option.{Some}"/utf8>>};

        {false, false, true} ->
            {some, <<"gleam/option.{None}"/utf8>>};

        {false, false, false} ->
            none
    end.

-file("src/oaspec/internal/codegen/client_ir.gleam", 303).
?DOC(false).
-spec imports(client_requirements(), oaspec@internal@codegen@context:context()) -> list(binary()).
imports(Requirements, Ctx) ->
    Base_imports = [<<"gleam/result"/utf8>>,
        <<"oaspec/transport"/utf8>>,
        <<(oaspec@config:package(oaspec@internal@codegen@context:config(Ctx)))/binary,
            "/decode"/utf8>>,
        <<(oaspec@config:package(oaspec@internal@codegen@context:config(Ctx)))/binary,
            "/response_types"/utf8>>],
    Base_imports@1 = case erlang:element(15, Requirements) of
        true ->
            [<<"gleam/int"/utf8>> | Base_imports];

        false ->
            Base_imports
    end,
    Base_imports@2 = case option_import(Requirements) of
        {some, Import_line} ->
            [Import_line | Base_imports@1];

        none ->
            Base_imports@1
    end,
    Base_imports@3 = case erlang:element(11, Requirements) of
        true ->
            lists:append(
                [<<(oaspec@config:package(
                            oaspec@internal@codegen@context:config(Ctx)
                        ))/binary,
                        "/types"/utf8>>,
                    <<(oaspec@config:package(
                            oaspec@internal@codegen@context:config(Ctx)
                        ))/binary,
                        "/encode"/utf8>>],
                Base_imports@2
            );

        false ->
            Base_imports@2
    end,
    Base_imports@4 = [<<(oaspec@config:package(
                oaspec@internal@codegen@context:config(Ctx)
            ))/binary,
            "/request_types"/utf8>> |
        Base_imports@3],
    Base_imports@5 = case erlang:element(10, Requirements) of
        true ->
            [<<"gleam/string"/utf8>> | Base_imports@4];

        false ->
            Base_imports@4
    end,
    Imports = case erlang:element(8, Requirements) of
        true ->
            [<<"gleam/dynamic/decode as dyn_decode"/utf8>> | Base_imports@5];

        false ->
            Base_imports@5
    end,
    Imports@1 = case erlang:element(9, Requirements) of
        true ->
            [<<"gleam/json"/utf8>> | Imports];

        false ->
            Imports
    end,
    Imports@2 = case erlang:element(2, Requirements) of
        true ->
            [<<"gleam/bool"/utf8>> | Imports@1];

        false ->
            Imports@1
    end,
    Imports@3 = case erlang:element(3, Requirements) of
        true ->
            [<<"gleam/float"/utf8>> | Imports@2];

        false ->
            Imports@2
    end,
    Imports@4 = case erlang:element(7, Requirements) of
        true ->
            [<<"gleam/list"/utf8>> | Imports@3];

        false ->
            Imports@3
    end,
    Imports@5 = case erlang:element(18, Requirements) of
        true ->
            [<<"gleam/uri"/utf8>> | Imports@4];

        false ->
            Imports@4
    end,
    case erlang:element(19, Requirements) of
        true ->
            [<<(oaspec@config:package(
                        oaspec@internal@codegen@context:config(Ctx)
                    ))/binary,
                    "/guards"/utf8>> |
                Imports@5];

        false ->
            Imports@5
    end.

-file("src/oaspec/internal/codegen/client_ir.gleam", 367).
?DOC(false).
-spec any_operation_has_server(oaspec@internal@codegen@context:context()) -> boolean().
any_operation_has_server(Ctx) ->
    gleam@list:any(
        oaspec@internal@codegen@context:operations(Ctx),
        fun(Op) ->
            {_, Operation, _, _} = Op,
            case erlang:element(12, Operation) of
                [] ->
                    case erlang:element(
                        6,
                        oaspec@internal@codegen@context:spec(Ctx)
                    ) of
                        [] ->
                            false;

                        _ ->
                            true
                    end;

                _ ->
                    true
            end
        end
    ).

-file("src/oaspec/internal/codegen/client_ir.gleam", 381).
?DOC(false).
-spec any_operation_has_no_server(oaspec@internal@codegen@context:context()) -> boolean().
any_operation_has_no_server(Ctx) ->
    gleam@list:any(
        oaspec@internal@codegen@context:operations(Ctx),
        fun(Op) ->
            {_, Operation, _, _} = Op,
            case erlang:element(12, Operation) of
                [] ->
                    case erlang:element(
                        6,
                        oaspec@internal@codegen@context:spec(Ctx)
                    ) of
                        [] ->
                            true;

                        _ ->
                            false
                    end;

                _ ->
                    false
            end
        end
    ).

-file("src/oaspec/internal/codegen/client_ir.gleam", 37).
?DOC(false).
-spec analyze(oaspec@internal@codegen@context:context()) -> client_requirements().
analyze(Ctx) ->
    Operations = oaspec@internal@codegen@context:operations(Ctx),
    All_params = gleam@list:flat_map(
        Operations,
        fun(Op) ->
            {_, Operation, _, _} = Op,
            gleam@list:filter_map(
                erlang:element(6, Operation),
                fun(Ref_p) -> case Ref_p of
                        {value, P} ->
                            {ok, P};

                        _ ->
                            {error, nil}
                    end end
            )
        end
    ),
    Needs_bool = gleam@list:any(
        All_params,
        fun(P@1) -> case erlang:element(6, P@1) of
                {parameter_schema, {inline, {boolean_schema, _}}} ->
                    true;

                _ ->
                    false
            end end
    ),
    Needs_float = gleam@list:any(
        All_params,
        fun(P@2) -> case erlang:element(6, P@2) of
                {parameter_schema,
                    {inline, {number_schema, _, _, _, _, _, _, _}}} ->
                    true;

                _ ->
                    false
            end end
    ),
    Has_multi_content_response = gleam@list:any(
        Operations,
        fun(Op@1) ->
            {_, Operation@1, _, _} = Op@1,
            gleam@list:any(
                maps:to_list(erlang:element(8, Operation@1)),
                fun(Entry) ->
                    {_, Ref_or} = Entry,
                    case Ref_or of
                        {value, Response} ->
                            erlang:length(
                                maps:to_list(erlang:element(3, Response))
                            )
                            > 1;

                        _ ->
                            false
                    end
                end
            )
        end
    ),
    Has_form_urlencoded = gleam@list:any(
        Operations,
        fun(Op@2) ->
            {_, Operation@2, _, _} = Op@2,
            case erlang:element(7, Operation@2) of
                {some, {value, Rb}} ->
                    gleam@list:any(
                        maps:to_list(erlang:element(3, Rb)),
                        fun(Ce) ->
                            {Key, _} = Ce,
                            Key =:= <<"application/x-www-form-urlencoded"/utf8>>
                        end
                    );

                _ ->
                    false
            end
        end
    ),
    Has_multipart = gleam@list:any(
        Operations,
        fun(Op@3) ->
            {_, Operation@3, _, _} = Op@3,
            case erlang:element(7, Operation@3) of
                {some, {value, Rb@1}} ->
                    gleam@list:any(
                        maps:to_list(erlang:element(3, Rb@1)),
                        fun(Ce@1) ->
                            {Key@1, _} = Ce@1,
                            Key@1 =:= <<"multipart/form-data"/utf8>>
                        end
                    );

                _ ->
                    false
            end
        end
    ),
    Needs_list = ((((Has_form_urlencoded orelse Has_multi_content_response)
    orelse gleam@list:any(
        All_params,
        fun(P@3) -> erlang:element(3, P@3) =:= in_query end
    ))
    orelse gleam@list:any(
        All_params,
        fun(P@4) -> erlang:element(3, P@4) =:= in_cookie end
    ))
    orelse gleam@list:any(
        All_params,
        fun(P@5) -> erlang:element(3, P@5) =:= in_header end
    ))
    orelse gleam@list:any(All_params, fun(P@6) -> case erlang:element(6, P@6) of
                {parameter_schema, {inline, {array_schema, _, _, _, _, _}}} ->
                    true;

                {parameter_schema, {reference, _, _} = Sr} ->
                    case oaspec@internal@codegen@context:resolve_schema_ref(
                        Sr,
                        Ctx
                    ) of
                        {ok, {array_schema, _, _, _, _, _}} ->
                            true;

                        _ ->
                            false
                    end;

                _ ->
                    false
            end end),
    Needs_dyn_decode = gleam@list:any(
        Operations,
        fun(Op@4) ->
            {_, Operation@4, _, _} = Op@4,
            gleam@list:any(
                maps:to_list(erlang:element(8, Operation@4)),
                fun(Entry@1) ->
                    {_, Ref_or@1} = Entry@1,
                    case Ref_or@1 of
                        {value, Response@1} ->
                            gleam@list:any(
                                maps:to_list(erlang:element(3, Response@1)),
                                fun(Ce@2) ->
                                    {Media_type_name, Mt} = Ce@2,
                                    case Media_type_name of
                                        <<"text/plain"/utf8>> ->
                                            false;

                                        _ ->
                                            case erlang:element(2, Mt) of
                                                {some,
                                                    {inline,
                                                        {array_schema,
                                                            _,
                                                            {inline, _},
                                                            _,
                                                            _,
                                                            _}}} ->
                                                    true;

                                                {some,
                                                    {inline,
                                                        {string_schema,
                                                            _,
                                                            _,
                                                            _,
                                                            _,
                                                            _,
                                                            _}}} ->
                                                    true;

                                                {some,
                                                    {inline,
                                                        {integer_schema,
                                                            _,
                                                            _,
                                                            _,
                                                            _,
                                                            _,
                                                            _,
                                                            _}}} ->
                                                    true;

                                                {some,
                                                    {inline,
                                                        {number_schema,
                                                            _,
                                                            _,
                                                            _,
                                                            _,
                                                            _,
                                                            _,
                                                            _}}} ->
                                                    true;

                                                {some,
                                                    {inline,
                                                        {boolean_schema, _}}} ->
                                                    true;

                                                _ ->
                                                    false
                                            end
                                    end
                                end
                            );

                        _ ->
                            false
                    end
                end
            )
        end
    ),
    Needs_json = Needs_dyn_decode orelse gleam@list:any(
        Operations,
        fun(Op@5) ->
            {_, Operation@5, _, _} = Op@5,
            case erlang:element(7, Operation@5) of
                {some, {value, Rb@2}} ->
                    gleam@list:any(
                        maps:to_list(erlang:element(3, Rb@2)),
                        fun(Ce@3) ->
                            {_, Mt@1} = Ce@3,
                            case erlang:element(2, Mt@1) of
                                {some,
                                    {inline, {string_schema, _, _, _, _, _, _}}} ->
                                    true;

                                {some,
                                    {inline,
                                        {integer_schema, _, _, _, _, _, _, _}}} ->
                                    true;

                                {some,
                                    {inline,
                                        {number_schema, _, _, _, _, _, _, _}}} ->
                                    true;

                                {some, {inline, {boolean_schema, _}}} ->
                                    true;

                                _ ->
                                    false
                            end
                        end
                    );

                _ ->
                    false
            end
        end
    ),
    Needs_string = ((Has_multi_content_response orelse Has_form_urlencoded)
    orelse Has_multipart)
    orelse gleam@list:any(
        All_params,
        fun(P@7) ->
            (erlang:element(3, P@7) =:= in_path) orelse (erlang:element(3, P@7)
            =:= in_cookie)
        end
    ),
    Needs_typed_schemas = oaspec@internal@codegen@import_analysis:operations_need_typed_schemas(
        Operations
    ),
    Needs_option_type = oaspec@internal@codegen@import_analysis:operations_have_optional_params(
        Operations
    )
    orelse oaspec@internal@codegen@import_analysis:operations_have_optional_body(
        Operations
    ),
    Needs_some_ctor = Needs_option_type orelse any_operation_has_server(Ctx),
    Needs_none_ctor = Needs_option_type orelse any_operation_has_no_server(Ctx),
    Needs_int = gleam@list:any(
        All_params,
        fun(P@8) -> case erlang:element(6, P@8) of
                {parameter_schema,
                    {inline, {integer_schema, _, _, _, _, _, _, _}}} ->
                    true;

                {parameter_schema,
                    {inline,
                        {array_schema,
                            _,
                            {inline, {integer_schema, _, _, _, _, _, _, _}},
                            _,
                            _,
                            _}}} ->
                    true;

                {parameter_schema, {reference, _, _} = Sr@1} ->
                    case oaspec@internal@codegen@context:resolve_schema_ref(
                        Sr@1,
                        Ctx
                    ) of
                        {ok, {integer_schema, _, _, _, _, _, _, _}} ->
                            true;

                        {ok,
                            {array_schema,
                                _,
                                {inline, {integer_schema, _, _, _, _, _, _, _}},
                                _,
                                _,
                                _}} ->
                            true;

                        _ ->
                            false
                    end;

                _ ->
                    false
            end end
    ),
    Needs_bytes_helper = gleam@list:any(
        Operations,
        fun(Op@6) ->
            {_, Operation@6, _, _} = Op@6,
            gleam@list:any(
                maps:to_list(erlang:element(8, Operation@6)),
                fun(Entry@2) ->
                    {_, Ref_or@2} = Entry@2,
                    case Ref_or@2 of
                        {value, Response@2} ->
                            gleam@list:any(
                                maps:to_list(erlang:element(3, Response@2)),
                                fun(Ce@4) ->
                                    {Name, _} = Ce@4,
                                    oaspec@internal@util@content_type:from_string(
                                        Name
                                    )
                                    =:= application_octet_stream
                                end
                            );

                        _ ->
                            false
                    end
                end
            )
        end
    ),
    Needs_text_helper = gleam@list:any(
        Operations,
        fun(Op@7) ->
            {_, Operation@7, _, _} = Op@7,
            gleam@list:any(
                maps:to_list(erlang:element(8, Operation@7)),
                fun(Entry@3) ->
                    {_, Ref_or@3} = Entry@3,
                    case Ref_or@3 of
                        {value, Response@3} ->
                            gleam@list:any(
                                maps:to_list(erlang:element(3, Response@3)),
                                fun(Ce@5) ->
                                    {_, Mt@2} = Ce@5,
                                    case erlang:element(2, Mt@2) of
                                        {some, _} ->
                                            true;

                                        none ->
                                            false
                                    end
                                end
                            );

                        _ ->
                            false
                    end
                end
            )
        end
    ),
    Needs_uri = Has_form_urlencoded orelse gleam@list:any(
        All_params,
        fun(P@9) ->
            (erlang:element(3, P@9) =:= in_path) orelse (erlang:element(3, P@9)
            =:= in_cookie)
        end
    ),
    Needs_guards = oaspec@config:validate(
        oaspec@internal@codegen@context:config(Ctx)
    )
    andalso gleam@list:any(
        Operations,
        fun(Op@8) ->
            {_, Operation@8, _, _} = Op@8,
            case erlang:element(7, Operation@8) of
                {some, {value, Rb@3}} ->
                    Content_entries = maps:to_list(erlang:element(3, Rb@3)),
                    case Content_entries of
                        [{_, Mt@3}] ->
                            case erlang:element(2, Mt@3) of
                                {some, {reference, _, Name@1}} ->
                                    oaspec@internal@codegen@guards:schema_has_validator(
                                        Name@1,
                                        Ctx
                                    );

                                _ ->
                                    false
                            end;

                        _ ->
                            false
                    end;

                _ ->
                    false
            end
        end
    ),
    {client_requirements,
        Needs_bool,
        Needs_float,
        Has_multi_content_response,
        Has_form_urlencoded,
        Has_multipart,
        Needs_list,
        Needs_dyn_decode,
        Needs_json,
        Needs_string,
        Needs_typed_schemas,
        Needs_option_type,
        Needs_some_ctor,
        Needs_none_ctor,
        Needs_int,
        Needs_bytes_helper,
        Needs_text_helper,
        Needs_uri,
        Needs_guards}.