#!/bin/bash
# Copyright (C) 2018 David P. <megver83@parabola.nu>
# Find deprecated Arch packages that are still in our blacklists.

# Repositories for specific arch'es.
# Common repos are in 'repos' variable.
repos="core community extra"
repos_x86_64="$repos testing multilib multilib-testing"
repos_i686="$repos testing build-support"
repos_armv7h="$repos alarm" # although we don't sync [alarm] we blacklist its packages to conflict with your-freedom

# Parabola repos for checking blacklists like your-privacy,
# which sometimes block [libre] and [pcr] packages.
# [nonprism] and [nonsystemd] are not listened because
# we do not blacklists those packages anywhere
repos_parabola="pcr pcr-multilib pcr-multilib-testing pcr-testing libre libre-multilib libre-multilib-testing libre-testing"

# Set the blacklist files. The packages here always have a [libre] replacement if there's one.
# aur-blacklist.txt is not here since we want to check Arch's official repos
blacklists="blacklist.txt"

# List here files that may also blacklist Parabola packages.
# These are intended to be used with $repos_parabola
blacklists_parabola="your-initfreedom-blacklist.txt your-privacy-blacklist.txt your-freedom_emu-blacklist.txt"

# Mirrors. Please choose HTTPS over HTTP when possible
# x86_64 mirrors
for r in $repos_x86_64; do
  mirrors+=("https://mirrors.edge.kernel.org/archlinux/$r/os/x86_64/")
done
# i686 mirrors
for r in $repos_i686; do
  mirrors+=("https://mirror.archlinux32.org/i686/$r/")
done
# armv7h mirrors
for r in $repos_armv7h; do
  mirrors+=("https://fl.us.mirror.archlinuxarm.org/armv7h/$r/")
done

add_parabola_mirrors(){
  # Parabola mirrors, used to check [libre] and [pcr] packages
  for r in $repos_parabola; do
    mirrors+=("https://mirror.grapentin.org/parabola/$r/os/x86_64/")
    mirrors+=("https://mirror.grapentin.org/parabola/$r/os/i686/")
    mirrors+=("https://mirror.grapentin.org/parabola/$r/os/armv7h/")
  done
}

# Sed expresion tested for Nginx, change if needed
sedexp='s/.*href="//;s/\.pkg.tar.xz.*//;s/\.pkg.tar.zst.*//'
# extra sedexps for special characters/symbols
sedexp+=';s/%2B/+/g;s/%3A/:/g;s/%40/@/g'

usage(){
cat <<EOM
Usage: ${0##*/} [arch|parabola]
Check if there are inexistent packages in the blacklists.

Arguments:
  arch                        Compares ArchLinux{32,ARM} blacklists
                              with their repositories
  parabola                    Compares Arch/Parabola blacklists (e.g.
                              your-privacy) with Parabola's and Arch's
                              repos

The 'parabola' argument compares with our repositories and Arch's
since in blacklists like your-privacy and your-initfreedom we also block
some packages from [pcr] (like jitsi) and [libre] (like icedove), and
probably also from their -multilib, -testing and -multilib-testing derivatives.

Note that the package architecture is always specified with 'parabola', and
in 'arch' only when there's an uneeded replacement. This is because your-freedom
is for any architecture and no matter if you use Parabola x86_64 or i686, it
will always conflict packages that are even for armv7h only (and vice versa).

To easily remove a line, you can use the following sed expresion:

  sed '/^pkgname:/d' -i blacklist_file.txt
EOM
}

mkpkglist(){
  parabola_pkgs=$(mktemp)
  arch_pkgs=$(mktemp)
  case $1 in
        parabola) add_parabola_mirrors
                  curl -s "${mirrors[@]}" | grep '".*.pkg.tar.xz"\|".*.pkg.tar.zst"' | sed $sedexp > "$parabola_pkgs"

                  # Separate packages by architecture
                  for arch in x86_64 i686 armv7h any; do
                    grep $arch$ "$parabola_pkgs" | for f in $(</dev/stdin); do
                        echo "${f%-*-*-*} $arch" >> "$parabola_pkgs"-$arch
                    done
                  done
                  cat "$parabola_pkgs"-{x86_64,i686,armv7h,any} | sort -u > "$parabola_pkgs"
                  rm "$parabola_pkgs"-{x86_64,i686,armv7h,any}
        ;;
        arch) curl -s "${mirrors[@]}" | grep '".*.pkg.tar.xz"\|".*.pkg.tar.zst"' | sed $sedexp > "$arch_pkgs"

              # Separate packages by architecture
              for arch in x86_64 i686 armv7h any; do
                grep $arch$ "$arch_pkgs" | for f in $(</dev/stdin); do
                    echo "${f%-*-*-*} $arch" >> "$arch_pkgs"-$arch
                done
              done
              cat "$arch_pkgs"-{x86_64,i686,armv7h,any} | sort -u > "$arch_pkgs"
              rm "$arch_pkgs"-{x86_64,i686,armv7h,any}
        ;;
  esac
}

err(){
  printf '%s==> Error:%s %s\n' \
         "$(tput bold;tput setaf 1)" \
         "$(tput sgr0)" \
         "$1"
  exit 1
}

msg(){
  printf '%s==>%s %s\n' \
         "$(tput bold;tput setaf 2)" \
         "$(tput sgr0)" \
         "$1"
}

submsg(){
  printf '  %s->%s %s\n' \
         "$(tput bold;tput setaf 4)" \
         "$(tput sgr0)" \
         "$1"
}

get_libre_pkgs(){
  # We'll use this when we check Arch's pkgs only
  if ! [[ -e $libre_pkgs ]]; then
  libre_pkgs=$(mktemp)
  for r in libre libre-multilib libre-testing libre-multilib-testing; do
    mirrors_parabola+=("https://mirror.grapentin.org/parabola/$r/os/x86_64/")
    mirrors_parabola+=("https://mirror.grapentin.org/parabola/$r/os/i686/")
    mirrors_parabola+=("https://mirror.grapentin.org/parabola/$r/os/armv7h/")
  done
  curl -s "${mirrors_parabola[@]}" | grep '".*.pkg.tar.xz"\|".*.pkg.tar.zst"' | sed $sedexp > "$libre_pkgs"
  for arch in x86_64 i686 armv7h any; do
    grep $arch$ "$libre_pkgs" | for f in $(</dev/stdin); do
      echo "${f%-*-*-*} $arch" >> "$libre_pkgs"-$arch
    done
  done
  cat "$libre_pkgs"-{x86_64,i686,armv7h,any} | sort -u > "$libre_pkgs"
  fi
}

add(){
  list="$(( list + 1 ))"
}

compare_pkgs(){
  # $1 is the pkgname and replacement (used when checking Arch pkgs)
  # $2 is the packages file list

  # First check if the pkg is available for
  # a specific architecture, if not, check
  # if it's for 'any'
  package="${1%%:*}"
  replacement="$(cut -d ":" -f2 <(echo "$1"))"

  for arch in x86_64 i686 armv7h; do
    grep $arch$ "$2" | awk '{print $1}' | grep -xw ^"$package" &> /dev/null || \
    grep any$ "$2" | awk '{print $1}' | grep -xw ^"$package" &> /dev/null || \
    if [ "$2" = "$arch_pkgs" ]; then
      get_libre_pkgs
      # Check if the package has a replacement, and
      # if such replacement is available for the same
      # architectures
      if ! [[ $replacement = "" ]]; then
        # If this works, it means the pkg doesn't exist for $arch in Arch,
        # but we have the [libre] replacement which should be deprecated.
        grep $arch$ "$libre_pkgs" | awk '{print $1}' | grep -xw ^"$replacement" &> /dev/null || \
        grep any$ "$libre_pkgs" | awk '{print $1}' | grep -xw ^"$replacement" &> /dev/null

        case $? in
            0) to_be_removed+=("$arch")
            ;;
            *) is_not_for+=("$arch")
            ;;
        esac
      else
        # However if this fails, it means the pkg doesn't have a replacement
        # for $arch, or it simply doesn't have a replacement.
        is_not_for+=("$arch")
      fi
    elif [ "$2" = "$parabola_pkgs" ]; then
      if [[ -n $replacement ]]; then
        # Look for the replacement
        grep $arch$ "$parabola_pkgs" | awk '{print $1}' | grep -xw ^"$replacement" &> /dev/null || \
        grep any$ "$parabola_pkgs" | awk '{print $1}' | grep -xw ^"$replacement" &> /dev/null

        case $? in
            0) to_be_deleted+=("$arch")
            ;;
            *) isnt_for+=("$arch")
            ;;
        esac
      else
        isnt_for+=("$arch")
      fi
    fi
  done

  # Arch
  if [[ "${is_not_for[*]}" = "x86_64 i686 armv7h" ]]; then
    submsg "$package was not found"
    add
  elif [[ "${to_be_removed[*]}" = "x86_64 i686 armv7h" ]]; then
    submsg "$package was not found, but we've [libre] replacements which should be removed"
    add
  elif [[ -n "${is_not_for[*]}" ]] || [[ -n "${to_be_removed[*]}" ]]; then
    for arch in "${to_be_removed[@]}"; do
      # If the replacement is available for the three arch'es supported
      # by Parabola, then shut up
      for a in x86_64 i686 armv7h; do
        grep -xw "^$replacement $a$" "$libre_pkgs" &> /dev/null && arches+=("$a")
      done
      if ! [[ "${arches[*]}" = "x86_64 i686 armv7h" ]]; then
        submsg "$package ($arch) was not found, but we've a [libre] replacement which should be removed"
        add
      fi
      unset arches
    done
  fi

  # Parabola
  if [[ "${isnt_for[*]}" = "x86_64 i686 armv7h" ]]; then
    submsg "$package was not found"
    add
  elif [[ -n "${isnt_for[*]}" ]]; then
    for arch in "${to_be_deleted[@]}"; do
      submsg "$package ($arch) was not found, but we've $replacement as replacement and should be removed"
      add
    done
  fi

  # Unset the variables so they can be re-used
  unset to_be_deleted to_be_removed is_not_for isnt_for arch package replacement
}

check(){
  mkpkglist "$1"
  case $1 in
        parabola) msg 'Comparing blacklists with Parabola packages ...'
                  pkgs=$(for bl in $blacklists_parabola; do grep -v ^# "$bl" | awk '{print $1}'; done)
                  for p in $pkgs; do
                    compare_pkgs "$p" "$parabola_pkgs"
                  done
                  rm -f "$parabola_pkgs"
        ;;
        arch) msg 'Comparing blacklists with Arch packages ...'
              pkgs=$(for bl in $blacklists; do grep -v ^# $bl | awk '{print $1}'; done)
              for p in $pkgs; do
                compare_pkgs "$p" "$arch_pkgs"
              done
              rm -f "$arch_pkgs" "$libre_pkgs"
        ;;
        *) err "$1 is not a valid argument"
        ;;
  esac
  if ! [[ $list -gt 0 ]]; then
    submsg 'No packages to show'
  fi
  msg 'done'
  unset list
}

if [[ ${#@} -gt 0 ]]; then
  netcheck="$(curl -sL networkcheck.kde.org)"
  if [[ "$netcheck" = OK ]]; then
    for arg in "$@"; do check "$arg"; done
  else
    err 'You must have internet connection to run this program'
  fi
else
  usage
fi