#!/usr/bin/env bash
#
#   pkgdelta - create delta files for use with pacman and repo-add
#   Generated from pkgdelta.sh.in; do not edit by hand.
#
#   Copyright (c) 2009 Xavier Chantry <shiningxc@gmail.com>
#
#   This program is free software; you can redistribute it and/or modify
#   it under the terms of the GNU General Public License as published by
#   the Free Software Foundation; either version 2 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 General Public License for more details.
#
#   You should have received a copy of the GNU General Public License
#   along with this program.  If not, see <http://www.gnu.org/licenses/>.
#

# bash options
set -o errexit

# gettext initialization
export TEXTDOMAIN='pacman-scripts'
export TEXTDOMAINDIR='/usr/share/locale'

declare -r myver='5.1.3'

LIBRARY=${LIBRARY:-'/usr/share/makepkg'}

# Import parseopts.sh
source "$LIBRARY"/util/parseopts.sh

# Options
QUIET=0
USE_COLOR='y'

# minimal of package before deltas are generated (bytes)
min_pkg_size=$((1024*1024))

# percent of new package above which the delta will be discarded
max_delta_size=70


# ensure we have a sane umask set
umask 0022

plain() {
	(( QUIET )) && return
	local mesg=$1; shift
	printf "${BOLD}    ${mesg}${ALL_OFF}\n" "$@" >&1
}

msg() {
	(( QUIET )) && return
	local mesg=$1; shift
	printf "${GREEN}==>${ALL_OFF}${BOLD} ${mesg}${ALL_OFF}\n" "$@" >&1
}

msg2() {
	(( QUIET )) && return
	local mesg=$1; shift
	printf "${BLUE}  ->${ALL_OFF}${BOLD} ${mesg}${ALL_OFF}\n" "$@" >&1
}

ask() {
	local mesg=$1; shift
	printf "${BLUE}::${ALL_OFF}${BOLD} ${mesg}${ALL_OFF}" "$@" >&1
}

warning() {
	local mesg=$1; shift
	printf "${YELLOW}==> $(gettext "WARNING:")${ALL_OFF}${BOLD} ${mesg}${ALL_OFF}\n" "$@" >&2
}

error() {
	local mesg=$1; shift
	printf "${RED}==> $(gettext "ERROR:")${ALL_OFF}${BOLD} ${mesg}${ALL_OFF}\n" "$@" >&2
}

if [[ -n "$MSYSTEM" ]]; then
  readonly -a UTILS_NAME=('bsdtar'
                          'bzip2'
                          'bzr'
                          'cat'
                          'ccache'
                          'distcc'
                          'git'
                          'gpg'
                          'gzip'
                          'hg'
                          'lzip'
                          'lzop'
                          'openssl'
                          'svn'
                          'tput'
                          'uncompress'
                          'upx'
                          'xargs'
                          'xz'
                         )

  for wrapper in ${UTILS_NAME[@]}; do
    eval "
    ${wrapper}"'() {
      local UTILS_PATH="/usr/bin/"
      if ! type -p ${UTILS_PATH}${FUNCNAME[0]} >/dev/null; then
        error "$(gettext "Cannot find the %s binary required for makepkg.")" "${UTILS_PATH}${FUNCNAME[0]}"
        exit 1
      fi
      ${UTILS_PATH}${FUNCNAME[0]} "$@"
    }'
  done
fi


# print usage instructions
usage() {
	printf "pkgdelta (pacman) %s\n" "${myver}"
	echo
	printf -- "$(gettext "Usage: pkgdelta [options] <package1> <package2>\n")"
	echo
	printf -- "$(gettext "\
pkgdelta will create a delta file between two packages.\n\
This delta file can then be added to a database using repo-add.\n")"
	echo
	printf -- "$(gettext "Example:  pkgdelta pacman-3.0.0.pkg.tar.gz pacman-3.0.1.pkg.tar.gz")\n"
	echo
	printf -- "$(gettext "Options:\n")"
	printf -- "$(gettext "  -q, --quiet       minimize output\n")"
	printf -- "$(gettext "  --nocolor         remove color from output\n")"
	printf -- "$(gettext "  --min-pkg-size    minimum package size before deltas are generated\n")"
	printf -- "$(gettext "  --max-delta-size  percent of new package above which the delta will be discarded\n")"
}

version() {
	printf "pkgdelta (pacman) %s\n" "$myver"
	printf -- "$(gettext "\
Copyright (c) 2009 Xavier Chantry <shiningxc@gmail.com>.\n\n\
This is free software; see the source for copying conditions.\n\
There is NO WARRANTY, to the extent permitted by law.\n")"
}

human_to_size() {
  awk -v human="$1" '
  function trim(s) {
    gsub(/^[[:space:]]+|[[:space:]]+$/, "", s)
    return s
  }

  function parse_units(units) {
    if (!units || units == "B")
      return 1
    if (match(units, /^.iB$/))
      return 1024
    if (match(units, /^.B$/))
      return 1000
    if (length(units) == 1)
      return 1024

    # parse failure: invalid base
    return -1
  }

  function parse_scale(s) {
    return index("BKMGTPE", s) - 1
  }

  function isnumeric(string) {
    return match(string, /^[-+]?[[:digit:]]*(\.[[:digit:]]*)?/)
  }

  BEGIN {
    # peel off the leading number as the size, fail on invalid number
    human = trim(human)
    if (isnumeric(human))
      size = substr(human, RSTART, RLENGTH)
    else
      exit 1

    # the trimmed remainder is assumed to be the units
    units = trim(substr(human, RLENGTH + 1))

    base = parse_units(units)
    if (base < 0)
      exit 1

    scale = parse_scale(substr(units, 1, 1))
    if (scale < 0)
      exit 1

    printf "%d\n", size * base^scale + (size + 0 > 0 ? 0.5 : -0.5)
  }'
}


isnumeric() {
	[[ $1 != *[!0-9]* ]]
}

read_pkginfo() {
	unset pkgver pkgname arch
	while IFS='=' read -r field value; do
		# skip comments and invalid lines
		[[ $field = '#'* || -z $value ]] && continue

		# skip lines which aren't fields we care about
		[[ $field != @(pkgver|pkgname|arch) ]] || continue

		declare -g "${field% }=${value# }"

		[[ $pkgname && $pkgver && $arch ]] && return 0
	done < <(bsdtar -xOqf "$1" .PKGINFO 2>/dev/null)

	error "$(gettext "Invalid package file '%s'.")" "$1"
	return 1
}

# $oldfile $oldmd5 $newfile $newmd5 $deltafile $deltamd5 $deltasize
create_xdelta()
{
	local oldfile=$1
	local newfile=$2
	local \
	oldname oldver oldarch \
	newname newver newarch \
	deltafile

	read_pkginfo "$oldfile" || return 1
	oldname="$pkgname"
	oldver="$pkgver"
	oldarch="$arch"
	read_pkginfo "$newfile" || return 1
	newname="$pkgname"
	newver="$pkgver"
	newarch="$arch"

	pkgsize="$(wc -c "$newfile" | cut -d' ' -f1)"

	if ((pkgsize < min_pkg_size)); then
		msg "$(gettext "Skipping delta creation for small package: %s - size %s")" "$newname" "$pkgsize"
		return 0
	fi

	if [[ $oldname != "$newname" ]]; then
		error "$(gettext "The package names don't match : '%s' and '%s'")" "$oldname" "$newname"
		return 1
	fi

	if [[ $oldarch != "$newarch" ]]; then
		error "$(gettext "The package architectures don't match : '%s' and '%s'")" "$oldarch" "$newarch"
		return 1
	fi

	if [[ $oldver == "$newver" ]]; then
		error "$(gettext "Both packages have the same version : '%s'")" "$newver"
		return 1
	fi

	msg "$(gettext "Generating delta from version %s to version %s")" "$oldver" "$newver"
	deltafile=$(dirname "$newfile")/$pkgname-${oldver}_to_${newver}-$arch.delta
	local ret=0

	xdelta3 -q -f -9 -S lzma -s "$oldfile" "$newfile" "$deltafile" || ret=$?
	if (( ret )); then
		error "$(gettext "Delta could not be created.")"
		return 1
	fi

	deltasize="$(wc -c "$deltafile" | cut -d' ' -f1)"

	if ((max_delta_size * pkgsize / 100 < deltasize)); then
		msg "$(gettext "Delta package larger than maximum size. Removing.")"
		rm -f "$deltafile"
		return 0
	fi

	msg "$(gettext "Generated delta : '%s'")" "$deltafile"
	(( QUIET )) && echo "$deltafile"

	return 0
}

OPT_SHORT='hqV'
OPT_LONG=('help' 'quiet' 'max-delta-size:' 'min-pkg-size:' 'nocolor' 'version')
if ! parseopts "$OPT_SHORT" "${OPT_LONG[@]}" -- "$@"; then
	exit 1
fi
set -- "${OPTRET[@]}"
unset OPT_SHORT OPT_LONG OPTRET

# determine whether we have gettext; make it a no-op if we do not
if ! type -p gettext >/dev/null; then
	gettext() {
		printf "%s\n" "$@"
	}
else
	gettext() {
		/usr/bin/gettext "$@"
	}
fi

# parse arguments
while :; do
	case $1 in
		-h|--help)
			usage
			exit 0 ;;
		-V|--version)
			version
			exit 0 ;;
		-q|--quiet)
			QUIET=1;;
		--nocolor)
			USE_COLOR='n';;
		--min-pkg-size)
			if ! min_pkg_size=$(human_to_size "$2"); then
				echo "invalid argument '$2' for option -- '$1'"
				exit 1
			fi
			shift ;;
		--max-delta-size)
			arg=$(awk -v val="$2" 'BEGIN { print val * 100 }')
			if ! isnumeric "$arg" || (( arg > 200 )); then
				echo "invalid argument '$2' for option -- '$1'"
				exit 1
			fi
			max_delta_size=$arg
			shift ;;
		--)
			shift
			break ;;
	esac
	shift
done

# check if messages are to be printed using color
unset ALL_OFF BOLD BLUE GREEN RED YELLOW
if [[ -t 2 && ! $USE_COLOR = "n" ]]; then
	# prefer terminal safe colored and bold text when tput is supported
	if tput setaf 0 &>/dev/null; then
		ALL_OFF="$(tput sgr0)"
		BOLD="$(tput bold)"
		BLUE="${BOLD}$(tput setaf 4)"
		GREEN="${BOLD}$(tput setaf 2)"
		RED="${BOLD}$(tput setaf 1)"
		YELLOW="${BOLD}$(tput setaf 3)"
	else
		ALL_OFF="\e[1;0m"
		BOLD="\e[1;1m"
		BLUE="${BOLD}\e[1;34m"
		GREEN="${BOLD}\e[1;32m"
		RED="${BOLD}\e[1;31m"
		YELLOW="${BOLD}\e[1;33m"
	fi
fi
readonly ALL_OFF BOLD BLUE GREEN RED YELLOW


if (( $# != 2 )); then
	usage
	exit 1
fi

for i in "$@"; do
	if [[ ! -f $i ]]; then
		error "$(gettext "File '%s' does not exist")" "$i"
		exit 1
	fi
done

if ! type xdelta3 &>/dev/null; then
	error "$(gettext "Cannot find the xdelta3 binary! Is xdelta3 installed?")"
	exit 1
fi

create_xdelta "$@"