-module(gilly@openapi@version).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/gilly/openapi/version.gleam").
-export([version_is_supported/1, version_decoder/0]).
-export_type([version/0]).

-type version() :: {version,
        integer(),
        gleam@option:option(integer()),
        gleam@option:option(integer())}.

-file("src/gilly/openapi/version.gleam", 33).
-spec parse_version(binary()) -> {ok, version()} | {error, binary()}.
parse_version(Version_str) ->
    Split = gleam@string:split(Version_str, <<"."/utf8>>),
    gleam@result:'try'(
        begin
            _pipe = gleam@list:first(Split),
            gleam@result:map_error(
                _pipe,
                fun(_) -> <<"Version string is empty"/utf8>> end
            )
        end,
        fun(Major_str) ->
            gleam@result:'try'(
                begin
                    _pipe@1 = gleam_stdlib:parse_int(Major_str),
                    gleam@result:map_error(
                        _pipe@1,
                        fun(_) ->
                            <<"Major version is not a valid integer"/utf8>>
                        end
                    )
                end,
                fun(Major) -> case Split of
                        [_, Minor_str, Patch_str] ->
                            {ok,
                                {version,
                                    Major,
                                    begin
                                        _pipe@2 = gleam_stdlib:parse_int(
                                            Minor_str
                                        ),
                                        gleam@option:from_result(_pipe@2)
                                    end,
                                    begin
                                        _pipe@3 = gleam_stdlib:parse_int(
                                            Patch_str
                                        ),
                                        gleam@option:from_result(_pipe@3)
                                    end}};

                        [_, Minor_str@1] ->
                            {ok,
                                {version,
                                    Major,
                                    begin
                                        _pipe@4 = gleam_stdlib:parse_int(
                                            Minor_str@1
                                        ),
                                        gleam@option:from_result(_pipe@4)
                                    end,
                                    none}};

                        [_] ->
                            {ok, {version, Major, none, none}};

                        _ ->
                            {error,
                                <<"Version string must be in the format 'X', 'X.Y', or 'X.Y.Z'"/utf8>>}
                    end end
            )
        end
    ).

-file("src/gilly/openapi/version.gleam", 56).
-spec version_is_supported(version()) -> boolean().
version_is_supported(Version) ->
    case Version of
        {version, 3, {some, 0}, _} ->
            true;

        {version, 3, {some, 1}, _} ->
            true;

        {version, 3, none, _} ->
            true;

        _ ->
            false
    end.

-file("src/gilly/openapi/version.gleam", 16).
-spec version_decoder() -> gleam@dynamic@decode:decoder(version()).
version_decoder() ->
    gleam@dynamic@decode:then(
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Version_str) -> case parse_version(Version_str) of
                {ok, Version} ->
                    case version_is_supported(Version) of
                        true ->
                            gleam@dynamic@decode:success(Version);

                        false ->
                            gleam@dynamic@decode:failure(
                                {version, 0, none, none},
                                <<"Unsupported OpenAPI version: "/utf8,
                                    Version_str/binary>>
                            )
                    end;

                {error, Msg} ->
                    gleam@dynamic@decode:failure({version, 0, none, none}, Msg)
            end end
    ).