#!/usr/bin/env bash
#
# rhel8-setup-interactive.sh
# -----------------------------------------------------------------------------
# Interaktive Nachkonfiguration eines frisch installierten RHEL8-Systems
# zur Vorbereitung einer abas-ERP-Installation.
#
# Aufruf (nach der RHEL-Grundinstallation, als root):
#   wget -O rhel8-setup-interactive.sh <URL>
#   chmod +x rhel8-setup-interactive.sh
#   ./rhel8-setup-interactive.sh
#
# Das Skript fragt jedes Feature per Y/n ab und geht alle Datenplatten
# (außer der OS-Platte) durch. Es ist idempotent: ein zweiter Lauf
# überspringt bereits erledigte Schritte.
#
# Mit DRY_RUN=1 ./rhel8-setup-interactive.sh werden potenziell
# destruktive Befehle nur angezeigt, nicht ausgeführt.
# -----------------------------------------------------------------------------

set -u

# ============================ Hilfsfunktionen ================================
C_R='\033[01;31m'; C_G='\033[01;32m'; C_Y='\033[01;33m'; C_B='\033[01;34m'; C_0='\033[00m'
log()  { echo -e "${C_G}[*]${C_0} $*"; }
warn() { echo -e "${C_Y}[!]${C_0} $*" >&2; }
err()  { echo -e "${C_R}[x]${C_0} $*" >&2; }
die()  { err "$*"; exit 1; }
hr()   { echo -e "${C_B}--------------------------------------------------------------${C_0}"; }

DRY_RUN="${DRY_RUN:-0}"
run() {
    if [ "$DRY_RUN" = "1" ]; then
        echo -e "${C_Y}DRY-RUN:${C_0} $*"
    else
        "$@"
    fi
}

AUTO="${AUTO:-0}"   # wird per --auto auf 1 gesetzt: bestätigt alle Defaults automatisch

# Y/n-Abfrage. Akzeptiert auch J/j (Ja). $2 = Default (y|n).
ask_yn() {
    local prompt="$1" def="${2:-y}" ans hint
    [ "$def" = "y" ] && hint="Y/n" || hint="y/N"
    if [ "$AUTO" = "1" ]; then
        echo -e "${C_B}[auto]${C_0} ${prompt} -> ${def}" >&2
        [[ "$def" =~ ^[YyJj] ]]; return
    fi
    read -r -p "$(echo -e "${C_B}[?]${C_0} ${prompt} [${hint}]: ")" ans
    ans="${ans:-$def}"
    [[ "$ans" =~ ^[YyJj] ]]
}

ask_val() {  # prompt default -> echo Antwort
    local prompt="$1" def="${2:-}" ans
    if [ "$AUTO" = "1" ]; then
        echo -e "${C_B}[auto]${C_0} ${prompt} -> ${def:-(leer)}" >&2
        echo "$def"; return
    fi
    if [ -n "$def" ]; then
        read -r -p "$(echo -e "${C_B}[?]${C_0} ${prompt} [${def}]: ")" ans
        echo "${ans:-$def}"
    else
        read -r -p "$(echo -e "${C_B}[?]${C_0} ${prompt}: ")" ans
        echo "$ans"
    fi
}

# ============================ Preflight ======================================
preflight() {
    [ "$(id -u)" -eq 0 ] || die "Bitte als root ausführen."
    if [ -r /etc/redhat-release ]; then
        if ! grep -qiE 'release 8' /etc/redhat-release; then
            warn "Dies scheint kein RHEL 8 zu sein: $(cat /etc/redhat-release)"
            ask_yn "Trotzdem fortfahren?" n || exit 1
        fi
    else
        warn "/etc/redhat-release nicht gefunden – evtl. kein RHEL."
        ask_yn "Trotzdem fortfahren?" n || exit 1
    fi
    [ "$DRY_RUN" = "1" ] && warn "DRY-RUN aktiv – es werden KEINE Änderungen vorgenommen."
}

# ============================ EPEL ===========================================
enable_epel() {
    hr; log "EPEL-Repository aktivieren"
    run subscription-manager repos --enable "codeready-builder-for-rhel-8-$(arch)-rpms" \
        || warn "CodeReady-Repo konnte nicht aktiviert werden."
    if ! rpm -q epel-release >/dev/null 2>&1; then
        run yum -y install https://dl.fedoraproject.org/pub/epel/epel-release-latest-8.noarch.rpm \
            || warn "epel-release konnte nicht installiert werden."
    else
        log "epel-release bereits installiert."
    fi
}

# ============================ Pakete =========================================
ABAS_PACKAGES=(
    net-tools ntsysv gdb cpp glibc mc nano screen xinetd Xvfb jq numad git lsof
    mlocate incron glibc.i686 vim-common time iotop htop pigz sysstat rsync
    perl-Net-SSLeay 'krb*' 'pdf*' 'guten*' 'hpli*' 'compat*' gcc parallel
    'cups-lpd*' 'cups-pdf*' 'cups-dev*' 'cups-pk*' 'psutils*' 'samba*' cifs-utils
    open-vm-tools acpid wget ncdu make gzip nmap zip libtool openvpn btop
    network-scripts moreutils langpacks-en glibc-all-langpacks python3 python3-pip
    bpytop fail2ban xorriso nfs-utils kernel-devel squashfs-tools sudo nload
    automake autoconf ghostscript poppler-utils netpbm netpbm-progs glibc-devel
    libXtst.x86_64 ncurses-compat-libs bc gawk cups cups-filters samba-client perl
    'perl(Digest::MD5)' bind-utils strace readline-devel ncurses-devel
    cyrus-sasl-devel pam-devel e2fsprogs-devel libacl-devel openldap-devel gcc-c++
    libuuid-devel net-snmp net-snmp-utils langpacks-de chrony yum-utils psmisc lvm2
    stunnel realmd sssd-ad samba-winbind samba-winbind-clients sssd-winbind-idmap
    sssd-tools sendEmail sqlite yamllint rsyslog pdftk telnet tmux fpart
)
install_packages() {
    hr; log "Standard-Pakete installieren (das dauert ein paar Minuten)"
    run yum -y update || warn "yum update meldete Fehler – fahre fort."
    # --skip-broken: einzelne (z.B. EPEL-)Pakete dürfen fehlen, ohne alles zu stoppen
    run yum -y install --skip-broken "${ABAS_PACKAGES[@]}" \
        || warn "Einige Pakete konnten nicht installiert werden (siehe oben)."
}

# ============================ Datenplatten ===================================
# Schützt OS-Platte und alle bereits genutzten Platten.
disk_protected() {
    local d="$1"
    lsblk -nr -o MOUNTPOINT "/dev/$d" 2>/dev/null | grep -q . && return 0
    lsblk -nr -o FSTYPE "/dev/$d" 2>/dev/null | grep -qi 'swap' && return 0
    pvs --noheadings -o pv_name 2>/dev/null | grep -q "/dev/${d}" && return 0
    return 1
}

first_partition() {  # liefert /dev/<part1> der Platte
    local d="$1" p
    p=$(lsblk -nr -o NAME,TYPE "/dev/$d" | awk '$2=="part"{print $1; exit}')
    [ -n "$p" ] && echo "/dev/$p"
}

setup_data_disk() {  # dev mountpoint fs vg lv
    local dev="$1" mp="$2" fs="$3" vg="$4" lv="$5"
    log "Konfiguriere /dev/$dev -> $mp ($fs, VG=$vg LV=$lv)"

    if vgs "$vg" >/dev/null 2>&1; then
        warn "Volume Group '$vg' existiert bereits – überspringe Plattenaufbau für /dev/$dev."
        return
    fi

    # Partition (GPT, eine Partition über die ganze Platte)
    run parted -s "/dev/$dev" mklabel gpt mkpart primary 0% 100% || die "parted fehlgeschlagen."
    run partprobe "/dev/$dev"; run udevadm settle; sleep 1

    local part
    part=$(first_partition "$dev")
    [ -n "$part" ] || die "Konnte Partition auf /dev/$dev nicht ermitteln."

    run pvcreate -y "$part"           || die "pvcreate fehlgeschlagen."
    run vgcreate "$vg" "$part"        || die "vgcreate fehlgeschlagen."
    run lvcreate -y -n "$lv" -l 100%FREE "$vg" || die "lvcreate fehlgeschlagen."

    local lvpath="/dev/$vg/$lv"
    if [ "$fs" = "ext4" ]; then
        run mkfs.ext4 -F "$lvpath" || die "mkfs.ext4 fehlgeschlagen."
    else
        run mkfs.xfs -f "$lvpath"  || die "mkfs.xfs fehlgeschlagen."
    fi

    run mkdir -p "$mp"
    run mount "$lvpath" "$mp" || die "mount fehlgeschlagen."

    # fstab per UUID (robuster als /dev/mapper-Namen mit Bindestrich-Mangling)
    if [ "$DRY_RUN" != "1" ]; then
        local uuid; uuid=$(blkid -s UUID -o value "$lvpath")
        if ! grep -q "$uuid" /etc/fstab 2>/dev/null; then
            cp -a /etc/fstab "/etc/fstab.bak.$(date +%s)"
            printf '\n# abas Daten (%s)\nUUID=%s  %s  %s  defaults  0 2\n' \
                   "$lv" "$uuid" "$mp" "$fs" >> /etc/fstab
            log "fstab-Eintrag für $mp ergänzt."
        else
            log "fstab-Eintrag für $mp bereits vorhanden."
        fi
    fi
}

configure_disks_interactive() {
    hr; log "Datenplatten konfigurieren"
    local disks d size cand=()
    mapfile -t disks < <(lsblk -dn -o NAME,TYPE | awk '$2=="disk"{print $1}')
    for d in "${disks[@]}"; do
        size=$(lsblk -dn -o SIZE "/dev/$d")
        if disk_protected "$d"; then
            echo "  /dev/$d ($size)  -> in Benutzung (OS/gemountet/PV)  [übersprungen]"
            continue
        fi
        if lsblk -nr -o NAME "/dev/$d" | grep -qv "^${d}$"; then
            warn "  /dev/$d ($size) hat bereits Partitionen, ist aber nicht gemountet."
            warn "  Aus Sicherheitsgründen wird die Platte NICHT automatisch überschrieben."
            warn "  Bei Bedarf vorher manuell aufräumen (wipefs/parted) und Skript erneut starten."
            continue
        fi
        cand+=("$d")
    done

    if [ "${#cand[@]}" -eq 0 ]; then
        warn "Keine freien Datenplatten gefunden."
        return
    fi

    local idx=1
    for d in "${cand[@]}"; do
        size=$(lsblk -dn -o SIZE "/dev/$d")
        hr
        if ! ask_yn "Freie Platte /dev/$d ($size) für abas einrichten?" y; then
            log "Überspringe /dev/$d."
            continue
        fi
        # hochzählende Defaults, damit "immer Enter" keine Konflikte erzeugt
        local mp fs vg lv def_mp def_vg def_lv
        def_mp="/mnt${idx}"
        def_vg="abas${idx}"
        [ "$idx" -eq 1 ] && def_lv="abas-data" || def_lv="abas-data${idx}"
        mp=$(ask_val "Mountpoint" "$def_mp")
        fs=$(ask_val "Dateisystem (xfs/ext4)" "xfs")
        [ "$fs" = "ext4" ] || fs="xfs"
        vg=$(ask_val "Volume-Group-Name" "$def_vg")
        lv=$(ask_val "Logical-Volume-Name" "$def_lv")
        echo -e "${C_Y}ACHTUNG:${C_0} /dev/$d wird komplett gelöscht und neu partitioniert!"
        if ask_yn "Wirklich fortfahren?" n; then
            setup_data_disk "$d" "$mp" "$fs" "$vg" "$lv"
            idx=$((idx + 1))   # nur bei tatsächlich konfigurierter Platte hochzählen
        else
            log "Abgebrochen für /dev/$d."
        fi
    done
}

# ============================ Java ===========================================
install_java() {  # version basepath  (8|17)
    local ver="$1" base="$2"
    hr; log "Java $ver (OpenJDK) installieren"
    if [ "$ver" = "17" ]; then
        run yum -y install java-17-openjdk.x86_64 java-17-openjdk-devel || warn "Java 17 Install-Fehler."
        run ln -sfn /usr/lib/jvm/java-17-openjdk "${base}/java17"
    else
        run yum -y install java-1.8.0-openjdk.x86_64 java-1.8.0-openjdk-devel || warn "Java 8 Install-Fehler."
        run ln -sfn /usr/lib/jvm/java-1.8.0-openjdk "${base}/java8"
    fi
}

# ============================ Webmin / vmtouch ===============================
install_webmin() {
    hr; log "Webmin installieren"
    if rpm -q webmin >/dev/null 2>&1; then log "Webmin bereits installiert."; return; fi
    run bash -c 'curl -fsSL -o /tmp/setup-repos.sh https://raw.githubusercontent.com/webmin/webmin/master/setup-repos.sh && yes | sh /tmp/setup-repos.sh' \
        || warn "Webmin-Repo-Setup fehlgeschlagen."
    run yum -y install webmin || warn "Webmin-Installation fehlgeschlagen."
}

install_vmtouch() {
    hr; log "vmtouch installieren"
    if command -v vmtouch >/dev/null 2>&1; then log "vmtouch bereits installiert."; return; fi
    run bash -c 'cd /tmp && rm -rf vmtouch && git clone https://github.com/hoytech/vmtouch.git && cd vmtouch && make && make install && cd /tmp && rm -rf vmtouch' \
        || warn "vmtouch-Installation fehlgeschlagen."
}

# ============================ Docker (RHEL) ==================================
configure_docker_daemon() {
    log "Docker daemon.json (abas-Empfehlung) schreiben"
    [ "$DRY_RUN" = "1" ] && { echo "DRY-RUN: würde /etc/docker/daemon.json schreiben"; return; }
    mkdir -p /etc/docker
    [ -f /etc/docker/daemon.json ] && cp -a /etc/docker/daemon.json "/etc/docker/daemon.json.bak.$(date +%s)"
    cat > /etc/docker/daemon.json <<'EOF'
{
  "bip": "172.31.0.1/24",
  "default-address-pools": [
    {"base":"172.31.1.0/16","size":24}
  ],
  "log-driver": "json-file",
  "log-opts": {"max-size":"50m","max-file":"5"}
}
EOF
    systemctl restart docker 2>/dev/null || warn "docker-Neustart fehlgeschlagen."
}

install_docker() {
    hr; log "Docker installieren (RHEL)"
    if command -v docker >/dev/null 2>&1; then
        log "docker-Binary bereits vorhanden – überspringe Installation."
    else
        # mögliche alte/konkurrierende Pakete entfernen (Fehler ignorieren)
        run bash -c 'dnf -y remove docker docker-client docker-client-latest docker-common \
            docker-latest docker-latest-logrotate docker-logrotate docker-engine podman runc 2>/dev/null' || true
        run dnf -y install dnf-plugins-core || warn "dnf-plugins-core Install-Fehler."
        run dnf config-manager --add-repo https://download.docker.com/linux/rhel/docker-ce.repo \
            || warn "Docker-Repo konnte nicht hinzugefügt werden."
        run dnf -y install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin \
            || warn "Docker-Installation fehlgeschlagen."
        run systemctl enable --now docker || warn "docker-Dienst nicht aktivierbar."
    fi
    configure_docker_daemon

    if ask_yn "docker-compose Standalone (von abas benötigt) installieren?" y; then
        local ver arch url
        arch=$(uname -m)
        ver=$(ask_val "Version pinnen? (leer = immer neueste)" "")
        if [ -n "$ver" ]; then
            url="https://github.com/docker/compose/releases/download/${ver}/docker-compose-linux-${arch}"
        else
            # GitHub-Weiterleitung auf das jeweils neueste Release-Asset
            url="https://github.com/docker/compose/releases/latest/download/docker-compose-linux-${arch}"
        fi
        run bash -c "curl -fsSL '${url}' -o /usr/bin/docker-compose && chmod +x /usr/bin/docker-compose" \
            && { [ "$DRY_RUN" = "1" ] || log "docker-compose installiert: $(docker-compose version 2>/dev/null | head -1)"; } \
            || warn "docker-compose Standalone Download fehlgeschlagen."
    fi
}

# ============================ Dienst-/System-Konfig ==========================
configure_xinetd() {
    hr; log "xinetd konfigurieren"
    local f=/etc/xinetd.conf
    [ -f "$f" ] || { warn "$f fehlt (xinetd installiert?)."; return; }
    [ "$DRY_RUN" = "1" ] && { echo "DRY-RUN: würde $f anpassen"; return; }
    cp -a "$f" "${f}.bak.$(date +%s)"
    _set_xinetd() {  # key value
        local k="$1" v="$2"
        if grep -qE "^[[:space:]]*#?[[:space:]]*${k}[[:space:]]*=" "$f"; then
            sed -i -E "s|^([[:space:]]*)#?[[:space:]]*${k}[[:space:]]*=.*|\1${k} = ${v}|" "$f"
        else
            sed -i "0,/{/s//{\n\t${k} = ${v}/" "$f"
        fi
    }
    _set_xinetd "max_load"   ""
    _set_xinetd "cps"        "10000 1"
    _set_xinetd "instances"  "UNLIMITED"
    _set_xinetd "per_source" "UNLIMITED"
    run systemctl restart xinetd || warn "xinetd-Neustart fehlgeschlagen."
}

configure_services() {
    hr; log "/etc/services ergänzen"
    [ "$DRY_RUN" = "1" ] && { echo "DRY-RUN: würde /etc/services ergänzen"; return; }
    if ! grep -q "^datmod" /etc/services; then
        cp -a /etc/services "/etc/services.bak.$(date +%s)"
        cat >> /etc/services <<'EOF'

# ABAS Konfiguration
datmod      48392/tcp   datmod   # Hilfsprogramm zum Starten des Anwendungsservers
edp_s3      6550/tcp    edp      # EDP-Server fuer alle Mandanten im HOMEDIR
EOF
        log "abas-Ports in /etc/services ergänzt."
    else
        log "abas-Ports bereits in /etc/services vorhanden."
    fi
}

configure_limits() {
    hr; log "Systemlimits setzen (/etc/security/limits.conf)"
    [ "$DRY_RUN" = "1" ] && { echo "DRY-RUN: würde /etc/security/limits.conf ergänzen"; return; }
    # evtl. früher angelegtes Drop-in entfernen (Limits stehen jetzt direkt in limits.conf)
    if [ -f /etc/security/limits.d/50-abas.conf ]; then
        rm -f /etc/security/limits.d/50-abas.conf
        log "Altes Drop-in limits.d/50-abas.conf entfernt."
    fi
    local f=/etc/security/limits.conf
    if grep -q '# abas limits' "$f" 2>/dev/null; then
        log "abas-Limits bereits in limits.conf vorhanden."; return
    fi
    cp -a "$f" "${f}.bak.$(date +%s)"
    # Block vor "# End of file" einfügen, sonst am Dateiende anhängen
    awk '
        /^# End of file/ && !done {
            print "# abas limits"
            print "*   soft   core      unlimited"
            print "*   -      rss       unlimited"
            print "*   -      nofile    32768"
            print ""
            done=1
        }
        { print }
        END { if (!done) {
            print ""; print "# abas limits"
            print "*   soft   core      unlimited"
            print "*   -      rss       unlimited"
            print "*   -      nofile    32768"
        }}
    ' "$f" > "${f}.tmp" && cat "${f}.tmp" > "$f" && rm -f "${f}.tmp"
    log "abas-Limits in limits.conf ergänzt."
}

configure_libs() {
    hr; log "Kompatibilitäts-Library-Links setzen (für ältere abas-Versionen)"
    make_compat_link() {  # base oldver  (ermittelt aktuelle Version dynamisch)
        local base="$1" old="$2" real
        real=$(find /usr/lib64 -maxdepth 1 -name "${base}.[0-9]*" -printf '%f\n' 2>/dev/null | sort -V | tail -1)
        if [ -n "$real" ]; then
            run ln -sf "$real" "/usr/lib64/${base}.${old}"
            log "  ${base}.${old} -> ${real}"
        else
            warn "  Keine Datei für ${base} gefunden – übersprungen."
        fi
    }
    make_compat_link "libncurses.so" 5
    make_compat_link "libtinfo.so"   5
    make_compat_link "libnsl.so"     1
    make_compat_link "libcurl.so"    3
}

configure_ssh() {
    hr; log "SSH konfigurieren (PermitRootLogin yes, StrictModes no)"
    warn "Hinweis: Diese Einstellungen sind für die abas-INSTALLATION gedacht."
    warn "         Erwäge, sie danach wieder zu härten."
    [ "$DRY_RUN" = "1" ] && { echo "DRY-RUN: würde sshd_config anpassen"; return; }
    local f=/etc/ssh/sshd_config
    cp -a "$f" "${f}.bak.$(date +%s)"
    _set_ssh() {  # key value
        local k="$1" v="$2"
        if grep -qE "^[[:space:]]*#?[[:space:]]*${k}[[:space:]]+" "$f"; then
            sed -i -E "s|^[[:space:]]*#?[[:space:]]*${k}[[:space:]]+.*|${k} ${v}|" "$f"
        else
            echo "${k} ${v}" >> "$f"
        fi
    }
    _set_ssh "PermitRootLogin" "yes"
    _set_ssh "StrictModes"     "no"
    run systemctl restart sshd || warn "sshd-Neustart fehlgeschlagen."
}

configure_redroot() {
    hr; log "Roten root-Prompt einrichten"
    [ "$DRY_RUN" = "1" ] && { echo "DRY-RUN: würde /etc/profile.d/redrootprompt.sh schreiben"; return; }
    cat > /etc/profile.d/redrootprompt.sh <<'EOF'
## Custom root color
force_color_prompt=yes
if [ "$LOGNAME" = root ] || [ "$(id -u)" -eq 0 ]; then
    PS1='\[\033[01;31m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[01;34m\]#\[\033[00m\] '
else
    PS1='\u@\h:\w\$ '
fi
EOF
    log "redrootprompt.sh geschrieben."
}

configure_sysctl() {
    hr; log "sysctl für abas setzen"
    [ "$DRY_RUN" = "1" ] && { echo "DRY-RUN: würde /etc/sysctl.d/50-abas.conf schreiben"; return; }
    cat > /etc/sysctl.d/50-abas.conf <<'EOF'
# sysctl-config for abas
fs.protected_hardlinks = 0
fs.suid_dumpable = 1
kernel.pid_max = 65534
kernel.core_pattern = core.%p
net.ipv6.conf.all.disable_ipv6 = 1
net.ipv6.conf.default.disable_ipv6 = 1
net.ipv6.conf.lo.disable_ipv6 = 1
EOF
    run sysctl -p /etc/sysctl.d/50-abas.conf || warn "sysctl -p meldete Fehler."
}

configure_hosts() {
    hr; log "/etc/hosts anpassen"
    [ "$DRY_RUN" = "1" ] && { echo "DRY-RUN: würde /etc/hosts anpassen"; return; }
    local ip fqdn short
    ip=$(hostname -I 2>/dev/null | awk '{print $1}')
    fqdn=$(hostname -f 2>/dev/null || hostname)
    short=$(hostname -s 2>/dev/null || hostname)
    log "Erkannt: IP=$ip  Hostname=$fqdn"
    if ask_yn "Diesen Host in /etc/hosts eintragen und IPv6-localhost auskommentieren?" y; then
        cp -a /etc/hosts "/etc/hosts.bak.$(date +%s)"
        sed -i -E 's/^(::1[[:space:]].*)/#\1/' /etc/hosts
        if [ -n "$ip" ] && ! grep -q "$short" /etc/hosts; then
            echo "$ip $short $fqdn" >> /etc/hosts
        fi
        log "/etc/hosts angepasst."
    fi
}

configure_selinux() {
    hr; log "SELinux deaktivieren"
    [ "$DRY_RUN" = "1" ] && { echo "DRY-RUN: würde SELinux deaktivieren"; return; }
    if [ -f /etc/selinux/config ]; then
        cp -a /etc/selinux/config "/etc/selinux/config.bak.$(date +%s)"
        sed -i -E 's/^SELINUX=.*/SELINUX=disabled/' /etc/selinux/config
        setenforce 0 2>/dev/null || true
        log "SELinux auf disabled gesetzt (greift nach Reboot)."
    fi
}

configure_services_state() {
    hr; log "Dienste aktivieren/deaktivieren"
    run systemctl disable --now firewalld 2>/dev/null || warn "firewalld nicht deaktivierbar (evtl. nicht vorhanden)."
    run systemctl disable --now smartd    2>/dev/null || warn "smartd nicht deaktivierbar (evtl. nicht vorhanden)."
    run systemctl enable --now smb  2>/dev/null || warn "smb nicht aktivierbar."
    run systemctl enable --now nmb  2>/dev/null || warn "nmb nicht aktivierbar."
}

# ============================ Hauptablauf ====================================
usage() {
    cat <<EOF
Verwendung: $0 [--auto] [-h|--help]

  --auto   Alle Abfragen automatisch mit ihrem Standardwert bestätigen.
           AUSNAHME: Die Festplattenkonfiguration bleibt interaktiv.
           (auch per Umgebungsvariable: AUTO=1 $0)

  DRY_RUN=1 $0   zeigt potenziell destruktive Befehle nur an.
EOF
}

main() {
    local arg
    for arg in "$@"; do
        case "$arg" in
            --auto) AUTO=1 ;;
            -h|--help) usage; exit 0 ;;
            *) warn "Unbekannter Parameter: $arg"; usage; exit 1 ;;
        esac
    done

    preflight
    hr
    echo -e "${C_G}senapsa RHEL8 / abas Setup (interaktiv)${C_0}"
    [ "$AUTO" = "1" ] && warn "--auto aktiv: Defaults werden automatisch bestätigt (außer Festplatten)."
    hr

    if ask_yn "EPEL aktivieren?" y; then enable_epel; fi
    if ask_yn "Standard-Pakete installieren?" y; then install_packages; fi

    local ABAS_BASE="/mnt1"
    if ask_yn "Datenplatten konfigurieren?" y; then
        # Festplattenkonfiguration immer interaktiv – auch im --auto-Modus
        local _auto_save="$AUTO"; AUTO=0
        configure_disks_interactive
        AUTO="$_auto_save"
        ABAS_BASE=$(ask_val "abas-Basispfad (für Java-Links)" "/mnt1")
    fi

    if ask_yn "Java 8 (OpenJDK) installieren?" y;  then install_java 8  "$ABAS_BASE"; fi
    if ask_yn "Java 17 (OpenJDK, ab abas2024.Q3) installieren?" y; then install_java 17 "$ABAS_BASE"; fi

    if ask_yn "Webmin installieren?" y;   then install_webmin;  fi
    if ask_yn "vmtouch installieren?" y;  then install_vmtouch; fi
    if ask_yn "Docker installieren (inkl. abas daemon.json)?" y; then install_docker; fi

    if ask_yn "xinetd konfigurieren?" y;          then configure_xinetd; fi
    if ask_yn "/etc/services ergänzen?" y;        then configure_services; fi
    if ask_yn "Systemlimits setzen?" y;           then configure_limits; fi
    if ask_yn "Kompatibilitäts-Library-Links setzen (Legacy/Upgrade)?" y; then configure_libs; fi
    if ask_yn "SSH für Installation öffnen (PermitRootLogin yes)?" y; then configure_ssh; fi
    if ask_yn "Roten root-Prompt einrichten?" y;  then configure_redroot; fi
    if ask_yn "sysctl für abas setzen?" y;        then configure_sysctl; fi
    if ask_yn "/etc/hosts anpassen?" y;           then configure_hosts; fi
    if ask_yn "SELinux deaktivieren?" y;          then configure_selinux; fi
    if ask_yn "Dienste setzen (firewalld/smartd aus, samba an)?" y; then configure_services_state; fi

    hr
    log "Konfiguration abgeschlossen."
    echo
    echo -e "${C_Y}==============================================================${C_0}"
    echo -e "${C_Y} WICHTIG:${C_0} Bitte den Server NEU STARTEN, damit alle Änderungen"
    echo -e "          (u.a. SELinux, sysctl, Mounts) vollumfänglich wirksam werden."
    echo -e "${C_Y}==============================================================${C_0}"
    echo
    echo "Verifikation nach dem Reboot:"
    echo "  - SELinux:  getenforce            (sollte 'Disabled')"
    echo "  - Mounts:   df -h"
    echo
    if ask_yn "Jetzt neu starten?" n; then
        run reboot
    fi
}

main "$@"