go_over

-module(go_over@comparisons).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([parse/1, get_comparator/1]).

-spec parse(binary()) -> gleamsver:sem_ver().
parse(Ver) ->
    _assert_subject = begin
        _pipe = gleam@string:split(Ver, <<" "/utf8>>),
        gleam@list:last(_pipe)
    end,
    {ok, Parsed} = case _assert_subject of
        {ok, _} -> _assert_subject;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"go_over/comparisons"/utf8>>,
                        function => <<"parse"/utf8>>,
                        line => 7})
    end,
    _assert_subject@1 = gleamsver:parse(Parsed),
    {ok, Semver} = case _assert_subject@1 of
        {ok, _} -> _assert_subject@1;
        _assert_fail@1 ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail@1,
                        module => <<"go_over/comparisons"/utf8>>,
                        function => <<"parse"/utf8>>,
                        line => 11})
    end,
    Semver.

-spec eq(gleamsver:sem_ver()) -> fun((gleamsver:sem_ver()) -> boolean()).
eq(R) ->
    fun(L) -> gleamsver:compare(L, R) =:= eq end.

-spec lt(gleamsver:sem_ver()) -> fun((gleamsver:sem_ver()) -> boolean()).
lt(R) ->
    fun(L) -> gleamsver:compare(L, R) =:= lt end.

-spec lte(gleamsver:sem_ver()) -> fun((gleamsver:sem_ver()) -> boolean()).
lte(R) ->
    fun(L) -> (eq(R))(L) orelse (lt(R))(L) end.

-spec gt(gleamsver:sem_ver()) -> fun((gleamsver:sem_ver()) -> boolean()).
gt(R) ->
    fun(L) -> gleamsver:compare(L, R) =:= gt end.

-spec gte(gleamsver:sem_ver()) -> fun((gleamsver:sem_ver()) -> boolean()).
gte(R) ->
    fun(L) -> (eq(R))(L) orelse (gt(R))(L) end.

-spec do_get_comparator(binary()) -> fun((gleamsver:sem_ver()) -> boolean()).
do_get_comparator(Ver) ->
    _assert_subject = begin
        _pipe = gleam@string:split(Ver, <<" "/utf8>>),
        gleam@list:first(_pipe)
    end,
    {ok, Op} = case _assert_subject of
        {ok, _} -> _assert_subject;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"go_over/comparisons"/utf8>>,
                        function => <<"do_get_comparator"/utf8>>,
                        line => 33})
    end,
    Semver = parse(Ver),
    case Op of
        <<"<"/utf8>> ->
            lt(Semver);

        <<"<="/utf8>> ->
            lte(Semver);

        <<">"/utf8>> ->
            gt(Semver);

        <<">="/utf8>> ->
            gte(Semver);

        <<"=="/utf8>> ->
            eq(Semver);

        <<"="/utf8>> ->
            eq(Semver);

        _ ->
            eq(Semver)
    end.

-spec all_good() -> fun((gleamsver:sem_ver()) -> boolean()).
all_good() ->
    fun(_) -> false end.

-spec get_comparator(binary()) -> fun((gleamsver:sem_ver()) -> boolean()).
get_comparator(Ver) ->
    Cleaned = begin
        _pipe = Ver,
        _pipe@1 = gleam@string:split(_pipe, <<","/utf8>>),
        gleam@list:map(_pipe@1, fun gleam@string:trim/1)
    end,
    case Cleaned of
        [] ->
            all_good();

        [V] ->
            do_get_comparator(V);

        [First | Tail] ->
            gleam@list:fold(
                Tail,
                do_get_comparator(First),
                fun(Acc, V@1) ->
                    fun(Semver) ->
                        Acc(Semver) andalso (do_get_comparator(V@1))(Semver)
                    end
                end
            )
    end.