-module(oaspec@openapi@operations).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/oaspec/openapi/operations.gleam").
-export([collect_operations/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.

-file("src/oaspec/openapi/operations.gleam", 11).
?DOC(
    " Collect all operations from the spec with their IDs, paths, and methods.\n"
    " Handles path-level parameter inheritance, security inheritance, and\n"
    " operationId generation from method + path when not specified.\n"
).
-spec collect_operations(oaspec@codegen@context:context()) -> list({binary(),
    oaspec@openapi@spec:operation(oaspec@openapi@spec:resolved()),
    binary(),
    oaspec@openapi@spec:http_method()}).
collect_operations(Ctx) ->
    Paths = gleam@list:sort(
        maps:to_list(erlang:element(4, oaspec@codegen@context:spec(Ctx))),
        fun(A, B) ->
            gleam@string:compare(erlang:element(1, A), erlang:element(1, B))
        end
    ),
    gleam@list:flat_map(
        Paths,
        fun(Entry) ->
            {Path, Ref_or} = Entry,
            Path_item = oaspec@openapi@spec:unwrap_ref(Ref_or),
            begin
                Ops = [{erlang:element(4, Path_item), get},
                    {erlang:element(5, Path_item), post},
                    {erlang:element(6, Path_item), put},
                    {erlang:element(7, Path_item), delete},
                    {erlang:element(8, Path_item), patch},
                    {erlang:element(9, Path_item), head},
                    {erlang:element(10, Path_item), options},
                    {erlang:element(11, Path_item), trace}],
                gleam@list:filter_map(
                    Ops,
                    fun(Op_entry) ->
                        {Maybe_op, Method} = Op_entry,
                        case Maybe_op of
                            {some, Operation} ->
                                Op_param_keys = gleam@list:map(
                                    erlang:element(6, Operation),
                                    fun(Ref_p) ->
                                        Parameter = oaspec@openapi@spec:unwrap_ref(
                                            Ref_p
                                        ),
                                        {erlang:element(2, Parameter),
                                            erlang:element(3, Parameter)}
                                    end
                                ),
                                Inherited_params = gleam@list:filter(
                                    erlang:element(12, Path_item),
                                    fun(Ref_p@1) ->
                                        Parameter@1 = oaspec@openapi@spec:unwrap_ref(
                                            Ref_p@1
                                        ),
                                        not gleam@list:contains(
                                            Op_param_keys,
                                            {erlang:element(2, Parameter@1),
                                                erlang:element(3, Parameter@1)}
                                        )
                                    end
                                ),
                                Merged_params = lists:append(
                                    Inherited_params,
                                    erlang:element(6, Operation)
                                ),
                                Effective_security = case erlang:element(
                                    10,
                                    Operation
                                ) of
                                    {some, Sec} ->
                                        Sec;

                                    none ->
                                        erlang:element(
                                            7,
                                            oaspec@codegen@context:spec(Ctx)
                                        )
                                end,
                                Effective_servers = case erlang:element(
                                    12,
                                    Operation
                                ) of
                                    [_ | _] ->
                                        erlang:element(12, Operation);

                                    [] ->
                                        erlang:element(13, Path_item)
                                end,
                                Operation@1 = {operation,
                                    erlang:element(2, Operation),
                                    erlang:element(3, Operation),
                                    erlang:element(4, Operation),
                                    erlang:element(5, Operation),
                                    Merged_params,
                                    erlang:element(7, Operation),
                                    erlang:element(8, Operation),
                                    erlang:element(9, Operation),
                                    {some, Effective_security},
                                    erlang:element(11, Operation),
                                    Effective_servers,
                                    erlang:element(13, Operation)},
                                Op_id = case erlang:element(2, Operation@1) of
                                    {some, Id} ->
                                        Id;

                                    none ->
                                        <<<<(oaspec@openapi@spec:method_to_lower(
                                                    Method
                                                ))/binary,
                                                "_"/utf8>>/binary,
                                            (begin
                                                _pipe = gleam@string:replace(
                                                    Path,
                                                    <<"/"/utf8>>,
                                                    <<"_"/utf8>>
                                                ),
                                                _pipe@1 = gleam@string:replace(
                                                    _pipe,
                                                    <<"{"/utf8>>,
                                                    <<""/utf8>>
                                                ),
                                                gleam@string:replace(
                                                    _pipe@1,
                                                    <<"}"/utf8>>,
                                                    <<""/utf8>>
                                                )
                                            end)/binary>>
                                end,
                                {ok, {Op_id, Operation@1, Path, Method}};

                            none ->
                                {error, nil}
                        end
                    end
                )
            end
        end
    ).