fixupOutputHooks+=(_patchPpdFileCommands4fixupOutputHooks)



# Install a hook for the `fixupPhase`:
# If the variable `ppdFileCommands` contains a list of
# executable names, the hook calls `patchPpdFileCommands`
# on each output's `/share/cups/model` and `/share/ppd`
# directories in order to replace calls to those executables.

_patchPpdFileCommands4fixupOutputHooks () {
    [[ -n $ppdFileCommands ]]  ||  return 0
    if [[ -d $prefix/share/cups/model ]]; then
        patchPpdFileCommands "$prefix/share/cups/model" $ppdFileCommands
    fi
    if [[ -d $prefix/share/ppd ]]; then
        patchPpdFileCommands "$prefix/share/ppd" $ppdFileCommands
    fi
}



# patchPpdFileCommands PPD-ROOT PROGNAME...
#
# Look for ppd files in the directory PPD-ROOT.
# Descend into subdirectories, even if they are symlinks.
# However, ignore ppd files that don't belong to the same
# prefix ($NIX_STORE/$package_name) as PPD-ROOT-DIR does,
# to avoid stepping into other package's directories.
# ppd files may be gzipped; if the are,
# uncompress them, later recompress them.
# Skip symlinks to ppd files.
# PPD-ROOT may also be a single ppd file.
#
# Look for the PROGNAME executable in outputs and `buildInputs`,
# then look for PROGNAME invocations in the ppd files,
# without path or with common paths like `/usr/bin/$PROGNAME`.
# Replace those invocations with an absolute path to the
# corresponding executable from the outputs or `buildInputs`.
# Executables are searched where CUPS would search them,
# i.e., in `/bin` and `/lib/cups/filter`.
#
# As soon as an executable's path is replaced as
# described above, the package containing the binary
# is added to the list of propagated build inputs.
# This ensures the executable's package is still
# recognized as runtime dependency of the ppd file
# even if the ppd file is compressed lateron.
#
# PROGNAME may not contain spaces or tabs.
# The function will also likely fail or produce
# broken results if PROGNAME contains characters that
# require shell or regex escaping (e.g. a backslash).

patchPpdFileCommands () {

    local bin binnew binold binoldgrep cupspath path ppdroot ppdrootprefix

    # we will store some temporary data here
    pushd "$(mktemp -d --tmpdir patch-ppd-file-commands.XXXX)"

    # remember the ppd root path
    [[ "$1" == $NIX_STORE/* ]]  # ensure it's a store directory
    ppdroot=$1
    shift  # now "$@" is the list of binaries
    ppdrootprefix=${ppdroot%"/${ppdroot#"$NIX_STORE"/*/}"}

    # create `cupspath` (where we should look for binaries),
    # with these priorities
    # * outputs of current build before buildInputs
    # * `/lib/cups/filter' before `/bin`
    # * add HOST_PATH at end, so we don't miss anything
    for path in $(getAllOutputNames); do
        addToSearchPath cupspath "${!path}/lib/cups/filter"
        addToSearchPath cupspath "${!path}/bin"
    done
    for path in ${pkgsHostTarget+"${pkgsHostTarget[@]}"}; do
        addToSearchPath cupspath "$path/lib/cups/filter"
        addToSearchPath cupspath "$path/bin"
    done
    while read -r -d : path; do
        addToSearchPath cupspath "$path"
    done  <<< "${HOST_PATH:+"${HOST_PATH}:"}"

    # create list of compressed ppd files
    # so we can recompress them later
    find -L "$ppdroot" -type f -iname '*.ppd.gz' '!' -xtype l -print0  > gzipped

    # decompress gzipped ppd files
    echo "patchPpdFileCommands: decompressing $(grep -cz '^' < gzipped) gzipped ppd file(s) in $ppdroot"
    xargs -0r -n 64 -P "$NIX_BUILD_CORES"  gunzip  < gzipped

    # create list of all ppd files to be checked
    find -L "$ppdroot" -type f -iname '*.ppd' '!' -xtype l -print0  > ppds

    for bin in "$@"; do

        # discover new path
        binnew=$(PATH=$cupspath '@which@/bin/which' "$bin")
        echo "patchPpdFileCommands: located binary $binnew"

        # for each binary, we look for the name itself, but
        # also for a couple of common paths that might be used
        for binold in {/usr,}/{lib/cups/filter,sbin,bin}/"$bin" "$bin"; do

            # escape regex characters in the old command string
            binoldgrep=$(sed 's,[]$.*[\^],\\&,g' <<< "$binold")
            # ...and surround old command with some regex
            # that singles out shell command invocations
            # to avoid replacing other strings that might contain the
            # command name by accident (like "perl" in "perl-script")
            binoldgrep='\(^\|[;&| '$'\t''"`(]\)'"$binoldgrep"'\($\|[);&| '$'\t''"`<>]\)'
            # this string is used to *quickly* filter out
            # unaffected files before the (slower) awk script runs;
            # note that a similar regex is build in the awk script;
            # if `binoldgrep` is changed, the awk script should also be checked

            # create list of likely affected files
            # (might yield exit status != 0 if there are no matches)
            xargs -0r  grep -lZ "$binoldgrep"  < ppds  > ppds-to-patch  ||  true

            echo "patchPpdFileCommands: $(grep -cz '^' < ppds-to-patch) ppd file(s) contain $binold"

            # actually patch affected ppd files with awk;
            # this takes some time but can be parallelized;
            # speed up with LC_ALL=C, https://stackoverflow.com/a/33850386
            LC_ALL=C xargs -0r -n 64 -P "$NIX_BUILD_CORES"  \
              awk -i inplace -v old="${binold//\\/\\\\}" -v new="${binnew//\\/\\\\}" -f "@awkscript@"  \
              < ppds-to-patch

        done

        # create list of affected files
        xargs -0r  grep -lZF "$binnew"  < ppds  > patched-ppds  ||  true

        echo "patchPpdFileCommands: $(grep -cz '^' < patched-ppds) ppd file(s) patched with $binnew"

        # if the new command is contained in a file,
        # remember the new path so we can add it to
        # the list of propagated dependencies later
        if [[ -s patched-ppds ]]; then
            printf '%s\0' "${binnew%"/${binnew#"${NIX_STORE}"/*/}"}"  >> dependencies
        fi

    done

    # recompress ppd files that have been decompressed before
    echo "patchPpdFileCommands: recompressing $(grep -cz '^' < gzipped) gzipped ppd file(s)"
    # we can't just hand over the paths of the uncompressed files
    # to gzip as it would add the lower-cased extension ".gz"
    # even for files where the original was named ".GZ"
    xargs -0r -n 1 -P "$NIX_BUILD_CORES"  \
      "$SHELL" -c 'gzip -9nS ".${0##*.}" "${0%.*}"'  \
      < gzipped

    # enlist dependencies for propagation;
    # this is needed in case ppd files are compressed later
    # (Nix won't find dependency paths in compressed files)
    if [[ -s dependencies ]]; then

        # weed out duplicates from the dependency list first
        sort -zu dependencies  > sorted-dependencies

        mkdir -p "$ppdrootprefix/nix-support"
        while IFS= read -r -d '' path; do
            printWords "$path" >> "$ppdrootprefix/nix-support/propagated-build-inputs"
            # stdenv writes it's own `propagated-build-inputs`,
            # based on the variable `propagatedBuildInputs`,
            # but only to one output (`outputDev`).
            # So we also add our dependencies to that variable.
            # If our file survives as written above, great!
            # If stdenv overwrits it,
            # our dependencies will still be added to the file.
            # The end result might contain too many
            # propagated dependencies for multi-output packages,
            # but never a broken package.
            appendToVar propagatedBuildInputs "$path"
        done  < sorted-dependencies
    fi

    popd

}
