-module(kludge@internal@patch).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/kludge/internal/patch.gleam").
-export([compare_patch/2, parse_patch_name/1]).
-export_type([patch/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 patch() :: {patch,
        binary(),
        binary(),
        binary(),
        gleam@option:option(binary())}.

-file("src/kludge/internal/patch.gleam", 8).
?DOC(false).
-spec compare_patch(patch(), patch()) -> gleam@order:order().
compare_patch(Lhs, Rhs) ->
    gleam@order:lazy_break_tie(
        gleam@string:compare(erlang:element(3, Lhs), erlang:element(3, Rhs)),
        fun() ->
            gleam@order:lazy_break_tie(
                gleam@string:compare(
                    erlang:element(4, Lhs),
                    erlang:element(4, Rhs)
                ),
                fun() -> case erlang:element(5, Lhs) of
                        {some, Lhs@1} ->
                            case erlang:element(5, Rhs) of
                                {some, Rhs@1} ->
                                    gleam@string:compare(Lhs@1, Rhs@1);

                                none ->
                                    lt
                            end;

                        none ->
                            case erlang:element(5, Rhs) of
                                {some, _} ->
                                    gt;

                                none ->
                                    eq
                            end
                    end end
            )
        end
    ).

-file("src/kludge/internal/patch.gleam", 28).
?DOC(false).
-spec parse_patch_name(binary()) -> {ok, patch()} | {error, nil}.
parse_patch_name(Path) ->
    gleam@result:'try'(
        begin
            _pipe = Path,
            _pipe@1 = filepath:base_name(_pipe),
            gleam@string:split_once(_pipe@1, <<"+"/utf8>>)
        end,
        fun(_use0) ->
            {Name, End_dot_patch} = _use0,
            gleam@bool:guard(
                not gleam_stdlib:string_ends_with(
                    End_dot_patch,
                    <<".patch"/utf8>>
                ),
                {error, nil},
                fun() ->
                    End = gleam@string:drop_end(End_dot_patch, 6),
                    _pipe@2 = case gleam@string:split_once(End, <<"+"/utf8>>) of
                        {ok, {Version, Ordering}} ->
                            {patch, Path, Name, Version, {some, Ordering}};

                        {error, nil} ->
                            {patch, Path, Name, End, none}
                    end,
                    {ok, _pipe@2}
                end
            )
        end
    ).