-module(atproto_openapi@paths).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/atproto_openapi/paths.gleam").
-export([path_for/1, query_path_item/2, procedure_path_item/2]).

-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/atproto_openapi/paths.gleam", 28).
?DOC(false).
-spec 'maybe'(
    binary(),
    gleam@option:option(ISK),
    fun((ISK) -> gleam@json:json())
) -> list({binary(), gleam@json:json()}).
'maybe'(Key, Value, To_json) ->
    case Value of
        {some, V} ->
            [{Key, To_json(V)}];

        none ->
            []
    end.

-file("src/atproto_openapi/paths.gleam", 39).
?DOC(false).
-spec non_empty_json(binary(), list(gleam@json:json())) -> list({binary(),
    gleam@json:json()}).
non_empty_json(Key, Values) ->
    case Values of
        [] ->
            [];

        _ ->
            [{Key, gleam@json:preprocessed_array(Values)}]
    end.

-file("src/atproto_openapi/paths.gleam", 49).
?DOC(false).
-spec path_for(binary()) -> binary().
path_for(Nsid) ->
    <<"/xrpc/"/utf8, Nsid/binary>>.

-file("src/atproto_openapi/paths.gleam", 267).
?DOC(false).
-spec error_envelope_schema(list(atproto_lexicon@ast:lexicon_error())) -> gleam@json:json().
error_envelope_schema(Errors) ->
    Names = gleam@list:map(Errors, fun(E) -> erlang:element(2, E) end),
    gleam@json:object(
        [{<<"type"/utf8>>, gleam@json:string(<<"object"/utf8>>)},
            {<<"properties"/utf8>>,
                gleam@json:object(
                    [{<<"error"/utf8>>,
                            gleam@json:object(
                                [{<<"type"/utf8>>,
                                        gleam@json:string(<<"string"/utf8>>)},
                                    {<<"enum"/utf8>>,
                                        gleam@json:array(
                                            Names,
                                            fun gleam@json:string/1
                                        )}]
                            )},
                        {<<"message"/utf8>>,
                            gleam@json:object(
                                [{<<"type"/utf8>>,
                                        gleam@json:string(<<"string"/utf8>>)}]
                            )}]
                )}]
    ).

-file("src/atproto_openapi/paths.gleam", 256).
?DOC(false).
-spec errors_description(list(atproto_lexicon@ast:lexicon_error())) -> binary().
errors_description(Errors) ->
    _pipe = Errors,
    _pipe@1 = gleam@list:map(_pipe, fun(E) -> case erlang:element(3, E) of
                {some, D} ->
                    <<<<(erlang:element(2, E))/binary, ": "/utf8>>/binary,
                        D/binary>>;

                none ->
                    erlang:element(2, E)
            end end),
    gleam@string:join(_pipe@1, <<"\n"/utf8>>).

-file("src/atproto_openapi/paths.gleam", 235).
?DOC(false).
-spec error_response_json(list(atproto_lexicon@ast:lexicon_error())) -> gleam@option:option(gleam@json:json()).
error_response_json(Errors) ->
    case Errors of
        [] ->
            none;

        _ ->
            {some,
                gleam@json:object(
                    [{<<"description"/utf8>>,
                            gleam@json:string(errors_description(Errors))},
                        {<<"content"/utf8>>,
                            gleam@json:object(
                                [{<<"application/json"/utf8>>,
                                        gleam@json:object(
                                            [{<<"schema"/utf8>>,
                                                    error_envelope_schema(
                                                        Errors
                                                    )}]
                                        )}]
                            )}]
                )}
    end.

-file("src/atproto_openapi/paths.gleam", 184).
?DOC(false).
-spec binary_schema() -> gleam@json:json().
binary_schema() ->
    gleam@json:object(
        [{<<"type"/utf8>>, gleam@json:string(<<"string"/utf8>>)},
            {<<"format"/utf8>>, gleam@json:string(<<"binary"/utf8>>)}]
    ).

-file("src/atproto_openapi/paths.gleam", 176).
?DOC(false).
-spec body_content_json(atproto_lexicon@ast:body(), binary()) -> {ok,
        gleam@json:json()} |
    {error, atproto_openapi@refs:ref_error()}.
body_content_json(Body, Doc_id) ->
    gleam@result:'try'(case erlang:element(4, Body) of
            {some, Bs} ->
                atproto_openapi@schema:body_schema(Bs, Doc_id);

            none ->
                {ok, binary_schema()}
        end, fun(Body_schema) ->
            {ok,
                gleam@json:object(
                    [{erlang:element(3, Body),
                            gleam@json:object(
                                [{<<"schema"/utf8>>, Body_schema}]
                            )}]
                )}
        end).

-file("src/atproto_openapi/paths.gleam", 213).
?DOC(false).
-spec ok_response_json(
    gleam@option:option(atproto_lexicon@ast:body()),
    binary()
) -> {ok, gleam@json:json()} | {error, atproto_openapi@refs:ref_error()}.
ok_response_json(Output, Doc_id) ->
    case Output of
        none ->
            {ok,
                gleam@json:object(
                    [{<<"description"/utf8>>, gleam@json:string(<<"OK"/utf8>>)}]
                )};

        {some, Body} ->
            gleam@result:'try'(
                body_content_json(Body, Doc_id),
                fun(Content) ->
                    Description = case erlang:element(2, Body) of
                        {some, D} ->
                            D;

                        none ->
                            <<"OK"/utf8>>
                    end,
                    {ok,
                        gleam@json:object(
                            [{<<"description"/utf8>>,
                                    gleam@json:string(Description)},
                                {<<"content"/utf8>>, Content}]
                        )}
                end
            )
    end.

-file("src/atproto_openapi/paths.gleam", 193).
?DOC(false).
-spec responses_json(
    gleam@option:option(atproto_lexicon@ast:body()),
    list(atproto_lexicon@ast:lexicon_error()),
    binary()
) -> {ok, gleam@json:json()} | {error, atproto_openapi@refs:ref_error()}.
responses_json(Output, Errors, Doc_id) ->
    gleam@result:'try'(
        ok_response_json(Output, Doc_id),
        fun(Ok_response) ->
            Error_response = error_response_json(Errors),
            {ok,
                gleam@json:object(
                    lists:append(
                        [[{<<"200"/utf8>>, Ok_response}], case Error_response of
                                {some, E} ->
                                    [{<<"400"/utf8>>, E}];

                                none ->
                                    []
                            end]
                    )
                )}
        end
    ).

-file("src/atproto_openapi/paths.gleam", 122).
?DOC(false).
-spec parameter_json(
    binary(),
    atproto_lexicon@ast:params_property_type(),
    boolean(),
    binary()
) -> {ok, gleam@json:json()} | {error, atproto_openapi@refs:ref_error()}.
parameter_json(Name, Pt, Required, Doc_id) ->
    gleam@result:'try'(
        atproto_openapi@schema:params_property_type(Pt, Doc_id),
        fun(Param_schema) ->
            Style_fields = case Pt of
                {params_array, _, _, _, _} ->
                    [{<<"style"/utf8>>, gleam@json:string(<<"form"/utf8>>)},
                        {<<"explode"/utf8>>, gleam@json:bool(true)}];

                _ ->
                    []
            end,
            {ok,
                gleam@json:object(
                    lists:append(
                        [[{<<"name"/utf8>>, gleam@json:string(Name)},
                                {<<"in"/utf8>>,
                                    gleam@json:string(<<"query"/utf8>>)},
                                {<<"required"/utf8>>, gleam@json:bool(Required)}],
                            Style_fields,
                            [{<<"schema"/utf8>>, Param_schema}]]
                    )
                )}
        end
    ).

-file("src/atproto_openapi/paths.gleam", 107).
?DOC(false).
-spec parameters_json(
    gleam@option:option(atproto_lexicon@ast:params_schema()),
    binary()
) -> {ok, list(gleam@json:json())} | {error, atproto_openapi@refs:ref_error()}.
parameters_json(Params, Doc_id) ->
    case Params of
        none ->
            {ok, []};

        {some, P} ->
            gleam@list:try_map(
                erlang:element(4, P),
                fun(Entry) ->
                    {Name, Pt} = Entry,
                    Required = gleam@list:contains(erlang:element(3, P), Name),
                    parameter_json(Name, Pt, Required, Doc_id)
                end
            )
    end.

-file("src/atproto_openapi/paths.gleam", 70).
?DOC(false).
-spec query_operation(binary(), atproto_lexicon@ast:query_def()) -> {ok,
        gleam@json:json()} |
    {error, atproto_openapi@refs:ref_error()}.
query_operation(Nsid, Q) ->
    gleam@result:'try'(
        parameters_json(erlang:element(3, Q), Nsid),
        fun(Parameters) ->
            gleam@result:'try'(
                responses_json(erlang:element(4, Q), erlang:element(5, Q), Nsid),
                fun(Responses) ->
                    {ok,
                        gleam@json:object(
                            lists:append(
                                [[{<<"operationId"/utf8>>,
                                            gleam@json:string(Nsid)}],
                                    'maybe'(
                                        <<"description"/utf8>>,
                                        erlang:element(2, Q),
                                        fun gleam@json:string/1
                                    ),
                                    non_empty_json(
                                        <<"parameters"/utf8>>,
                                        Parameters
                                    ),
                                    [{<<"responses"/utf8>>, Responses}]]
                            )
                        )}
                end
            )
        end
    ).

-file("src/atproto_openapi/paths.gleam", 54).
?DOC(false).
-spec query_path_item(binary(), atproto_lexicon@ast:query_def()) -> {ok,
        gleam@json:json()} |
    {error, atproto_openapi@refs:ref_error()}.
query_path_item(Nsid, Q) ->
    gleam@result:'try'(
        query_operation(Nsid, Q),
        fun(Operation) ->
            {ok, gleam@json:object([{<<"get"/utf8>>, Operation}])}
        end
    ).

-file("src/atproto_openapi/paths.gleam", 153).
?DOC(false).
-spec request_body_json(
    gleam@option:option(atproto_lexicon@ast:body()),
    binary()
) -> {ok, gleam@option:option(gleam@json:json())} |
    {error, atproto_openapi@refs:ref_error()}.
request_body_json(Input, Doc_id) ->
    case Input of
        none ->
            {ok, none};

        {some, Body} ->
            gleam@result:'try'(
                body_content_json(Body, Doc_id),
                fun(Content) ->
                    {ok,
                        {some,
                            gleam@json:object(
                                lists:append(
                                    [[{<<"required"/utf8>>,
                                                gleam@json:bool(true)}],
                                        'maybe'(
                                            <<"description"/utf8>>,
                                            erlang:element(2, Body),
                                            fun gleam@json:string/1
                                        ),
                                        [{<<"content"/utf8>>, Content}]]
                                )
                            )}}
                end
            )
    end.

-file("src/atproto_openapi/paths.gleam", 85).
?DOC(false).
-spec procedure_operation(binary(), atproto_lexicon@ast:procedure_def()) -> {ok,
        gleam@json:json()} |
    {error, atproto_openapi@refs:ref_error()}.
procedure_operation(Nsid, P) ->
    gleam@result:'try'(
        parameters_json(erlang:element(3, P), Nsid),
        fun(Parameters) ->
            gleam@result:'try'(
                request_body_json(erlang:element(4, P), Nsid),
                fun(Request_body) ->
                    gleam@result:'try'(
                        responses_json(
                            erlang:element(5, P),
                            erlang:element(6, P),
                            Nsid
                        ),
                        fun(Responses) ->
                            {ok,
                                gleam@json:object(
                                    lists:append(
                                        [[{<<"operationId"/utf8>>,
                                                    gleam@json:string(Nsid)}],
                                            'maybe'(
                                                <<"description"/utf8>>,
                                                erlang:element(2, P),
                                                fun gleam@json:string/1
                                            ),
                                            non_empty_json(
                                                <<"parameters"/utf8>>,
                                                Parameters
                                            ),
                                            'maybe'(
                                                <<"requestBody"/utf8>>,
                                                Request_body,
                                                fun(Body) -> Body end
                                            ),
                                            [{<<"responses"/utf8>>, Responses}]]
                                    )
                                )}
                        end
                    )
                end
            )
        end
    ).

-file("src/atproto_openapi/paths.gleam", 60).
?DOC(false).
-spec procedure_path_item(binary(), atproto_lexicon@ast:procedure_def()) -> {ok,
        gleam@json:json()} |
    {error, atproto_openapi@refs:ref_error()}.
procedure_path_item(Nsid, P) ->
    gleam@result:'try'(
        procedure_operation(Nsid, P),
        fun(Operation) ->
            {ok, gleam@json:object([{<<"post"/utf8>>, Operation}])}
        end
    ).