-module(oaspec@internal@codegen@allof_merge).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/oaspec/internal/codegen/allof_merge.gleam").
-export([merge_allof_schemas/2]).
-export_type([merged_all_of/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 merged_all_of() :: {merged_all_of,
        gleam@dict:dict(binary(), oaspec@internal@openapi@schema:schema_ref()),
        list(binary()),
        oaspec@internal@openapi@schema:additional_properties()}.

-file("src/oaspec/internal/codegen/allof_merge.gleam", 22).
?DOC(false).
-spec merge_allof_schemas(
    list(oaspec@internal@openapi@schema:schema_ref()),
    oaspec@internal@codegen@context:context()
) -> merged_all_of().
merge_allof_schemas(Schemas, Ctx) ->
    gleam@list:index_fold(
        Schemas,
        {merged_all_of, maps:new(), [], unspecified},
        fun(Acc, S_ref, Idx) ->
            Resolved = oaspec@internal@codegen@context:resolve_schema_ref(
                S_ref,
                Ctx
            ),
            case Resolved of
                {ok,
                    {object_schema,
                        _,
                        Properties,
                        Required,
                        Additional_properties,
                        _,
                        _}} ->
                    Merged_ap = case {Additional_properties,
                        erlang:element(4, Acc)} of
                        {{typed, X}, _} ->
                            {typed, X};

                        {_, {typed, X@1}} ->
                            {typed, X@1};

                        {untyped, _} ->
                            untyped;

                        {_, untyped} ->
                            untyped;

                        {forbidden, _} ->
                            forbidden;

                        {_, forbidden} ->
                            forbidden;

                        {unspecified, unspecified} ->
                            unspecified
                    end,
                    {merged_all_of,
                        maps:merge(erlang:element(2, Acc), Properties),
                        lists:append(erlang:element(3, Acc), Required),
                        Merged_ap};

                {ok, Schema_obj} ->
                    Field_name = case Idx of
                        0 ->
                            <<"value"/utf8>>;

                        N ->
                            <<"value_"/utf8,
                                (erlang:integer_to_binary(N))/binary>>
                    end,
                    {merged_all_of,
                        gleam@dict:insert(
                            erlang:element(2, Acc),
                            Field_name,
                            {inline, Schema_obj}
                        ),
                        [Field_name | erlang:element(3, Acc)],
                        erlang:element(4, Acc)};

                _ ->
                    Acc
            end
        end
    ).