oaspec

-module(oaspec@util@content_type).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/oaspec/util/content_type.gleam").
-export([from_string/1, is_json_compatible/1, is_xml_compatible/1, to_string/1, is_supported/1, is_supported_request/1, is_supported_response/1]).
-export_type([content_type/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.

-type content_type() :: application_json |
    text_plain |
    multipart_form_data |
    form_url_encoded |
    application_octet_stream |
    application_xml |
    text_xml |
    {unsupported_content_type, binary()}.

-file("src/oaspec/util/content_type.gleam", 20).
?DOC(
    " Parse a content type string into a ContentType.\n"
    " Recognizes structured syntax suffixes: types ending with `+json` are\n"
    " treated as JSON-compatible, and types ending with `+xml` as XML-compatible.\n"
).
-spec from_string(binary()) -> content_type().
from_string(Content_type) ->
    case Content_type of
        <<"application/json"/utf8>> ->
            application_json;

        <<"text/plain"/utf8>> ->
            text_plain;

        <<"multipart/form-data"/utf8>> ->
            multipart_form_data;

        <<"application/x-www-form-urlencoded"/utf8>> ->
            form_url_encoded;

        <<"application/octet-stream"/utf8>> ->
            application_octet_stream;

        <<"application/xml"/utf8>> ->
            application_xml;

        <<"text/xml"/utf8>> ->
            text_xml;

        Other ->
            case gleam_stdlib:string_ends_with(Other, <<"+json"/utf8>>) of
                true ->
                    application_json;

                false ->
                    case gleam_stdlib:string_ends_with(Other, <<"+xml"/utf8>>) of
                        true ->
                            application_xml;

                        false ->
                            {unsupported_content_type, Other}
                    end
            end
    end.

-file("src/oaspec/util/content_type.gleam", 43).
?DOC(
    " Check if a content type string is JSON-compatible.\n"
    " Matches \"application/json\" and any type with a \"+json\" suffix.\n"
).
-spec is_json_compatible(binary()) -> boolean().
is_json_compatible(S) ->
    (S =:= <<"application/json"/utf8>>) orelse gleam_stdlib:string_ends_with(
        S,
        <<"+json"/utf8>>
    ).

-file("src/oaspec/util/content_type.gleam", 49).
?DOC(
    " Check if a content type string is XML-compatible.\n"
    " Matches \"application/xml\", \"text/xml\", and any type with a \"+xml\" suffix.\n"
).
-spec is_xml_compatible(binary()) -> boolean().
is_xml_compatible(S) ->
    ((S =:= <<"application/xml"/utf8>>) orelse (S =:= <<"text/xml"/utf8>>))
    orelse gleam_stdlib:string_ends_with(S, <<"+xml"/utf8>>).

-file("src/oaspec/util/content_type.gleam", 54).
?DOC(" Convert a ContentType back to its string representation.\n").
-spec to_string(content_type()) -> binary().
to_string(Content_type) ->
    case Content_type of
        application_json ->
            <<"application/json"/utf8>>;

        text_plain ->
            <<"text/plain"/utf8>>;

        multipart_form_data ->
            <<"multipart/form-data"/utf8>>;

        form_url_encoded ->
            <<"application/x-www-form-urlencoded"/utf8>>;

        application_octet_stream ->
            <<"application/octet-stream"/utf8>>;

        application_xml ->
            <<"application/xml"/utf8>>;

        text_xml ->
            <<"text/xml"/utf8>>;

        {unsupported_content_type, S} ->
            S
    end.

-file("src/oaspec/util/content_type.gleam", 68).
?DOC(" Check if a content type is supported anywhere in code generation.\n").
-spec is_supported(content_type()) -> boolean().
is_supported(Content_type) ->
    case Content_type of
        application_json ->
            true;

        text_plain ->
            true;

        multipart_form_data ->
            true;

        form_url_encoded ->
            true;

        application_octet_stream ->
            true;

        application_xml ->
            true;

        text_xml ->
            true;

        _ ->
            false
    end.

-file("src/oaspec/util/content_type.gleam", 101).
-spec registry_has_supported(binary(), binary()) -> boolean().
registry_has_supported(Name, Category) ->
    _pipe = oaspec@capability:registry(),
    gleam@list:any(
        _pipe,
        fun(C) ->
            ((erlang:element(2, C) =:= Name) andalso (erlang:element(3, C) =:= Category))
            andalso (erlang:element(4, C) =:= supported)
        end
    ).

-file("src/oaspec/util/content_type.gleam", 85).
?DOC(
    " Check if a content type is supported for request bodies.\n"
    " Driven by the capability registry: looks up the MIME string under\n"
    " category `\"request\"` at level Supported. UnsupportedContentType\n"
    " never matches the registry and always returns False.\n"
).
-spec is_supported_request(content_type()) -> boolean().
is_supported_request(Content_type) ->
    case Content_type of
        {unsupported_content_type, _} ->
            false;

        Ct ->
            registry_has_supported(to_string(Ct), <<"request"/utf8>>)
    end.

-file("src/oaspec/util/content_type.gleam", 94).
?DOC(
    " Check if a content type is supported for responses. Same mechanism\n"
    " as `is_supported_request`, just targeting the `\"response\"` category.\n"
).
-spec is_supported_response(content_type()) -> boolean().
is_supported_response(Content_type) ->
    case Content_type of
        {unsupported_content_type, _} ->
            false;

        Ct ->
            registry_has_supported(to_string(Ct), <<"response"/utf8>>)
    end.