#!/bin/bash
#
# modules_update.sh
#
# Führt BI-Updatejobs für alle in BI_UPDATE_MODULES definierten Module aus.
# Erwartet, dass vorher BI_ENV gesourced wurde (JAVA_HOME, WEBAPP, LOGPFAD,
# BI_UPDATE_MODULES, MAILPROG, LOGMAIL, ERRORMAIL, MAIL_BETREFF_*).
#
# Dieses Skript protokolliert die Läufe zusätzlich in der Tabelle update_prot
# (über DOQUERY, falls im PATH verfügbar) und kann Logdateien optional per Mail
# anhängen – nur im Fehlerfall oder immer (gesteuert über MAIL_ATTACH_LOGS_MODE).

set -u

#######################################
# Modul → systeminfo_id Mapping
#######################################
declare -A SYSTEMINFO_MAP=(
    [gang]=121
    [cob]=10
    [zul]=130
    [man]=200
    [sos]=7
    [erfolg]=120
    [rpta]=330
    [etl]=270
    [kern]=9
    [kenn]=109
    [ivs]=140
    [bau]=4
    [fin]=3
    [lm]=300
    [sva]=6
)

# Steuerung, wann Logs angehängt werden:
#   error  = nur im Fehlerfall (Standard)
#   always = bei Erfolg und Fehler
MAIL_ATTACH_LOGS_MODE="${MAIL_ATTACH_LOGS_MODE:-error}"

# Steuerung, ob die Job-Logdatei auf interne Fehler geprüft werden soll.
#   true  = Log nach Fehlermustern durchsuchen (FAILED / Fehlgeschlagen etc.)
#   false = nur Java-Exitcode verwenden
CHECK_JOBLOG_FOR_ERRORS="${CHECK_JOBLOG_FOR_ERRORS:-false}"

########## Hilfsfunktionen für Mailversand ##########

# Log-Mail (Erfolgsfall) – nur, wenn MAILPROG und LOGMAIL gesetzt sind.
# Zusätzliche Parameter ab $3 werden direkt an MAILPROG weitergereicht (z.B. -a <file>).
send_log_mail() {
    local subject="$1"
    local body_file="$2"
    shift 2

    if [ -n "${MAILPROG:-}" ] && [ -n "${LOGMAIL:-}" ]; then
        $MAILPROG -s "$subject" "$@" $LOGMAIL <"$body_file"
    fi
}

# Fehlermail – bevorzugt an ERRORMAIL, sonst an LOGMAIL.
# Zusätzliche Parameter ab $3 werden direkt an MAILPROG weitergereicht (z.B. -a <file>).
send_error_mail() {
    local subject="$1"
    local body_file="$2"
    shift 2

    local recipient=""
    if [ -n "${ERRORMAIL:-}" ]; then
        recipient="$ERRORMAIL"
    elif [ -n "${LOGMAIL:-}" ]; then
        recipient="$LOGMAIL"
    fi

    if [ -n "${MAILPROG:-}" ] && [ -n "$recipient" ]; then
        $MAILPROG -s "$subject" "$@" $recipient <"$body_file"
    fi
}

########## Startcheck – minimale Grundprüfung ##########

startcheck_var() {
    local varname="$1"
    local value="${!varname:-}"

    if [ -z "$value" ]; then
        # Fallback auf /tmp, falls LOGPFAD (noch) nicht gesetzt ist
        local logdir="${LOGPFAD:-/tmp}"
        local tmpfile="$logdir/bi_update_startcheck_${varname}.log"

        {
            echo "Startcheck: Variable $varname fehlt oder ist leer. (Quelle: BI_ENV)"
            echo "Hinweis: Der Wert wird normalerweise in der BI_ENV gepflegt."
            date
        } >"$tmpfile"

        # Fehlermail (optional) schicken
        send_error_mail "BI Update Startcheck Fehler: $varname fehlt" "$tmpfile"

        echo "FEHLER: Startcheck gescheitert – Variable $varname fehlt oder ist leer."
        echo "Hinweis: Der Wert wird normalerweise in der BI_ENV gepflegt."
        exit 1
    fi
}

# Startcheck: Pflichtvariablen aus BI_ENV
startcheck_var "WEBAPP"
startcheck_var "LOGPFAD"
startcheck_var "BI_UPDATE_MODULES"

########## DOQUERY prüfen (über $PATH) ##########
# DOQUERY wird nur verwendet, wenn es im PATH gefunden wird.
# Ist es nicht vorhanden, wird die DB-Protokollierung vollständig übersprungen.

DOQUERY_AVAILABLE=0
DOQUERY_CMD=""

if command -v DOQUERY >/dev/null 2>&1; then
    DOQUERY_AVAILABLE=1
    DOQUERY_CMD="DOQUERY"
else
    echo "Hinweis: DOQUERY nicht im PATH gefunden – DB-Protokollierung deaktiviert."
fi

########## Logging vorbereiten ##########

MASTERLOG="$LOGPFAD/bi_update.log"
mkdir -p "$LOGPFAD"

ERROR_FLAG=0
ERROR_LOG_FILES=()    # Modul-/Job-Logs für Fehler-Mails
SUCCESS_LOG_FILES=()  # Modul-/Job-Logs für Erfolgs-Mails (bei MAIL_ATTACH_LOGS_MODE=always)

########## Funktion: Modul-Update ausführen ##########

run_module_update() {
    local module="$1"
    local log_dir="$2"
    local masterlog="$3"

    local module_upper
    module_upper=$(echo "$module" | tr '[:lower:]' '[:upper:]')
    local joblog="$log_dir/${module}_update.log"

    local start_ts
    local end_ts
    start_ts=$(date '+%Y-%m-%d %H:%M:%S%z')

    {
        echo
        echo "--- Start Update für Modul: $module ($module_upper) ---"
        date
    } >>"$masterlog"

    ########## DB-Protokollierung: Start ##########
    if [ $DOQUERY_AVAILABLE -eq 1 ]; then
        # Standardwert 0, falls Mapping nicht vorhanden ist
        local sys_id="0"
        if declare -p SYSTEMINFO_MAP >/dev/null 2>&1; then
            sys_id="${SYSTEMINFO_MAP[$module]:-0}"
        fi

        $DOQUERY_CMD "
            INSERT INTO update_prot (systeminfo_id, update_entity, update_id, update_time)
            VALUES ($sys_id, '$module', -10000, '$start_ts');
        " >>"$masterlog" 2>&1 || echo "WARNUNG: DB-Insert für Modul $module fehlgeschlagen." >>"$masterlog"
    fi
    ########## DB-Protokollierung: Start ENDE ##########

    # Java-Job ausführen, Fehler kontrolliert auswerten
    local rc=0
    if ! java ${JAVA_OPTS:-} \
        -classpath "$WEBAPP/WEB-INF/classes:$WEBAPP/WEB-INF/lib/*:$WEBAPP/WEB-INF/lib_ext/*" \
        de.superx.bin.ComponentAdminCLI -e "$module" \
        >>"$joblog" 2>&1
    then
        rc=$?
    fi

    # Optional: Logdatei inhaltlich auf Fehler prüfen,
    # falls der Prozess selbst mit Exitcode 0 beendet wurde.
    if [ "$rc" -eq 0 ] && [ "$CHECK_JOBLOG_FOR_ERRORS" = "true" ]; then
        if grep -q "Beim Ausführen des Jobs sind Fehler aufgetreten" "$joblog" \
        || grep -q " status: \[FAILED\]" "$joblog" \
        || grep -q "^\\*\\* Fehlgeschlagen:" "$joblog"
        then
            echo "Hinweis: Modul $module meldet interne Fehler im Job-Log – Returncode wird auf 1 gesetzt." >>"$masterlog"
            rc=1
        fi
    fi

    end_ts=$(date '+%Y-%m-%d %H:%M:%S%z')

    {
        echo "Returncode des Moduls $module: $rc"
        date
    } >>"$masterlog"

    if [ "$rc" -eq 0 ]; then
        # Modul war erfolgreich → Modul-Log für mögliche Anhänge merken
        SUCCESS_LOG_FILES+=("$joblog")
        
        echo "--- Ende Update von $module: ERFOLGREICH ---" >>"$masterlog"

        ########## DB-Protokollierung: Erfolg ##########
        if [ $DOQUERY_AVAILABLE -eq 1 ]; then
            $DOQUERY_CMD "
                UPDATE update_prot
                   SET updated_at = '$end_ts',
                       update_id  = -10000
                 WHERE tid = (
                         SELECT tid
                           FROM update_prot
                          WHERE update_entity = '$module'
                            AND updated_at IS NULL
                          ORDER BY tid DESC
                          LIMIT 1
                 );
            " >>"$masterlog" 2>&1 || echo "WARNUNG: DB-Update (Erfolg) für Modul $module fehlgeschlagen." >>"$masterlog"
        fi
        ########## DB-Protokollierung: Erfolg ENDE ##########

        ########## Zusätzliche Job-Logdatei auch im Erfolgsfall registrieren ##########
        # Damit sie bei MAIL_ATTACH_LOGS_MODE=always als Anhang mitgeschickt werden kann.
        local jobs_dir="$WEBAPP/WEB-INF/logs/jobs"
        if [ -d "$jobs_dir" ]; then
            # neueste Datei, die mit dem Modulnamen in Großbuchstaben beginnt, z.B. KENN_*.log
            local newest_jobfile
            newest_jobfile=$(ls -1t "$jobs_dir/${module_upper}_"*.log 2>/dev/null | head -n1 || true)
            if [ -n "$newest_jobfile" ] && [ -f "$newest_jobfile" ]; then
                SUCCESS_LOG_FILES+=("$newest_jobfile")
                echo "Hinweis: Zusätzlicher Job-Log (Erfolg) für Modul $module registriert: $newest_jobfile" >>"$masterlog"
            fi
        fi
        ########## Ende: zusätzliche Job-Logdatei (Erfolg) ##########

    else
        echo ">>>> ACHTUNG: Update des Moduls $module wurde mit einem FEHLER beendet! <<<<" >>"$masterlog"
        echo "--- Ende Update von $module: FEHLER ---" >>"$masterlog"
        ERROR_FLAG=1
        ERROR_LOG_FILES+=("$joblog")

        ########## Zusätzliche Job-Logdatei aus $WEBAPP/WEB-INF/logs/jobs im Fehlerfall ##########
        local jobs_dir="$WEBAPP/WEB-INF/logs/jobs"
        if [ -d "$jobs_dir" ]; then
            local newest_jobfile
            newest_jobfile=$(ls -1t "$jobs_dir/${module_upper}_"*.log 2>/dev/null | head -n1 || true)
            if [ -n "$newest_jobfile" ] && [ -f "$newest_jobfile" ]; then
                ERROR_LOG_FILES+=("$newest_jobfile")
                echo "Hinweis: Zusätzlicher Job-Log (Fehler) für Modul $module angehängt: $newest_jobfile" >>"$masterlog"
            fi
        fi
        ########## Ende: zusätzliche Job-Logdatei (Fehler) ##########

        ########## DB-Protokollierung: Fehler ##########
        if [ $DOQUERY_AVAILABLE -eq 1 ]; then
            $DOQUERY_CMD "
                UPDATE update_prot
                   SET updated_at = '$end_ts',
                       update_id  = -10001
                 WHERE tid = (
                         SELECT tid
                           FROM update_prot
                          WHERE update_entity = '$module'
                            AND updated_at IS NULL
                          ORDER BY tid DESC
                          LIMIT 1
                 );
            " >>"$masterlog" 2>&1 || echo "WARNUNG: DB-Update (Fehler) für Modul $module fehlgeschlagen." >>"$masterlog"
        fi
        ########## DB-Protokollierung: Fehler ENDE ##########
    fi

    echo >>"$masterlog"
}

########## Schleife über alle Module ##########

{
    echo "Starte BI-Updates für folgende Module: $BI_UPDATE_MODULES"
    date
    echo "######################################"
    echo
} >"$MASTERLOG"

for module in $BI_UPDATE_MODULES; do
    run_module_update "$module" "$LOGPFAD" "$MASTERLOG"
done

{
    echo
    echo "######################################"
    echo "-- Ende BI Update $(date)"
    echo
} >>"$MASTERLOG"

########## Mailversand (optional) ##########

if [ "$ERROR_FLAG" -eq 0 ]; then
    # Erfolgsfall
    attach_args=()
    if [ "$MAIL_ATTACH_LOGS_MODE" = "always" ]; then
        for f in "${SUCCESS_LOG_FILES[@]}"; do
            [ -f "$f" ] && attach_args+=("-a" "$f")
        done
    fi

    send_log_mail \
        "${MAIL_BETREFF_UPDATE:-BI Job Update}${MAIL_BETREFF_SUFFIX_ERFOLGREICH:-}" \
        "$MASTERLOG" \
        "${attach_args[@]}"

else
    echo "Sende Fehler-Logmail (falls konfiguriert)."

    attach_args=()

    # Bei MAIL_ATTACH_LOGS_MODE=always auch die Logs der erfolgreichen Module anhängen
    if [ "$MAIL_ATTACH_LOGS_MODE" = "always" ]; then
        for f in "${SUCCESS_LOG_FILES[@]}"; do
            [ -f "$f" ] && attach_args+=("-a" "$f")
        done
    fi

    # Fehler-Logs immer anhängen
    for f in "${ERROR_LOG_FILES[@]}"; do
        [ -f "$f" ] && attach_args+=("-a" "$f")
    done

    # Fehlerfall → Fehlermail an ERRORMAIL (oder Fallback LOGMAIL), mit Attachments
    send_error_mail \
        "${MAIL_BETREFF_UPDATE:-BI Job Update}${MAIL_BETREFF_SUFFIX_FEHLER:-}" \
        "$MASTERLOG" \
        "${attach_args[@]}"
fi