#!/bin/bash

shellfu import isa
shellfu import pretty
shellfu import sfpi

#
# Query on which distribution we are
#

dist() {
    #
    # Get key $1 of distro info
    #
    # Usage:
    #
    #     dist KEY
    #
    # Find plugin supporting the key and use it
    #
    # Common KEYs are:
    #
    #  *  'id' - small-caps identifier, eg. `debian`,
    #  *  'name' - human-readable name, eg. `Red Hat Enterprise Linux`,
    #  *  'ver' - release version, eg. '8.1'
    #  *  'ver.x' - first part of rel. version, eg. '8'
    #  *  'ver.y' - second part of rel. version, eg. '1'
    #  *  'ver.z' - third part of rel. version, eg. '0'
    #
    # Note that distros don't have to support all parts of version; plugins
    # should report empty string if the part is not supported.  However,
    # since meaning is always distro-specific, you should not query for it
    # directly (eg. don't use `ver.z` if you are on Debian.).
    #
    local key=$1
    local plg
    test -n "$key" || { mkusage -E KEY; return 2; }
    #shellcheck disable=SC2034
    SFPI__PREFIX=_distp
    for plg in $(sfpi__ls); do
        debug -v plg
        sfpi__call "$plg" get "$key" \
         && return
    done
    warn "no source for key: $key"
    return 3
}

dist__test() {
    #
    # Test on distro key
    #
    #     dist__test KEY OP VALUE [KEY OP VALUE]..
    #
    # Known OPs are
    #
    #  *  'eq', 'lt', 'gt', 'le', 'ge' and 'ne' are integer comparison
    #     operators as known from `test` unix command.
    #
    #  *  '==', '!=', are string comparison operators, also known from
    #     `test` unix command.
    #
    #  *  're' is regular expression matcher, ie. VALUE has to be basic
    #     regular expression matching whole line,
    #
    #  *  'vge', 'vle`, `vgt` and `vlt` have similar meanings as their
    #     corresponding integer operators, but work on version numbers
    #     using 'sort -V' command.
    #
    while test -n "$1"; do
        __dist__test1 "$1" "$2" "$3" || return 1
        shift 3 || { mkusage -E "KEY OP VALUE [KEY OP VALUE].."; return 2; }
    done
    return 0
}

__dist__test1() {
    #
    # Test on distro key
    #
    #     dist__test1 KEY OP VALUE
    #
    local key=$1
    local Op=$2
    local Ref=$3
    local Val
    test -n "$Op"
    Val=$(dist "$key") || return 3
    debug -v key Val Op Ref
    case $Op in
        eq|lt|le|gt|ge|ne)  __dist_intcmp             ;;
        ==)                 test "$Val" == "$Ref"     ;;
        !=)                 test "$Val" != "$Ref"     ;;
        re)                 grep -qx "$Ref" <<<"$Val" ;;
        veq|vne)            __dist_vercmp             ;;
        vge|vle|vgt|vlt)    __dist_vercmp             ;;
        *) mkusage -w "unsupported OP: $Op" \
                   -E "KEY OP VALUE [KEY OP VALUE].."
           return 2 ;;
    esac
}

__dist_intcmp() {
    #
    # Compare integers $Val and $Ref with $Op
    #
    isa__int "$Val" || { warn "not an integer: '$Val'"; return 3; }
    isa__int "$Ref" || { warn "not an integer: '$Ref'"; return 3; }
    test "$Val" -"$Op" "$Ref"
}

__dist_vercmp() {
    #
    # Compare versions $Val and $Ref with $Op
    #
    local rv="$Ref"$'\n'"$Val"
    local vr="$Val"$'\n'"$Ref"
    local rvs
    local vrs
    local rvs_same=0
    local vrs_same=0
    rvs=$(sort -V <<<"$rv")
    vrs=$(sort -V <<<"$vr")
    test "$rvs" == "$rv"; rvs_same=$?   # 0: r is ge    1: r is lt
    test "$vrs" == "$vr"; vrs_same=$?   # 0: v is ge    1: v is lt
    case ${Op:1}:$rvs_same:$vrs_same in

        # both are same
        #
        eq:0:0)  return 0 ;;
        ge:0:0)  return 0 ;;
        le:0:0)  return 0 ;;
        gt:0:0)  return 1 ;;
        lt:0:0)  return 1 ;;
        ne:0:0)  return 1 ;;

        # r is ge, v is lt
        #
        eq:0:1)  return 1 ;;
        ge:0:1)  return 0 ;;
        gt:0:1)  return 0 ;;
        le:0:1)  return 0 ;;
        lt:0:1)  return 1 ;;
        ne:0:1)  return 0 ;;

        # r is lt, v is ge
        #
        eq:1:0)  return 1 ;;
        ge:1:0)  return 1 ;;
        gt:1:0)  return 1 ;;
        le:1:0)  return 1 ;;
        lt:1:0)  return 0 ;;
        ne:1:0)  return 0 ;;

    esac
    #FIXME: these are pretty much surely borken
}

#shellfu module-version=__MKIT_PROJ_VERSION__