#!/usr/bin/env bash
set -Eeuo pipefail
umask 022

# STEP017 - SERVER ATTESO: 215.6 / ax-accessi
# Individua eventuali copie locali reali di bower_components/node_modules
# dentro /var/www/html/presenze.distribuite.
# Non elimina nulla e non tocca i symlink attivi verso le librerie condivise.

START_DIR="$PWD"
STAMP="$(date '+%Y%m%d_%H%M%S')"
BASE="STEP017_2156_DISTRIBUITE_LOCAL_LIB_DUPLICATES_AUDIT_ONLY_${STAMP}"
WORKDIR="${START_DIR}/.${BASE}_work_$$"
OUTZIP="${START_DIR}/${BASE}.zip"
LOGFILE="${WORKDIR}/run.log"
REPORT="${WORKDIR}/report.txt"
PACKAGED=0
FAILURES=0
WARNINGS=0

EXPECTED_HOST="${STEP_EXPECTED_HOST:-ax-accessi}"
EXPECTED_IP="${STEP_EXPECTED_IP:-192.168.215.6}"
SKIP_SERVER_CHECK="${STEP_SKIP_SERVER_CHECK:-0}"

TARGET_DIR="${STEP_TARGET_DIR:-/var/www/html/presenze.distribuite}"
SHARED_RELEASE="${STEP_SHARED_RELEASE:-/var/www/presenze-shared-libs/releases/presenze-legacy-20260723-v1}"

mkdir -p "$WORKDIR"
: >"$LOGFILE"
: >"$REPORT"

log()    { printf '%s\n' "$*" | tee -a "$LOGFILE"; }
report() { printf '%s\n' "$*" >>"$REPORT"; }
fail()   { FAILURES=$((FAILURES + 1)); log "ERRORE: $*"; report "ERRORE: $*"; }
warn()   { WARNINGS=$((WARNINGS + 1)); log "ATTENZIONE: $*"; report "ATTENZIONE: $*"; }

package_results() {
    local rc="${1:-0}"
    local zip_rc=0

    [[ "$PACKAGED" -eq 1 ]] && return 0
    PACKAGED=1

    report ""
    report "Esito finale: errori=${FAILURES}, avvisi=${WARNINGS}, exit_code=${rc}"

    rm -f -- "$OUTZIP"

    if ! command -v zip >/dev/null 2>&1; then
        rm -rf -- "$WORKDIR"
        printf '%s\n' "ERRORE: comando zip non disponibile" >&2
        return 127
    fi

    (cd "$WORKDIR" && zip -qr "$OUTZIP" .) || zip_rc=$?

    if [[ "$zip_rc" -eq 0 ]]; then
        zip -T "$OUTZIP" >>"$LOGFILE" 2>&1 || zip_rc=$?
    fi

    rm -rf -- "$WORKDIR"

    if [[ "$zip_rc" -ne 0 ]]; then
        rm -f -- "$OUTZIP"
        printf '%s\n' "ERRORE: creazione/verifica ZIP fallita (rc=${zip_rc})" >&2
        return "$zip_rc"
    fi

    printf '%s\n' "ZIP CREATO E VERIFICATO: $OUTZIP"
}

on_exit() {
    local rc=$?
    trap - EXIT INT TERM HUP
    package_results "$rc" || rc=$?
    exit "$rc"
}

trap on_exit EXIT
trap 'exit 130' INT
trap 'exit 143' TERM HUP

log "$BASE"
log "SERVER ATTESO: 215.6 / ax-accessi"
log "TARGET: $TARGET_DIR"
log "MODALITA': AUDIT ONLY - NESSUNA MODIFICA"
log "Avvio: $(date --iso-8601=seconds)"

ACTUAL_HOST="$(hostname -s 2>/dev/null || hostname)"
ACTUAL_IPS="$(hostname -I 2>/dev/null | xargs || true)"

{
    echo "STEP: $BASE"
    echo "Server atteso: 215.6 / ax-accessi"
    echo "Target: $TARGET_DIR"
    echo "Shared release: $SHARED_RELEASE"
    echo "Modalita': AUDIT ONLY"
    echo "Data: $(date --iso-8601=seconds)"
    echo "Hostname: $ACTUAL_HOST"
    echo "IP: $ACTUAL_IPS"
    echo
} >>"$REPORT"

for cmd in grep awk wc sort zip hostname xargs tr find readlink stat du basename; do
    command -v "$cmd" >/dev/null 2>&1 || fail "comando richiesto non disponibile: $cmd"
done

[[ "$FAILURES" -eq 0 ]] || exit 20

if [[ "$SKIP_SERVER_CHECK" != "1" ]]; then
    [[ "$ACTUAL_HOST" == "$EXPECTED_HOST" ]] \
        || fail "hostname ${ACTUAL_HOST}; previsto ${EXPECTED_HOST}"

    if [[ -n "$EXPECTED_IP" ]] && ! grep -qw -- "$EXPECTED_IP" <<<"$ACTUAL_IPS"; then
        fail "IP ${EXPECTED_IP} non presente tra: ${ACTUAL_IPS}"
    fi
fi

[[ "$FAILURES" -eq 0 ]] || exit 21

[[ -d "$TARGET_DIR" ]] || fail "cartella target assente: $TARGET_DIR"
[[ -d "$SHARED_RELEASE" ]] || fail "release condivisa assente: $SHARED_RELEASE"
[[ "$FAILURES" -eq 0 ]] || exit 22

log "[1/4] Verifica symlink attivi"

printf 'nome\ttipo\tlink_risolto\ttarget_atteso\tesito\n' >"${WORKDIR}/01_ACTIVE_LINKS.tsv"

for lib in bower_components node_modules; do
    path="${TARGET_DIR}/${lib}"
    expected="${SHARED_RELEASE}/${lib}"

    if [[ -L "$path" ]]; then
        resolved="$(readlink -f "$path" 2>/dev/null || true)"
        status="OK"

        [[ "$resolved" == "$expected" ]] || {
            status="TARGET_DIVERSO"
            fail "${path} punta a ${resolved}; atteso ${expected}"
        }

        [[ -d "$resolved" ]] || {
            status="TARGET_ASSENTE"
            fail "destinazione del link assente: ${resolved}"
        }

        printf '%s\tsymlink\t%s\t%s\t%s\n' \
            "$lib" "$resolved" "$expected" "$status" \
            >>"${WORKDIR}/01_ACTIVE_LINKS.tsv"
    elif [[ -d "$path" ]]; then
        printf '%s\tdirectory_reale\t-\t%s\tDA_CONVERTIRE\n' \
            "$lib" "$expected" >>"${WORKDIR}/01_ACTIVE_LINKS.tsv"
        fail "${path} è una directory reale, non un symlink"
    else
        printf '%s\tassente\t-\t%s\tASSENTE\n' \
            "$lib" "$expected" >>"${WORKDIR}/01_ACTIVE_LINKS.tsv"
        fail "${path} assente"
    fi
done

[[ "$FAILURES" -eq 0 ]] || exit 23

log "[2/4] Ricerca copie locali e directory correlate"

printf 'percorso\ttipo\tdimensione\tcandidato_eliminazione\n' \
    >"${WORKDIR}/02_LOCAL_CANDIDATES.tsv"

REAL_DUPLICATES=0
SYMLINKS_FOUND=0

while IFS= read -r -d '' item; do
    name="$(basename "$item")"
    size="$(du -sh -- "$item" 2>/dev/null | awk '{print $1}' || printf 'N/D')"

    if [[ -L "$item" ]]; then
        type="symlink"
        candidate="NO"
        SYMLINKS_FOUND=$((SYMLINKS_FOUND + 1))
    elif [[ -d "$item" ]]; then
        type="directory_reale"
        if [[ "$name" == "bower_components" || "$name" == "node_modules" ]]; then
            candidate="NO_LINK_ATTIVO"
        else
            candidate="SI_DA_VERIFICARE"
            REAL_DUPLICATES=$((REAL_DUPLICATES + 1))
        fi
    else
        type="altro"
        candidate="NO"
    fi

    printf '%s\t%s\t%s\t%s\n' \
        "$item" "$type" "$size" "$candidate" \
        >>"${WORKDIR}/02_LOCAL_CANDIDATES.tsv"
done < <(
    find "$TARGET_DIR" -mindepth 1 -maxdepth 1 \
        \( -name 'bower_components*' -o -name 'node_modules*' \
           -o -name '*bower*backup*' -o -name '*node*backup*' \
           -o -name '*bower*old*' -o -name '*node*old*' \) \
        -print0 2>>"$LOGFILE"
)

log "[3/4] Elenco completo primo livello"

find "$TARGET_DIR" -mindepth 1 -maxdepth 1 \
    -printf '%y\t%M\t%u:%g\t%p\t%l\n' \
    | sort >"${WORKDIR}/03_TARGET_TOP_LEVEL.tsv"

TARGET_SIZE="$(du -sh -- "$TARGET_DIR" 2>/dev/null | awk '{print $1}' || printf 'N/D')"
SHARED_BOWER_SIZE="$(du -sh -- "${SHARED_RELEASE}/bower_components" 2>/dev/null | awk '{print $1}' || printf 'N/D')"
SHARED_NODE_SIZE="$(du -sh -- "${SHARED_RELEASE}/node_modules" 2>/dev/null | awk '{print $1}' || printf 'N/D')"

{
    printf 'voce\tvalore\n'
    printf 'target_size\t%s\n' "$TARGET_SIZE"
    printf 'shared_bower_size\t%s\n' "$SHARED_BOWER_SIZE"
    printf 'shared_node_size\t%s\n' "$SHARED_NODE_SIZE"
    printf 'symlink_correlati_trovati\t%s\n' "$SYMLINKS_FOUND"
    printf 'directory_reali_duplicate_candidate\t%s\n' "$REAL_DUPLICATES"
} >"${WORKDIR}/04_SIZE_SUMMARY.tsv"

log "[4/4] Esito"

if [[ "$REAL_DUPLICATES" -gt 0 ]]; then
    warn "trovate ${REAL_DUPLICATES} directory reali candidate alla rimozione"
fi

{
    echo "AUDIT COMPLETATO"
    echo "Errori: $FAILURES"
    echo "Avvisi: $WARNINGS"
    echo "Symlink attivi bower_components/node_modules: OK"
    echo "Directory reali duplicate candidate: $REAL_DUPLICATES"
    echo "Dimensione target: $TARGET_SIZE"
    echo "Nessuna modifica eseguita."
} >"${WORKDIR}/99_SUMMARY.txt"

report "Symlink condivisi attivi: OK."
report "Directory reali duplicate candidate: $REAL_DUPLICATES."
report "Nessuna modifica eseguita."

log "AUDIT COMPLETATO: errori=${FAILURES}, avvisi=${WARNINGS}"