#!/bin/bash

# meld-src-pkgbuilds - compare source packages
#
# Copyright (C) 2020 bill-auger <bill-auger@programmer.net>
#
# SPDX-License-Identifier: AGPL-3.0-or-later
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <https://www.gnu.org/licenses/>.


# echo "$(grep 'WORKDIR=' /etc/libretools.conf | sed 's|^WORKDIR="\([^"]*\)"|\1|') IN"
# echo "$(grep 'WORKDIR=' /etc/libretools.conf | sed 's|^WORKDIR=||' | tr '"' ' ') IN"


readonly PKGS_DIR="$(source /etc/libretools.conf ; echo "${WORKDIR}" ;)"
readonly ABS_DIR=${PKGS_DIR}/arch
readonly ABSLIBRE_DIR=${PKGS_DIR}/abslibre

[[ ! -d "${PKGS_DIR:-/packages}" ]] && echo "no such dir" && exit 1


# readonly PKGS_DIR=$(grep 'WORKDIR=' /etc/libretools.conf | sed 's|.*WORKDIR="\([^"]*\)*"|\1|')

read -r -d '' USAGE <<-'USAGE_MSG'
USAGE:

  meld-src-pkgbuilds [ -a ] [ -g ] PKGBUILD-or-srcpkg-or-pkgname PKGBUILD-or-srcpkg

OPTIONS:

  -a UseAbs
  -g UseGui

EXAMPLES:

  # prompt for selection
  $ meld-src-pkgbuilds base

  # compare across repos
  $ meld-src-pkgbuilds libre/base/PKGBUILD nonsystemd/base/PKGBUILD

  # compare across versions
  $ meld-src-pkgbuilds libre/base/base-*-any.src.tar.gz
USAGE_MSG

declare -i UseAbs=0
declare -i UseGui=0


SelectSrcpkg() # (pkgname)
{
  # echo back parameter, if not a valid pkgname
  local pkgname=$1
  local pkgname_rx='^[0-9a-z][0-9a-zA-Z_-]*$'
  local pkg

# echo "SelectSrcpkg() pkgname='$pkgname' sourcepkg $( [[ "$pkgname" =~ ${pkgname_rx} ]] && pacman -Si "$pkgname" &> /dev/null || echo " not")exists" >&2 ;

  [[ "${pkgname}" =~ ${pkgname_rx} ]] && pacman -Si ${pkgname} &> /dev/null || return 1

# echo "SelectSrcpkg() pkgname=${pkgname} PKGS_DIR=$PKGS_DIR is $( pacman -Qsq ${pkgname} &> /dev/null || echo 'not ') installed" >&2

  local srcpkgs_glob="${pkgname}-*.src.tar.gz"
  local pkgs=( $(find "${PKGS_DIR}"/abslibre/ -type f -name "${srcpkgs_glob}" 2> /dev/null) \
               $(find "${PKGS_DIR}"/sources/  -type f -name "${srcpkgs_glob}" 2> /dev/null) )

# printf "SelectSrcpkg() ${#pkgs[@]} pkgs=%s\n" "${pkgs[@]}" >&2

  (( ${#pkgs[@]} )) && [[ -n "${pkgs[@]}" ]] || return 1

  select pkg in "${pkgs[@]}" ; do echo "${pkg}" ; break ; done
}

GitPkgbuilds()
{
# echo "GitPkgbuilds() pkgname='$1' $( [[ "$1" =~ '^[-@\._\+0-9a-z]+$' ]] && echo t || echo f )" >&2
#   local pkgbuild=$( [[ "$1" =~ /PKGBUILD$ ]] && echo "$1" )


#   local pkgname_rx='^[-@\._\+0-9a-z]+$'
  local pkgname_rx='^[0-9a-z][0-9a-zA-Z_-]*$'
  local pkgname=$(    [[ "$1" =~ ${pkgname_rx} ]] && echo "$1"        )
  local sort_order=$( [[ "$2" == '--reverse'   ]] && echo '--reverse' )
#   [[ -z "${pkgname}" ]]                           && echo "invalid pkgname: '$1'" >&2 && return 1
  [[ -z "${pkgname}" ]]                           && return 1

  local arch_dirs="$( find -L $ABS_DIR/      -maxdepth 2 -type d -name $pkgname | sort $sort_order)"
  local abs_dirs="$(  find    $ABSLIBRE_DIR/ -maxdepth 2 -type d -name $pkgname | sort $sort_order)"
  local arch_dir="$(  head -n 1 <<<${arch_dirs})"
  local abs_dir="$(   head -n 1 <<<${abs_dirs} )"
  local is_writable=$(touch ${abs_dir}/PKGBUILD &> /dev/null ; echo $(( ! $? )) ; )

echo -e "GitPkgbuilds() OUT\n  arch_dirs=$arch_dir\n  abs_dirs=$abs_dirs\n  arch_dir=$arch_dir\n  abs_dir=$abs_dir\n  is_writable=$is_writable" >&2

  [[ -z "$arch_dir"                             ]] && echo "no such arch PKGBUILD"     >&2 && return 1
  [[ -z "$abs_dir"                              ]] && echo "no such parabola PKGBUILD" >&2 && return 1

  [[ "$arch_dir" =~ $ABS_DIR.+$ABS_DIR          ]] && echo "multiple arch PKGBUILDs found (try --reverse)"
  [[ "$abs_dir" =~ $ABSLIBRE_DIR.+$ABSLIBRE_DIR ]] && echo "multiple abslibre PKGBUILDs found (try --reverse)"
  (( ! ${is_writable}                           )) && echo "fixing 'dev' group perms on ABS dir" && mkdev ${abs_dir}/
  ls --color=auto --group-directories-first -F -l ${arch_dir}/trunk/ ${abs_dir}/
}

DoDiff()
{
  local pkgbuild_a="$1"
  local pkgbuild_b="$2"
  local srcpkg_a="$3"
  local srcpkg_b="$4"
  local sed_rx='s|(\-\-\-\|\+\+\+) /dev/fd/[0-9]*\s*(.*)|\1 /PKGBUILD \2|'
  local patch_file=srcpkgbuild.patch

echo "DoDiff() pkgbuild_a=$pkgbuild_a pkgbuild_b=$pkgbuild_b"

  [[ -n "${pkgbuild_a}" && -n "${pkgbuild_b}" ]] || return 1

  if   [[ -n "${srcpkg_a}" && -n "${srcpkg_b}" ]]
  then if   diff "${srcpkg_a}" "${srcpkg_b}" &> /dev/null
       then echo "source packages identical" ; return ;
       else echo "source packages differ"
       fi
  fi

  if   diff "${pkgbuild_a}" "${pkgbuild_b}" &> /dev/null
  then echo "PKGBUILDs identical"
  else echo "PKGBUILDs differ"
       if   (( UseGui ))
       then echo "launching meld"
            meld       "${pkgbuild_a}" "${pkgbuild_b}"
       else diff -u -r "${pkgbuild_a}" "${pkgbuild_b}" | sed -E "${sed_rx}" | tee ${patch_file} >&2
       fi
  fi
}

main()
{
echo -e "meld-src-pkgbuilds() IN\n  n_args$#\n  1=$1\n  2=$2\n  GitPkgbuilds='$(GitPkgbuilds "$1")'" ; # $# $@" >&2 ; local in=$# ;

  local pkgname_rx='^[0-9a-z][0-9a-zA-Z_-]*$'
  local is_pkg_name=$(   [[ "$1" =~ ${pkgname_rx} ]] ; echo $(( ! $? )) )
  local is_src_pkg_a=$(  [[ "$1" =~ src\.tar\.gz$ ]] ; echo $(( ! $? )) )
  local is_src_pkg_b=$(  [[ "$2" =~ src\.tar\.gz$ ]] ; echo $(( ! $? )) )
  local is_pkgbuild_a=$( [[ "$1" =~ /PKGBUILD$    ]] ; echo $(( ! $? )) )
  local is_pkgbuild_b=$( [[ "$2" =~ /PKGBUILD$    ]] ; echo $(( ! $? )) )
  local srcpkg_a
  local srcpkg_b

  if   (( is_pkg_name ))
  then if   (( UseAbs ))
       then srcpkgs=( "$(GitPkgbuilds "$1")" )
            srcpkg_a=${srcpkgs[0]}
            srcpkg_b=${srcpkgs[1]}
       else srcpkg_a="$( SelectSrcpkg "$1" || GitPkgbuilds "$1" )" ; is_src_pkg_a=1 ;
            srcpkg_b="$( SelectSrcpkg "$1" || GitPkgbuilds "$1" )" ; is_src_pkg_b=1 ;
       fi
  else (( is_src_pkg_a  && is_src_pkg_b  )) && srcpkg_a="$1" srcpkg_b="$2"
       (( is_pkgbuild_a && is_pkgbuild_b )) && srcpkg_a="$1" srcpkg_b="$2"
  fi

  local are_src_pkgs=$(  (( is_src_pkg_a     && is_src_pkg_b        )) ; echo $(( ! $? )) )
  local are_abs_dirs=$(  (( UseAbs        )) && [[ -d "${srcpkg_a}" && \
                                                   -d "${srcpkg_b}" ]] ; echo $(( ! $? )) )
  local are_pkgbuilds=$( (( is_pkgbuild_a )) && [[ -f "${srcpkg_a}" ]]                   && \
                         (( is_pkgbuild_b )) && [[ -f "${srcpkg_b}" ]] ; echo $(( ! $? )) )

echo -e "meld-src-pkgbuilds()\n  srcpkg_a=${srcpkg_a}\n  srcpkg_b=${srcpkg_b}\n  are_src_pkgs=$are_src_pkgs\n  are_abs_dirs=$are_abs_dirs\n  are_pkgbuilds=$are_pkgbuilds">&2

  if   [[ -z "${srcpkg_a}" || -z "${srcpkg_b}" || "${srcpkg_a}" == "${srcpkg_b}" ]]
  then echo "arguments must be one <pkgname>, or two unique *.src.tar.gz or PKGBUILD"

  elif (( are_src_pkgs ))
  then local pkgbuild_a="$( [[ -f "${srcpkg_a}" ]] && tar -ztf "${srcpkg_a}" | grep PKGBUILD )"
       local pkgbuild_b="$( [[ -f "${srcpkg_b}" ]] && tar -ztf "${srcpkg_b}" | grep PKGBUILD )"

echo -e "meld-src-pkgbuilds()\n  pkgbuild_a=${pkgbuild_a}\n  pkgbuild_b=${pkgbuild_b}\n  tar_a_cmd=${tar_a_cmd[@]}\n  tar_b_cmd=${tar_b_cmd[@]}" >&2

       if   [[ -n "${pkgbuild_a}" && -n "${pkgbuild_b}" ]]
       then cd /tmp
            tar -zxf "${srcpkg_a}" "${pkgbuild_a}" > ./srcpkgbuild_a
            tar -zxf "${srcpkg_b}" "${pkgbuild_b}" > ./srcpkgbuild_b
            DoDiff ./srcpkgbuild_a ./srcpkgbuild_b "${srcpkg_a}" "${srcpkg_b}"
            rm ./srcpkgbuild_a ./srcpkgbuild_b
       fi

  elif (( are_abs_dirs ))
  then DoDiff "${srcpkg_a}/PKGBUILD" "${srcpkg_b}/PKGBUILD"

  elif (( are_pkgbuilds ))
  then DoDiff "${srcpkg_a}" "${srcpkg_b}"
  fi
}


#   local UseGui=$( [[ "$1" == '--gui' ]] ; echo ! $(($?)) ) ; (( UseGui )) && shift ;
#   local UseGui=$( while getopts 'g' opt ; do [[ "${opt}" == 'g' ]] ; echo $(( ! $? )) ; done ; shift $(( OPTIND - 1 )) ; )
while getopts 'ag' opt
do case "$opt" in
   a) UseAbs=1                                                  ;;
   g) UseGui=1                                                  ;;
   *) echo "invalid option: '%s'" "${opt}\n${USAGE}" ; return 1 ;;
   esac
done ; shift $(( OPTIND - 1 )) ; (( $# )) || ! echo "args err" || exit 1 ;
readonly UseAbs UseGui


main "$@"