#!/bin/bash
# shellcheck source=kz-common.sh
###############################################################################
# Apps installeren.
#
# Geschreven door Karel Zimmer <info@karelzimmer.nl>.
###############################################################################
PROGRAM_PATH=$(realpath "$(dirname  "$0")")
source "$PROGRAM_PATH"/kz-common.sh
PROGRAM_NAME=kz-install
DISPLAY_NAME=${PROGRAM_NAME/kz-/kz }
RELEASE_YEAR=2009

VERSION_NUMBER=59.04.01
VERSION_DATE=2021-10-01


###############################################################################
# Global constants
###############################################################################

readonly RUN_AS_SUPERUSER=true
readonly OPTIONS_SHORT=$OPTIONS_SHORT_COMMON'ace:filrs'
readonly OPTIONS_LONG=$OPTIONS_LONG_COMMON",apps,cat,edition:,files,info,list,\
remove,simulate"
readonly USAGE="Gebruik: $DISPLAY_NAME [-a|--apps] [-c|--cat] \
[-e|--edition=EDITIE] [-f|--files]
                    [-i|--info] [-l|--list] [-r|--remove] [-s|--simulate]
                    $OPTIONS_USAGE_COMMON
                    [APP...] [BESTAND...]"
readonly HELP="Gebruik: $DISPLAY_NAME [OPTIE...] [APP...] [BESTAND...]

Apps installeren.

Opties:
  -a --apps     toon lijst van te installeren apps
  -c --cat      toon inhoud van installatiebestanden
  -e --edition=EDITIE
                gebruik opgegeven editie
  -f --files    toon lijst van beschikbare installatiebestanden
  -i --info     toon aanvullende instructies na het installeren van apps
  -l --list     maak applijst aan
  -r --remove   toon instructies voor het verwijderen van apps
  -s --simulate geen actie, simuleer installatie, en toon opdracht die
                uitgevoerd zou worden
$OPTIONS_HELP_COMMON

Argumenten:
  APP           opgegeven apps installeren
  BESTAND       opgegeven installatiebestanden verwerken"

DASHES=$(printf '%.0s=' {1..79}); readonly DASHES
readonly EDITION_DEFAULT=desktop
SPACES=$(printf '%.0s ' {1..79}); readonly SPACES
VERSION=$(lsb_release --release --short); readonly VERSION
readonly LIST_FILE=/usr/local/etc/${PROGRAM_NAME}-applist
CMDS_FILE=$(mktemp -t "$PROGRAM_NAME-XXXXXXXXXX.cmds"); readonly CMDS_FILE
TEXT_FILE=$(mktemp -t "$PROGRAM_NAME-XXXXXXXXXX.text"); readonly TEXT_FILE
TEMP_LIST=$(mktemp -t "$PROGRAM_NAME-XXXXXXXXXX.list"); readonly TEMP_LIST

# Less-opties, overgenomen (en aangepast, zie 'man less', zoek PROMPTS)
# van:
# 1. systemctl en journalctl, zie bijv. 'man systemctl', zoek LESS
#    ("FRSXMK")
# 2. man, zie 'mam man', zoek LESS
readonly LESS_OPTIONS="--LONG-PROMPT --no-init --quit-if-one-screen \
--quit-on-intr --RAW-CONTROL-CHARS --prompt=M Tekstuitvoer $PROGRAM_NAME \
?ltregel %lt?L/%L.:byte %bB?s/%s..? .?e (EINDE) :?pB %pB\%. .(druk h voor \
hulp of q voor stoppen)"


###############################################################################
# Global variables
###############################################################################

declare -a  APP_ARGUMENT=()
declare -a  FILE_ARGUMENT=()
declare -a  FILE_TO_PROCESS=()
declare     ARGUMENT_APP=false
declare     ARGUMENT_FILE=false
declare     COMMANDS_FOUND=false
declare     EDITION=$EDITION_DEFAULT
declare     EDITION_ARGUMENT=''
declare     EXECUTE_COMMANDS=true
declare -i  MAXRC=0
declare     INFO_FOUND=false
declare     OPTION_APPS=false
declare     OPTION_CAT=false
declare     OPTION_EDITION=false
declare     OPTION_FILES=false
declare     OPTION_INFO=false
declare     OPTION_LIST=false
declare     OPTION_REMOVE=false
declare     OPTION_SIMULATE=false
declare     REMOVE_FOUND=false

# Terminalattributen, zie 'man terminfo'.  Gebruik ${<variabele-naam>}.
declare     CARRIAGE_RETURN=''
declare     BLINK=''
declare     CURSOR_INVISABLE=''
declare     CURSOR_VISABLE=''


###############################################################################
# Functions
###############################################################################

check_input() {
    local   -i  app_arg_num=0
    local   -i  file_arg_num=0
    local   -i  getopt_rc=0
    local       parsed=''

    parsed=$(
        getopt  --alternative                       \
                --options       "$OPTIONS_SHORT"    \
                --longoptions   "$OPTIONS_LONG"     \
                --name          "$DISPLAY_NAME"     \
                --              "$@"
        )       || getopt_rc=$?
    if [[ $getopt_rc -ne $SUCCESS ]]; then
        printf '%s\n' "$USAGELINE" >&2
        exit $ERROR
    fi
    eval set -- "$parsed"
    process_common_options "$@"
    STATUS_ERROR="[${RED}FOUT${NORMAL}]"
    STATUS_SUCCESS="[${GREEN}GOED${NORMAL}]"

    while true; do
        case $1 in
            -a|--apps)
                OPTION_APPS=true
                shift
                ;;
            -c|--cat)
                OPTION_CAT=true
                shift
                ;;
            -e|--edition)
                if $OPTION_EDITION; then
                    TEXT="optie '$1' eenmaal opgeven"
                    printf  "$DISPLAY_NAME: %s\n%s\n"   \
                            "$TEXT"                     \
                            "$USAGELINE"                >&2
                    exit    $ERROR
                else
                    OPTION_EDITION=true
                    EDITION_ARGUMENT=$2
                    EDITION=$EDITION_ARGUMENT
                fi
                shift 2
                ;;
            -f|--files)
                OPTION_FILES=true
                shift
                ;;
            -i|--info)
                OPTION_INFO=true
                EXECUTE_COMMANDS=false
                shift
                ;;
            -l|--list)
                OPTION_LIST=true
                EXECUTE_COMMANDS=false
                shift
                ;;
            -r|--remove)
                OPTION_REMOVE=true
                EXECUTE_COMMANDS=false
                shift
                ;;
            -s|--simulate)
                OPTION_SIMULATE=true
                EXECUTE_COMMANDS=false
                shift
                ;;
            --)
                shift
                break
                ;;
            *)
                shift
                ;;
        esac
    done

    if ! $OPTION_GUI && [[ -t 1 ]]; then
        # Tekstuitvoer non-gui naar de terminal.
        CARRIAGE_RETURN=$(tput cr)
        BLINK=$(tput blink)
        CURSOR_INVISABLE=$(tput civis)
        CURSOR_VISABLE=$(tput cvvis)
    fi
    STATUS_BUSY="[${BLINK}${BOLD}WERK${NORMAL}]"

    # Verwerk argumenten.
    while [[ "$*" ]]; do
        if [[ "$(basename "$1")" = $PROGRAM_NAME-*.sh ]]; then
            ARGUMENT_FILE=true
            FILE_ARGUMENT[$file_arg_num]=$1
            ((++file_arg_num))
            shift
        else
            ARGUMENT_APP=true
            APP_ARGUMENT[$app_arg_num]=$1
            ((++app_arg_num))
            shift
        fi
    done
}


process_input() {
    local       file=''
    local       file_notfound=false
    local   -i  app_seq_num=0
    local   -i  app_tot_num=0
    local   -i  file_num=0
    local       skip_line=false

    if $OPTION_LIST; then
        check_user
        process_option_list
        exit $SUCCESS
    fi
    if $ARGUMENT_APP; then
        process_argument_app
    fi
    if $ARGUMENT_FILE; then
        process_argument_file
    fi

    # Als argument APP of FILE is opgegeven, geen standaardbestanden verwerken.
    if ! ($ARGUMENT_APP || $ARGUMENT_FILE); then
        process_dfltfiles
    fi

    # Verwerk opties.
    if $OPTION_APPS; then
        process_option_apps
        exit $SUCCESS
    elif $OPTION_FILES; then
        process_option_files
        exit $SUCCESS
    fi

    # Ergens hiervoor ging het niet helemaal goed.
    if $file_notfound; then
        exit $SUCCESS
    fi

    # Optie cat is afhankelijk van argumenten APP en FILE.
    if $OPTION_CAT; then
        process_option_cat
        exit $SUCCESS
    fi

    # We gaan opdrachten uitvoeren, mogen we dat wel?
    if $EXECUTE_COMMANDS; then
        check_user
        check_on_ac_power
    fi

    # We gaan opdrachten uitvoeren of simuleren.
    for file in "${FILE_TO_PROCESS[@]}"; do
        cat "$file" >> "$CMDS_FILE"
    done

    # 'if ! grep --regexp='^#2'...; then...' werkt niet; grep geeft 0
    # terug als niets gevonden, is OK, maar dan ook rc=1, is niet OK.
    app_tot_num=$(
        grep --word-regexp --regexp='^#2' --count "$CMDS_FILE" || true
        )

    if $EXECUTE_COMMANDS && $OPTION_GUI; then
        TITLE='Apps installeren'
        TEXT=''
        # Met "|& zenity --progress" worden globale variabelen uit
        # aangeroepen functies niet doorgegeven, vandaar de
        # 'process substitution' met "> >(zenity...)".
        process_file > >(
            zenity  --progress              \
                    --pulsate               \
                    --auto-close            \
                    --no-cancel             \
                    --width     700         \
                    --height    50          \
                    --title     "$TITLE"    \
                    --text      "$TEXT"     2> >($LOGCMD)
            )
    else
        process_file
    fi
}


process_option_list() {
    local text0='Opdrachten worden verwerkt'
    local text1="[1/3]  Bepaal welke pakketten handmatig zijn geinstalleerd"
    local text3='[2/3]  Bepaal welke snaps zijn geinstalleerd'
    local text2="[3/3]  Bepaal welke pakketbronnen zijn toegevoegd"

    TITLE='Applijst maken'
    if $OPTION_GUI; then
        (
        printf '%s\n' "#$text1"
        create_list_manual_installed    #1
        printf '%s\n' "#$text2"
        create_list_snaps               #2
        printf '%s\n' "#$text3"
        create_list_added_repos         #3
        ) |&
        zenity  --progress              \
                --pulsate               \
                --auto-close            \
                --no-cancel             \
                --width     600         \
                --height    50          \
                --title     "$TITLE"    \
                --text      "$text0"    2> >($LOGCMD)
    else
        create_list_manual_installed    #1
        create_list_snaps               #2
        create_list_added_repos         #3
    fi

    info "
De applijst is vastgelegd in bestand $LIST_FILE.
Dit bestand bevatten de eerder geinstalleerde apps.
Dit bestand kan worden gebruikt voor het nalopen van de installatie."
}


create_list_manual_installed() {        #1
    local       header="1. Deze pakketten zijn handmatig geinstalleerd via \
Software of
   met een opdracht zoals 'sudo apt-get --install <pakket|bestand>':"
    local       footer=''
    local   -i  number_of_lines=0
    local       plural='geinstalleerde pakketten'

    printf '%s\n' "$text1..."
    printf '%b\n' "$header\n$DASHES" > "$TEMP_LIST"

    apt list --manual-installed 2> >($LOGCMD) >> "$TEMP_LIST"

    number_of_lines=$(wc --lines < "$TEMP_LIST")
    number_of_lines=$((number_of_lines - 4))
    if [[ $number_of_lines -eq 1 ]]; then
        plural='geinstalleerd pakket'
    fi
    footer="Dit overzicht bevat $number_of_lines handmatig $plural."
    printf '%b\n' "$DASHES\n$footer\n" >> "$TEMP_LIST"

    cat "$TEMP_LIST" > "$LIST_FILE"
}


create_list_snaps() {                   #2
    local       header="2. Deze snaps zijn geinstalleerd met '[sudo] install \
<snap>' of met Software:"
    local       footer=''
    local   -i  number_of_lines=0
    local       plural='snaps'

    printf '%s\n' "$text3..."
    printf '%b\n' "$header\n$DASHES" > "$TEMP_LIST"

    if ! snap list 2> /dev/null >> "$TEMP_LIST"; then
        TEXT='snap is niet geinstalleerd op dit systeem'
        printf '%s\n' "$TEXT" >> "$TEMP_LIST"
    fi

    number_of_lines=$(wc --lines < "$TEMP_LIST")
    number_of_lines=$((number_of_lines - 3))
    if [[ $number_of_lines -eq 1 ]]; then
        plural='snap'
    fi
    footer="Dit overzicht bevat $number_of_lines $plural."
    printf '%b\n' "$DASHES\n$footer\n" >> "$TEMP_LIST"

    cat "$TEMP_LIST" >> "$LIST_FILE"
}


create_list_added_repos() {                 #3
    local       header="3. Deze pakketbronnen zijn toegevoegd met de \
installatie van een pakket of
   met de opdracht 'sudo add-apt-repository ppa:<ppa-gebruiker>/<ppa-naam>':"
    local       footer=''
    local   -i  number_of_lines=0
    local       plural='pakketbronnen'
    local       search=''

    printf '%s\n' "$text2..."
    printf '%b\n' "$header\n$DASHES" > "$TEMP_LIST"

    search=/etc/apt/sources.list
    cd  $search.d || exit $ERROR
    if !    grep    --recursive             \
                    --no-filename           \
                    --regexp='^deb '        \
                    --recursive             \
                    /etc/apt/sources.list   \
                    /etc/apt/sources.list.d |
            grep    --invert-match          \
                    --regexp='ubuntu.com'   |
            sort    --unique                >> "$TEMP_LIST"; then
        true
    fi

    number_of_lines=$(wc --lines < "$TEMP_LIST")
    number_of_lines=$((number_of_lines - 3))
    if [[ $number_of_lines -eq 1 ]]; then
        plural='pakketbron'
    fi
    footer="Dit overzicht bevat $number_of_lines toegevoegde $plural."
    printf '%b\n' "$DASHES\n$footer" >> "$TEMP_LIST"

    cat "$TEMP_LIST" >> "$LIST_FILE"
}


process_argument_app() {
    local       app=''
    local       file=''
    local   -a  files=()
    local       search=''
    local       cmds_file=''

    cmds_file=$(mktemp -t "$PROGRAM_NAME-XXXXXXXXXX.cmds")
    # Install zoekt naar apps in alle kz-install-<distro>-<versie>-bestanden
    # en stopt bij de eerstgevonden (installatie is computer-onafhankelijk),
    # setup zoekt naar apps in kz-install-<distro>-<versie>-<edition>.sh en
    # kz-install-<distro>-<versie>-<edition>-<computernaam>.sh.
    search=$PROGRAM_NAME-$DISTRO-$VERSION
    for file in "$PROGRAM_PATH/$search"*.sh; do
        files+=("$file")
    done
    for app in "${APP_ARGUMENT[@]}"; do
        file=$(
            if ! grep       --files-with-matches    \
                            --line-regexp           \
                            --regexp="#1 $app"      \
                            "${files[@]}"           \
                            2> /dev/null            |
                    head    --lines=1; then
                printf '\n'
            fi
            )
        if [[ $file ]]; then
            process_argument_app_file
        else
            info "App '$app' niet gevonden."
            file_notfound=true
        fi
    done
    if $file_notfound; then
        info "Typ '$DISPLAY_NAME --apps' voor beschikbare apps."
    else
        if ! grep --quiet --line-regexp --regexp='# EOF' "$cmds_file"
        then
            printf '%s\n' '# EOF' >> "$cmds_file"
        fi
        FILE_TO_PROCESS[$file_num]=$cmds_file
        ((++file_num))
    fi
}


process_argument_app_file() {
    local app_found=false
    local description_found=false
    local record=''

    while read -r record; do
        case $record in
            '#1 '*)
                if [[ $record = '#1 '$app ]]; then
                    if $app_found; then
                        info "Dubbele app-naam $app."
                    else
                        # Gezochte app-naam.
                        # Regels doorschrijven naar tijdelijk bestand tot
                        # eerstvolgende app-naam of beschrijving (verplicht),
                        # of tot EOF.
                        app_found=true
                    fi
                elif $app_found; then
                    # Volgende app-naam.
                    break
                fi
                ;;
            '#2'*)
                # Beschrijving.
                if $description_found; then
                    # Volgende beschrijving.
                    break
                elif $app_found; then
                    printf '%b\n' "$record" >> "$cmds_file"
                    description_found=true
                fi
                ;;
            *)
                # Overige regels.
                if $app_found; then
                    printf '%s\n' "$record" >> "$cmds_file"
                fi
                ;;
        esac
    done < "$file"
}


process_argument_file() {
    local file=''

    for file in "${FILE_ARGUMENT[@]}"; do
        if [[ -e $file ]]; then
            FILE_TO_PROCESS[$file_num]=$file
            ((++file_num))
        else
            info "Bestand $file niet gevonden."
            file_notfound=true
        fi
    done
    if $file_notfound; then
        info "Typ '$DISPLAY_NAME --files' voor beschikbare \
installatiebestanden."
    fi
}


process_dfltfiles() {
    local dfltfile_1=''
    local dfltfile_2=''

    dfltfile_1=$PROGRAM_PATH/$PROGRAM_NAME-$DISTRO-$VERSION-$EDITION.sh
    dfltfile_2=$PROGRAM_PATH/$PROGRAM_NAME-$DISTRO-$VERSION-$EDITION-\
$HOSTNAME.sh

    if [[ -e $dfltfile_1 ]]; then
        FILE_TO_PROCESS[$file_num]=$dfltfile_1
        ((++file_num))
    else
        file_notfound=true
    fi
    # Niet verplicht aanwezig.
    if [[ -e $dfltfile_2 ]]; then
        FILE_TO_PROCESS[$file_num]=$dfltfile_2
        ((++file_num))
    fi
    if $file_notfound; then
        info "Geen installatiebestanden gevonden voor $DISTRO $VERSION \
$EDITION."
        exit $WARNING
    fi
}


process_option_apps() {
    local   -a  files=()
    local       search=''

    # Install zoekt naar apps in alle kz-install-<distro>-<versie>-bestanden
    # en stopt bij de eerstgevonden (installatie is computer-onafhankelijk),
    # setup zoekt naar apps in kz-install-<distro>-<versie>-<edition>.sh en
    # kz-install-<distro>-<versie>-<edition>-<computernaam>.sh.
    search=$PROGRAM_NAME-$DISTRO-$VERSION
    for file in "$PROGRAM_PATH/$search"*.sh; do
        files+=("$file")
    done
    printf '%s\n' "De volgende apps zijn beschikbaar:

NUMMER APP
$(
    if !    grep    --no-messages           \
                    --regexp='^#1 '         \
                    "${files[@]}"           |
            awk     '{print $2}'            |
            sort    --unique                |
            nl      --number-width=6        \
                    --number-format=rn      \
                    --number-separator=' '  \
                    --body-numbering=a; then
        printf '%s\n' "     0 Geen apps gevonden voor $DISTRO $VERSION."
    else
        printf '%s\n' "
Om APPs te bekijken voer uit:
    ${BLUE}$DISPLAY_NAME --sim APP...${NORMAL}
    ${BLUE}$DISPLAY_NAME --cat APP...${NORMAL}
Om APPs te installeren voer uit:
    ${BLUE}$DISPLAY_NAME APP...${NORMAL}"
    fi
)"
}


process_option_files() {
    printf '%s\n' "De volgende installatiebestanden zijn beschikbaar:

NUMMER BESTAND
$(
    if !    find    "${FILE_TO_PROCESS[@]}" \
                    2> /dev/null            |
            nl      --number-width=6        \
                    --number-format=rn      \
                    --number-separator=' '  \
                    --body-numbering=a; then
        printf '%s\n' "     0 Geen installatiebestanden gevonden voor $DISTRO \
$VERSION $EDITION.
Typ 'man $DISPLAY_NAME' voor meer informatie."
    else
        printf '%s\n' "
Om BESTANDen te bekijken voer uit:
    ${BLUE}$DISPLAY_NAME --sim BESTAND...${NORMAL}
    ${BLUE}$DISPLAY_NAME --cat BESTAND...${NORMAL}
Om BESTANDen te gebruiken voer uit:
    ${BLUE}$DISPLAY_NAME BESTAND...${NORMAL}"
    fi
)"
}


process_option_cat() {
    for file in "${FILE_TO_PROCESS[@]}"; do
        {
            printf '%s\n' "${BLUE}# $file${NORMAL}"
            cat "$file"
            printf '\n'
        }   >> "$CMDS_FILE"
    done
    if $OPTION_GUI; then
        TITLE='Inhoud installatiebestanden'
        if ! zenity --text-info                         \
                    --width         850                 \
                    --height        400                 \
                    --title         "$TITLE"            \
                    --filename      "$CMDS_FILE"        \
                    --font          'Ubuntu Mono 12'    \
                    --ok-label      'Oké'               \
                    --cancel-label  'Annuleren'         2> >($LOGCMD); then
            true
        fi
    else
        less "$LESS_OPTIONS" "$CMDS_FILE"
    fi
}


process_file() {
    local       description=''
    local   -i  cmd_seq_num=0
    local       prev_recordtype=''
    local       record=''
    local       recordtype=''
    local       write_description_line=true

    if $EXECUTE_COMMANDS; then
        printf '%b' "${CURSOR_INVISABLE}"
    fi
    $skip_line && printf '\n'; skip_line=true

    while read -r record; do
        recordtype=${record:0:2}
        case $recordtype in
            ''|'#1')
                # Lege regel of lege app-naam.
                continue
                ;;
            '#2')
                process_description "$record"
                ;;
            '#3')
                process_install_instruction "$record"
                ;;
            '#4')
                process_remove_instruction "$record"
                ;;
            '#'*)
                # Commentaarregel.
                continue
                ;;
            *)
                process_command "$record"
                ;;
        esac
        prev_recordtype=$recordtype
    done < "$CMDS_FILE"

    if $EXECUTE_COMMANDS; then
        printf '%b' "${CURSOR_VISABLE}"
    fi
}


process_description() {
    local record=${1:-record?}

    description="${record:3}"
    if ! $OPTION_SIMULATE && ! $EXECUTE_COMMANDS; then
        return $SUCCESS
    fi

    write_description_line=true
    ((++app_seq_num))
    cmd_seq_num=0
}


process_install_instruction() {
    local       record=${1:-record?}
    local       filler=''
    local   -i  len=0

    INFO_FOUND=true
    if ! $OPTION_INFO; then
        return $SUCCESS
    fi
    filler=${SPACES:0:8}
    if [[ $prev_recordtype = '#3' ]]; then
        printf  '%s%s\n\n' "$filler" "${record:3}" >> "$TEXT_FILE"
    else
        ((++app_seq_num))
        len=${#description}
        # ?? wordt in term_script vervangen door aantal te installeren apps.
        printf  "\n[%2d/??] %s\n%s%.${len}s\n\n%s%s\n\n"    \
                "$app_seq_num"  "$description"              \
                "$filler"       "$DASHES"                   \
                "$filler"       "${record:3}"               >> "$TEXT_FILE"
    fi
}


process_remove_instruction() {
    local       record=${1:-record?}
    local       filler=''
    local   -i  len=0

    REMOVE_FOUND=true
    if ! $OPTION_REMOVE; then
        return $SUCCESS
    fi
    filler=${SPACES:0:8}
    if [[ $prev_recordtype = '#4' ]]; then
        printf  '%s%s\n\n' "$filler" "${record:3}" >> "$TEXT_FILE"
    else
        ((++app_seq_num))
        len=${#description}
        # ?? wordt in term_script vervangen door aantal te te verwijderen apps.
        printf  "\n[%2d/??] %s\n%s%.${len}s\n\n%s%s\n\n"    \
                "$app_seq_num"  "$description"              \
                "$filler"       "$DASHES"                   \
                "$filler"       "${record:3}"               >> "$TEXT_FILE"
    fi
}


process_command() {
    local       cmd=${1:-cmd?}
    local   -i  cmd_rc=0
    local       description_line=''
    local   -i  desc_maxlen=1000
    local       desc_printf=''
    local       status=''

    COMMANDS_FOUND=true
    ((++cmd_seq_num))

    if $OPTION_SIMULATE; then
        if $write_description_line; then
            printf  '[%3d/%-3d] %s\n\n' \
                    "$app_seq_num"      \
                    "$app_tot_num"      \
                    "$description"      >> "$TEXT_FILE"
            write_description_line=false
        fi
        printf  '%9s [%2d] %s\n\n'          \
                " "                         \
                "$cmd_seq_num"              \
                "${BLUE}$record${NORMAL}"   >> "$TEXT_FILE"
    elif $EXECUTE_COMMANDS; then
        desc_printf=$description
        if $OPTION_GUI; then
            TEXT="#[$app_seq_num/$app_tot_num] $description\n\n$record"
            printf '%s\n' "$TEXT"
        else
            if [[ -t 1 ]]; then
                # Afbreken in Terminalvenster moet i.v.m. updaten status.
                #  <------------- tput cols ------------->
                # '[WERK] [  1/1  ] [ 1] Te lange descr...' <=== op 1 regel
                #  <-------- 22 -------->
                desc_maxlen=$(($(tput cols) - 22))
                if [[ ${#desc_printf} -gt $desc_maxlen ]]; then
                    desc_printf=${desc_printf:0:(($desc_maxlen - 3))}'...'
                fi
            fi
        fi
        printf  -v description_line                                 \
                "[%3d/%-3d] [%2d] %-${desc_maxlen}.${desc_maxlen}s" \
                "$app_seq_num"                                      \
                "$app_tot_num"                                      \
                "$cmd_seq_num"                                      \
                "$desc_printf"
        execute_command "$record"
    fi
}


execute_command() {
    local       cmd=${1:-cmd?}
    local   -i  cmd_rc=0
    local       status=''

    check_dpkg
    if ! $OPTION_GUI; then
        if [[ $cmd_seq_num -eq 1 ]]; then
            printf "$STATUS_BUSY %s${CARRIAGE_RETURN}" "$description_line"
        else
            printf  "$STATUS_BUSY ${SPACES:0:9}%s${CARRIAGE_RETURN}"    \
                    "${description_line:9}"
        fi
    fi

    log "$description_line"
    log "${BLUE}$cmd${NORMAL}"
    eval "$cmd" |& $LOGCMD || cmd_rc=$?
    if [[ $cmd_rc -gt $MAXRC ]]; then
        MAXRC=$cmd_rc
    fi
    if [[ $cmd_rc -eq $SUCCESS ]]; then
        status="$STATUS_SUCCESS"
    else
        status="$STATUS_ERROR"
    fi
    log "$status rc=$cmd_rc, maxrc=$MAXRC"
    printf '%s\n' "$status"
}


check_dpkg() {
    local -i wait_for_aptd=5

    if ls /snap/core/*/var/cache/debconf/config.dat &> /dev/null; then
        while sudo  fuser                                               \
                    /var/{lib/{dpkg,apt/lists},cache/apt/archives}/lock \
                    /var/cache/debconf/config.dat                       \
                    /snap/core/*/var/cache/debconf/config.dat           \
                    &> /dev/null; do
            log 'Wacht tot andere pakketbeheerder klaar is...'
            sleep $wait_for_aptd
        done
    else
        while sudo  fuser                                               \
                    /var/{lib/{dpkg,apt/lists},cache/apt/archives}/lock \
                    /var/cache/debconf/config.dat                       \
                    &> /dev/null; do
            log 'Wacht tot andere pakketbeheerder klaar is...'
            sleep $wait_for_aptd
        done
    fi
}


term_script() {
    local   -i  app_num=0

    if $OPTION_SIMULATE; then
        if $OPTION_GUI; then
            TITLE='Installatie-opdrachten'
            if ! zenity --text-info                         \
                        --width         1200                \
                        --height        400                 \
                        --title         "$TITLE"            \
                        --filename      "$TEXT_FILE"        \
                        --font          'Ubuntu Mono 12'    \
                        --ok-label      'Oké'               \
                        --cancel-label  'Annuleren'         2> >($LOGCMD); then
                true
            fi
        else
            less "$LESS_OPTIONS" "$TEXT_FILE"
        fi
    elif $OPTION_INFO && $INFO_FOUND; then
        printf '\n' >> "$TEXT_FILE"
        # Vervang ?? door aantal te installeren apps.
        app_num=$(grep --regexp='\??] ' --count "$TEXT_FILE")
        sed -i "s|/??] |/$(printf %-2d "$app_num")] |g" "$TEXT_FILE"
        if $OPTION_GUI; then
            TITLE='Installatie-instructies'
            if ! zenity --text-info                         \
                        --width         850                 \
                        --height        400                 \
                        --title         "$TITLE"            \
                        --filename      "$TEXT_FILE"        \
                        --font          'Ubuntu Mono 12'    \
                        --ok-label      'Oké'               \
                        --cancel-label  'Annuleren'         2> >($LOGCMD); then
                true
            fi
        else
            less "$LESS_OPTIONS" "$TEXT_FILE"
        fi
    elif $OPTION_INFO && ! $INFO_FOUND; then
        info 'Geen installatie-instructies.'
    elif $OPTION_REMOVE && $REMOVE_FOUND; then
        printf '\n' >> "$TEXT_FILE"
        # Vervang ?? door aantal te verwijderen apps.
        app_num=$(grep --regexp='\??] ' --count "$TEXT_FILE")
        sed -i "s|/??] |/$(printf %-2d "$app_num")] |g" "$TEXT_FILE"
        # Vervang 'installeren' door 'verwijderen' (even lang).
        sed --in-place --expression='s/installeren/verwijderen/g' "$TEXT_FILE"
        if $OPTION_GUI; then
            TITLE='Verwijder-instructies'
            if ! zenity --text-info                         \
                        --width         850                 \
                        --height        400                 \
                        --title         "$TITLE"            \
                        --filename      "$TEXT_FILE"        \
                        --font          'Ubuntu Mono 12'    \
                        --ok-label      'Oké'               \
                        --cancel-label  'Annuleren'         2> >($LOGCMD); then
                true
            fi
        else
            less "$LESS_OPTIONS" "$TEXT_FILE"
        fi
    elif $OPTION_REMOVE && ! $REMOVE_FOUND; then
        info 'Geen verwijder-instructies.'
    elif ! $COMMANDS_FOUND; then
        info 'Geen opdrachten.'
    fi

    if  $EXECUTE_COMMANDS && [[ $MAXRC -eq $SUCCESS ]] && $INFO_FOUND &&
        ! $OPTION_GUI; then
        info "
Er zijn aanvullende instructies!
Gebruik de opdracht:
    ${BLUE}$DISPLAY_NAME --info ${APP_ARGUMENT[*]}${NORMAL}"
    fi

    if $EXECUTE_COMMANDS && $OPTION_GUI; then
        if [[ $MAXRC -ne $SUCCESS ]]; then
            warning 'Installatie is geëindigd met een waarschuwing.'
            exit $WARNING
        else
            info 'Installatie is voltooid.'
            exit $SUCCESS
        fi
    fi
}


###############################################################################
# Main line
###############################################################################

main() {
    init_script "$@"
    check_input "$@"
    process_input
    term_script
}


main "$@"


# EOF