go_over

-module(go_over@warning).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/go_over/warning.gleam").
-export([severity_as_string/1, string_to_severity/1, adv_to_warning/2, retired_to_warning/2, rejected_license_to_warning/2, info_to_warning/2, git_deps_to_warnings/1, is_info/1, format_as_string/1, format_as_string_minimal/1, format_as_json/1]).
-export_type([warning_reason_code/0, severity/0, dep/0, warning/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 warning_reason_code() :: warning_reason_retired |
    warning_reason_vulnerable |
    {warning_reason_rejected_license, binary()} |
    warning_reason_info.

-type severity() :: severity_package_retired_invalid |
    severity_package_retired_security |
    severity_package_retired_deprecated |
    severity_package_retired_renamed |
    {severity_package_retired_other_reason, binary()} |
    severity_rejected_license |
    severity_critical |
    severity_high |
    severity_low |
    severity_moderate |
    severity_info |
    {severity_unknown, binary()}.

-type dep() :: direct_dep | indirect_dep.

-type warning() :: {warning,
        gleam@option:option(binary()),
        binary(),
        gleam@option:option(binary()),
        binary(),
        warning_reason_code(),
        severity(),
        dep()}.

-file("src/go_over/warning.gleam", 18).
?DOC(false).
-spec warning_reason_code_as_string(warning_reason_code()) -> binary().
warning_reason_code_as_string(W) ->
    case W of
        warning_reason_retired ->
            <<"Retired"/utf8>>;

        warning_reason_vulnerable ->
            <<"Vulnerable"/utf8>>;

        {warning_reason_rejected_license, Name} ->
            <<<<"Rejected License ("/utf8, Name/binary>>/binary, ")"/utf8>>;

        warning_reason_info ->
            <<"Info"/utf8>>
    end.

-file("src/go_over/warning.gleam", 42).
?DOC(false).
-spec severity_as_string(severity()) -> binary().
severity_as_string(S) ->
    case S of
        severity_package_retired_invalid ->
            <<"package-retired:invalid"/utf8>>;

        severity_package_retired_security ->
            <<"package-retired:security"/utf8>>;

        severity_package_retired_deprecated ->
            <<"package-retired:deprecated"/utf8>>;

        severity_package_retired_renamed ->
            <<"package-retired:renamed"/utf8>>;

        {severity_package_retired_other_reason, Reason} ->
            <<"package-retired:"/utf8, (string:lowercase(Reason))/binary>>;

        severity_rejected_license ->
            <<"rejected-license"/utf8>>;

        severity_critical ->
            <<"critical"/utf8>>;

        severity_high ->
            <<"high"/utf8>>;

        severity_low ->
            <<"low"/utf8>>;

        severity_moderate ->
            <<"moderate"/utf8>>;

        severity_info ->
            <<"info"/utf8>>;

        {severity_unknown, Value} ->
            gleam@string:join(
                [<<"unknown"/utf8>>, string:lowercase(Value)],
                <<"-"/utf8>>
            )
    end.

-file("src/go_over/warning.gleam", 61).
?DOC(false).
-spec string_to_severity(binary()) -> severity().
string_to_severity(S) ->
    case string:lowercase(S) of
        <<"package-retired:invalid"/utf8>> ->
            severity_package_retired_invalid;

        <<"package-retired:security"/utf8>> ->
            severity_package_retired_security;

        <<"package-retired:deprecated"/utf8>> ->
            severity_package_retired_deprecated;

        <<"package-retired:renamed"/utf8>> ->
            severity_package_retired_renamed;

        <<"package-retired:"/utf8, V/binary>> ->
            {severity_package_retired_other_reason, V};

        <<"rejected-license"/utf8>> ->
            severity_rejected_license;

        <<"critical"/utf8>> ->
            severity_critical;

        <<"high"/utf8>> ->
            severity_high;

        <<"low"/utf8>> ->
            severity_low;

        <<"moderate"/utf8>> ->
            severity_moderate;

        <<"info"/utf8>> ->
            severity_info;

        <<"unknown-"/utf8, V@1/binary>> ->
            {severity_unknown, V@1};

        V@2 ->
            {severity_unknown, V@2}
    end.

-file("src/go_over/warning.gleam", 84).
?DOC(false).
-spec dep_code_as_string(dep()) -> binary().
dep_code_as_string(D) ->
    case D of
        direct_dep ->
            <<"Direct"/utf8>>;

        indirect_dep ->
            <<"Indirect"/utf8>>
    end.

-file("src/go_over/warning.gleam", 91).
?DOC(false).
-spec dep_code_from_bool(boolean()) -> dep().
dep_code_from_bool(D) ->
    case D of
        true ->
            direct_dep;

        false ->
            indirect_dep
    end.

-file("src/go_over/warning.gleam", 110).
?DOC(false).
-spec adv_to_warning(
    go_over@packages:package(),
    list(go_over@advisories@advisories:advisory())
) -> list(warning()).
adv_to_warning(Pkg, Advisories) ->
    gleam@list:map(
        Advisories,
        fun(Adv) ->
            {warning,
                {some, erlang:element(2, Adv)},
                erlang:element(2, Pkg),
                {some, erlang:element(4, Pkg)},
                erlang:element(6, Adv),
                warning_reason_vulnerable,
                string_to_severity(erlang:element(4, Adv)),
                dep_code_from_bool(erlang:element(5, Pkg))}
        end
    ).

-file("src/go_over/warning.gleam", 127).
?DOC(false).
-spec retired_to_warning(
    go_over@packages:package(),
    gleam@hexpm:release_retirement()
) -> warning().
retired_to_warning(Pkg, Ret) ->
    Sev = case erlang:element(2, Ret) of
        deprecated ->
            severity_package_retired_deprecated;

        invalid ->
            severity_package_retired_invalid;

        renamed ->
            severity_package_retired_renamed;

        security ->
            severity_package_retired_security;

        other_reason ->
            {severity_package_retired_other_reason,
                gleam@option:unwrap(erlang:element(3, Ret), <<"Unknown"/utf8>>)}
    end,
    {warning,
        none,
        erlang:element(2, Pkg),
        {some, erlang:element(4, Pkg)},
        go_over@hex@core:print_ret(Ret),
        warning_reason_retired,
        Sev,
        dep_code_from_bool(erlang:element(5, Pkg))}.

-file("src/go_over/warning.gleam", 148).
?DOC(false).
-spec rejected_license_to_warning(go_over@packages:package(), binary()) -> warning().
rejected_license_to_warning(Pkg, License) ->
    {warning,
        none,
        erlang:element(2, Pkg),
        none,
        <<"Rejected License found: "/utf8, License/binary>>,
        {warning_reason_rejected_license, License},
        severity_rejected_license,
        dep_code_from_bool(erlang:element(5, Pkg))}.

-file("src/go_over/warning.gleam", 160).
?DOC(false).
-spec info_to_warning(binary(), binary()) -> warning().
info_to_warning(Target, Reason) ->
    {warning,
        none,
        Target,
        none,
        Reason,
        warning_reason_info,
        severity_info,
        direct_dep}.

-file("src/go_over/warning.gleam", 172).
?DOC(false).
-spec git_deps_to_warnings(list(go_over@packages:package())) -> list(warning()).
git_deps_to_warnings(Pkgs) ->
    Git_names = begin
        _pipe = Pkgs,
        _pipe@1 = gleam@list:filter(
            _pipe,
            fun(P) -> erlang:element(6, P) =:= package_source_git end
        ),
        gleam@list:map(_pipe@1, fun(P@1) -> erlang:element(2, P@1) end)
    end,
    case Git_names of
        [] ->
            [];

        Names ->
            [info_to_warning(
                    <<"git-dependencies"/utf8>>,
                    <<"Info: git dependencies have limited support (retirement and license checks are not performed): "/utf8,
                        (gleam@string:join(Names, <<", "/utf8>>))/binary>>
                )]
    end.

-file("src/go_over/warning.gleam", 190).
?DOC(false).
-spec is_info(warning()) -> boolean().
is_info(W) ->
    case erlang:element(7, W) of
        severity_info ->
            true;

        _ ->
            false
    end.

-file("src/go_over/warning.gleam", 238).
?DOC(false).
-spec color(warning(), binary()) -> binary().
color(W, Str) ->
    case erlang:element(7, W) of
        severity_critical ->
            go_over@util@print:format_critical(Str);

        severity_package_retired_security ->
            go_over@util@print:format_critical(Str);

        severity_high ->
            go_over@util@print:format_high(Str);

        severity_rejected_license ->
            go_over@util@print:format_high(Str);

        severity_moderate ->
            go_over@util@print:format_moderate(Str);

        severity_package_retired_renamed ->
            go_over@util@print:format_moderate(Str);

        severity_package_retired_deprecated ->
            go_over@util@print:format_moderate(Str);

        severity_low ->
            go_over@util@print:format_low(Str);

        severity_package_retired_invalid ->
            go_over@util@print:format_low(Str);

        {severity_package_retired_other_reason, _} ->
            go_over@util@print:format_low(Str);

        severity_info ->
            go_over@util@print:format_info(Str);

        {severity_unknown, _} ->
            go_over@util@print:format_warning(Str)
    end.

-file("src/go_over/warning.gleam", 197).
?DOC(false).
-spec format_as_string(warning()) -> binary().
format_as_string(W) ->
    _pipe = [<<"ID: "/utf8,
            (gleam@option:unwrap(erlang:element(2, W), <<"null"/utf8>>))/binary>>,
        <<"Package: "/utf8, (erlang:element(3, W))/binary>>,
        <<"Version: "/utf8,
            (gleam@option:unwrap(erlang:element(4, W), <<"null"/utf8>>))/binary>>,
        <<"WarningReason: "/utf8,
            (warning_reason_code_as_string(erlang:element(6, W)))/binary>>,
        <<"Dependency Type: "/utf8,
            (dep_code_as_string(erlang:element(8, W)))/binary>>,
        <<"Severity: "/utf8, (severity_as_string(erlang:element(7, W)))/binary>>,
        <<"Reason: "/utf8, (erlang:element(5, W))/binary>>],
    _pipe@1 = gleam@string:join(_pipe, <<"\n"/utf8>>),
    color(W, _pipe@1).

-file("src/go_over/warning.gleam", 211).
?DOC(false).
-spec format_as_string_minimal(warning()) -> binary().
format_as_string_minimal(W) ->
    case erlang:element(4, W) of
        {some, Version} ->
            color(
                W,
                <<<<<<<<(erlang:element(3, W))/binary, "-"/utf8>>/binary,
                            Version/binary>>/binary,
                        ": "/utf8>>/binary,
                    (severity_as_string(erlang:element(7, W)))/binary>>
            );

        none ->
            color(
                W,
                <<<<(erlang:element(3, W))/binary, ": "/utf8>>/binary,
                    (severity_as_string(erlang:element(7, W)))/binary>>
            )
    end.

-file("src/go_over/warning.gleam", 223).
?DOC(false).
-spec format_as_json(warning()) -> gleam@json:json().
format_as_json(W) ->
    gleam@json:object(
        [{<<"id"/utf8>>,
                gleam@json:nullable(
                    erlang:element(2, W),
                    fun gleam@json:string/1
                )},
            {<<"package"/utf8>>, gleam@json:string(erlang:element(3, W))},
            {<<"version"/utf8>>,
                gleam@json:nullable(
                    erlang:element(4, W),
                    fun gleam@json:string/1
                )},
            {<<"warning_reason"/utf8>>,
                gleam@json:string(
                    warning_reason_code_as_string(erlang:element(6, W))
                )},
            {<<"dependency_type"/utf8>>,
                gleam@json:string(dep_code_as_string(erlang:element(8, W)))},
            {<<"severity"/utf8>>,
                gleam@json:string(severity_as_string(erlang:element(7, W)))},
            {<<"reason"/utf8>>, gleam@json:string(erlang:element(5, W))}]
    ).