-module(oaspec@internal@openapi@dedup).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/oaspec/internal/openapi/dedup.gleam").
-export([dedup_property_names/1, dedup_param_field_names/1, dedup_enum_variants/1, dedup/1]).

-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).

-file("src/oaspec/internal/openapi/dedup.gleam", 167).
?DOC(false).
-spec next_unique_name(
    binary(),
    gleam@dict:dict(binary(), boolean()),
    gleam@dict:dict(binary(), boolean()),
    integer()
) -> binary().
next_unique_name(Base, Input_names, Claimed, Suffix) ->
    Candidate = <<<<Base/binary, "_"/utf8>>/binary,
        (erlang:integer_to_binary(Suffix))/binary>>,
    case gleam@dict:has_key(Input_names, Candidate) orelse gleam@dict:has_key(
        Claimed,
        Candidate
    ) of
        true ->
            next_unique_name(Base, Input_names, Claimed, Suffix + 1);

        false ->
            Candidate
    end.

-file("src/oaspec/internal/openapi/dedup.gleam", 148).
?DOC(false).
-spec deduplicate_strings(list(binary())) -> list(binary()).
deduplicate_strings(Names) ->
    Input_names = gleam@list:fold(
        Names,
        maps:new(),
        fun(Acc, Name) -> gleam@dict:insert(Acc, Name, true) end
    ),
    {Result_rev, _} = gleam@list:fold(
        Names,
        {[], maps:new()},
        fun(Acc@1, Name@1) ->
            {Result, Claimed} = Acc@1,
            case gleam@dict:has_key(Claimed, Name@1) of
                false ->
                    {[Name@1 | Result],
                        gleam@dict:insert(Claimed, Name@1, true)};

                true ->
                    Unique_name = next_unique_name(
                        Name@1,
                        Input_names,
                        Claimed,
                        2
                    ),
                    {[Unique_name | Result],
                        gleam@dict:insert(Claimed, Unique_name, true)}
            end
        end
    ),
    lists:reverse(Result_rev).

-file("src/oaspec/internal/openapi/dedup.gleam", 101).
?DOC(false).
-spec dedup_property_names(list(binary())) -> list(binary()).
dedup_property_names(Prop_names) ->
    Snake_names = gleam@list:map(
        Prop_names,
        fun oaspec@internal@util@naming:to_snake_case/1
    ),
    deduplicate_strings(Snake_names).

-file("src/oaspec/internal/openapi/dedup.gleam", 117).
?DOC(false).
-spec dedup_param_field_names(
    list(oaspec@internal@openapi@spec:parameter(any()))
) -> list(binary()).
dedup_param_field_names(Params) ->
    Snake_names = gleam@list:map(
        Params,
        fun(P) ->
            oaspec@internal@util@naming:to_snake_case(erlang:element(2, P))
        end
    ),
    Reserved = [<<"body"/utf8>>,
        <<"path"/utf8>>,
        <<"query"/utf8>>,
        <<"headers"/utf8>>],
    With_reserved = lists:append(Reserved, Snake_names),
    case deduplicate_strings(With_reserved) of
        [_, _, _, _ | Rest] ->
            Rest;

        _ ->
            []
    end.

-file("src/oaspec/internal/openapi/dedup.gleam", 137).
?DOC(false).
-spec dedup_enum_variants(list(binary())) -> list(binary()).
dedup_enum_variants(Enum_values) ->
    Pascal_names = gleam@list:map(
        Enum_values,
        fun oaspec@internal@util@naming:to_pascal_case/1
    ),
    deduplicate_strings(Pascal_names).

-file("src/oaspec/internal/openapi/dedup.gleam", 53).
?DOC(false).
-spec dedup_schema_object(oaspec@internal@openapi@schema:schema_object()) -> oaspec@internal@openapi@schema:schema_object().
dedup_schema_object(Schema_obj) ->
    case Schema_obj of
        {object_schema, _, Properties, _, Additional_properties, _, _} = Obj ->
            New_props = begin
                _pipe = maps:to_list(Properties),
                _pipe@1 = gleam@list:map(
                    _pipe,
                    fun(Entry) ->
                        {Name, Prop_ref} = Entry,
                        {Name, dedup_schema_ref(Prop_ref)}
                    end
                ),
                maps:from_list(_pipe@1)
            end,
            {object_schema,
                erlang:element(2, Obj),
                New_props,
                erlang:element(4, Obj),
                case Additional_properties of
                    {typed, Ap} ->
                        {typed, dedup_schema_ref(Ap)};

                    forbidden ->
                        forbidden;

                    untyped ->
                        untyped;

                    unspecified ->
                        unspecified
                end,
                erlang:element(6, Obj),
                erlang:element(7, Obj)};

        {one_of_schema, Metadata, Schemas, Discriminator} ->
            {one_of_schema,
                Metadata,
                gleam@list:map(Schemas, fun dedup_schema_ref/1),
                Discriminator};

        {any_of_schema, Metadata@1, Schemas@1, Discriminator@1} ->
            {any_of_schema,
                Metadata@1,
                gleam@list:map(Schemas@1, fun dedup_schema_ref/1),
                Discriminator@1};

        _ ->
            Schema_obj
    end.

-file("src/oaspec/internal/openapi/dedup.gleam", 46).
?DOC(false).
-spec dedup_schema_ref(oaspec@internal@openapi@schema:schema_ref()) -> oaspec@internal@openapi@schema:schema_ref().
dedup_schema_ref(Schema_ref) ->
    case Schema_ref of
        {reference, _, _} ->
            Schema_ref;

        {inline, Schema_obj} ->
            {inline, dedup_schema_object(Schema_obj)}
    end.

-file("src/oaspec/internal/openapi/dedup.gleam", 27).
?DOC(false).
-spec dedup_schemas(oaspec@internal@openapi@spec:open_api_spec(JBB)) -> oaspec@internal@openapi@spec:open_api_spec(JBB).
dedup_schemas(Spec) ->
    case erlang:element(5, Spec) of
        none ->
            Spec;

        {some, Components} ->
            New_schemas = begin
                _pipe = maps:to_list(erlang:element(2, Components)),
                _pipe@1 = gleam@list:map(
                    _pipe,
                    fun(Entry) ->
                        {Name, Schema_ref} = Entry,
                        {Name, dedup_schema_ref(Schema_ref)}
                    end
                ),
                maps:from_list(_pipe@1)
            end,
            {open_api_spec,
                erlang:element(2, Spec),
                erlang:element(3, Spec),
                erlang:element(4, Spec),
                {some,
                    {components,
                        New_schemas,
                        erlang:element(3, Components),
                        erlang:element(4, Components),
                        erlang:element(5, Components),
                        erlang:element(6, Components),
                        erlang:element(7, Components),
                        erlang:element(8, Components),
                        erlang:element(9, Components),
                        erlang:element(10, Components),
                        erlang:element(11, Components)}},
                erlang:element(6, Spec),
                erlang:element(7, Spec),
                erlang:element(8, Spec),
                erlang:element(9, Spec),
                erlang:element(10, Spec),
                erlang:element(11, Spec)}
    end.

-file("src/oaspec/internal/openapi/dedup.gleam", 21).
?DOC(false).
-spec dedup(oaspec@internal@openapi@spec:open_api_spec(JAY)) -> oaspec@internal@openapi@spec:open_api_spec(JAY).
dedup(Spec) ->
    _pipe = Spec,
    dedup_schemas(_pipe).