#!/bin/bash
# =============================================================================
#  qa_new  --  full server hardware inventory and health report
# =============================================================================

# =============================================================================
#  CONFIGURATION -- EDIT THESE BEFORE EVERYTHING ELSE
# =============================================================================

FW_MANIFEST_URL="http://216.104.40.250/scripts/fw_versions"

SST_URL="http://216.104.40.250/tools/sst"
IPMI_URL="http://216.104.40.250/tools/ipmi"
STOR_URL="http://184.154.112.130/raid/lsi/cli"

IPMI_ZIP="IPMICFG_1.37.0_build.250723.zip"
IPMI_BINARY="/usr/src/IPMICFG_1.37.0_build.250723/Linux/64bit/IPMICFG-Linux.x86_64"
IPMI_SYMLINK="/usr/bin/ipmicfg"
STOR_BINARY="/opt/MegaRAID/storcli/storcli64"
STOR_SYMLINK="/usr/bin/storcli"

SKIP_TOOL_INSTALL=0
SKIP_SST_FW_UPDATE=0
SKIP_SERVER_SUMMARY=0
SKIP_TOOL_BOX=0
SKIP_STORAGE=0
SKIP_SMART_PER_DISK=0
SKIP_PSU_CHECK=0
SKIP_NVME_HEALTH=0
SKIP_BOND_CHECK=0
SKIP_LSPCI=0
SKIP_SEL=0

PSU_EXPECTED_COUNT=2
NVME_PCT_USED_FAIL=90
NVME_SPARE_WARN=10


# =============================================================================
#  TOOL INSTALLATION -- IPMICFG + STORCLI first (needed for pre-gather)
#  SST installed later only if Intel SSDs are detected
# =============================================================================

if [ -f /etc/debian_version ]; then _OS="debian"
elif [ -f /etc/redhat-release ]; then _OS="rhel"
else _OS="unknown"; fi

if [ -r /etc/os-release ]; then
    . /etc/os-release
    _OS_PRETTY="${PRETTY_NAME:-}"
fi
[ -z "$_OS_PRETTY" ] && _OS_PRETTY="$_OS"

_TOOL_STATUSES=()

tool_state_token() {
    case "$1" in
        present)   printf '%b%binstalled%b'       "$BOLD" "$G" "$RST" ;;
        installed) printf '%b%bnewly installed%b'  "$BOLD" "$G" "$RST" ;;
        failed)    printf '%b%bFAILED%b'           "$BOLD" "$R" "$RST" ;;
        skipped)   printf '%b%bskipped%b'          "$BOLD" "$DIM" "$RST" ;;
    esac
}

# -- IPMICFG (install now so ipmicfg is available for pre-gather) -------------
if [ -f "$IPMI_SYMLINK" ] || [ -f /usr/local/bin/ipmicfg ]; then
    _TOOL_STATUSES+=("IPMICFG=present")
else
    wget -q --timeout=15 --tries=1 -P /usr/src "${IPMI_URL}/${IPMI_ZIP}" >/dev/null 2>&1 \
        && unzip -q "/usr/src/${IPMI_ZIP}" -d /usr/src >/dev/null 2>&1 \
        && ln -s "$IPMI_BINARY" "$IPMI_SYMLINK" 2>/dev/null \
        && chmod +x "$IPMI_SYMLINK" 2>/dev/null
    [ -f "$IPMI_SYMLINK" ] && _TOOL_STATUSES+=("IPMICFG=installed") || _TOOL_STATUSES+=("IPMICFG=failed")
fi

# -- STORCLI (install now so storcli is available for pre-gather) -------------
if [ -f "$STOR_SYMLINK" ] || [ -f "$STOR_BINARY" ]; then
    _TOOL_STATUSES+=("STORCLI=present")
else
    if [ "$_OS" = "debian" ]; then
        PKG="storcli_007.1017.0000.0000_all.deb"
        wget -q --timeout=15 --tries=1 "${STOR_URL}/${PKG}" -P /usr/src >/dev/null 2>&1 \
            && dpkg -i "/usr/src/${PKG}" >/dev/null 2>&1
    elif [ "$_OS" = "rhel" ]; then
        PKG="storcli-007.1017.0000.0000-1.noarch.rpm"
        wget -q --timeout=15 --tries=1 "${STOR_URL}/${PKG}" -P /usr/src >/dev/null 2>&1 \
            && rpm -ivh "/usr/src/${PKG}" >/dev/null 2>&1
    fi
    if [ -f "$STOR_BINARY" ]; then
        cp "$STOR_BINARY" "$STOR_SYMLINK" >/dev/null 2>&1 && chmod +x "$STOR_SYMLINK"
        _TOOL_STATUSES+=("STORCLI=installed")
    else
        _TOOL_STATUSES+=("STORCLI=failed")
    fi
fi


# =============================================================================
#  STARTUP -- clear the SEL
# =============================================================================
ipmicfg -clrint 2>/dev/null


# =============================================================================
#  TIMEZONE AUTO-DETECTION via traceroute hop hostnames
# =============================================================================
command -v traceroute >/dev/null 2>&1 || \
    (export DEBIAN_FRONTEND=noninteractive; apt-get update -qq 2>/dev/null && \
     apt-get install -y traceroute 2>/dev/null || \
     apt-get install -y inetutils-traceroute 2>/dev/null || \
     yum install -y traceroute 2>/dev/null) >/dev/null 2>&1

_DCINFO=$(traceroute -m 10 -q 1 8.8.8.8 2>/dev/null | awk 'NR>2 {print $2}' | grep -v '^\*$' | \
while IFS= read -r _h; do
    _h=$(printf '%s' "$_h" | tr '[:upper:]' '[:lower:]')
    case "$_h" in
        *dfw*|*dal*|*ftw*)          printf 'Dallas/Fort Worth|America/Chicago\n'  ;;
        *ord*|*chi*)                printf 'Chicago|America/Chicago\n'            ;;
        *lax*)                      printf 'Los Angeles|America/Los_Angeles\n'    ;;
        *sjc*|*sfo*|*oak*|*scl*|*svl*|*snv*) printf 'Santa Clara|America/Los_Angeles\n' ;;
        *sea*)                      printf 'Seattle|America/Los_Angeles\n'        ;;
        *ewr*|*nwk*|*njr*)         printf 'New Jersey|America/New_York\n'        ;;
        *nyc*|*jfk*)               printf 'New York|America/New_York\n'          ;;
        *atl*)                      printf 'Atlanta|America/New_York\n'           ;;
        *mia*)                      printf 'Miami|America/New_York\n'             ;;
        *iad*|*dca*|*bos*)         printf 'Washington DC|America/New_York\n'     ;;
        *phx*)                      printf 'Phoenix|America/Phoenix\n'            ;;
        *den*)                      printf 'Denver|America/Denver\n'              ;;
        *ams*)                      printf 'Amsterdam|Europe/Amsterdam\n'         ;;
        *lon*|*lhr*|*ldn*)         printf 'London|Europe/London\n'               ;;
        *fra*)                      printf 'Frankfurt|Europe/Berlin\n'            ;;
        *sin*)                      printf 'Singapore|Asia/Singapore\n'           ;;
        *nrt*|*tok*)               printf 'Tokyo|Asia/Tokyo\n'                   ;;
    esac
done | sort | uniq -c | sort -rn | head -1 | awk '{print $2}')

if [ -n "$_DCINFO" ]; then
    _DC_NAME="${_DCINFO%%|*}"
    _DC_TZ="${_DCINFO##*|}"
    _CURRENT_TZ=$(timedatectl show --property=Timezone --value 2>/dev/null || cat /etc/timezone 2>/dev/null | tr -d '[:space:]')
    echo "DC Location: ${_DC_NAME}  |  Timezone: ${_DC_TZ}"
    if [ "$_CURRENT_TZ" != "$_DC_TZ" ]; then
        timedatectl set-timezone "$_DC_TZ" 2>/dev/null
        echo "Timezone updated: ${_CURRENT_TZ} -> ${_DC_TZ}"
    else
        echo "Timezone already correct: ${_DC_TZ}"
    fi
else
    _DC_NAME="Unknown"
    _DC_TZ=""
    echo "DC Location: could not detect -- timezone unchanged"
fi


# =============================================================================
#  FIRMWARE MANIFEST
# =============================================================================
declare -A BIOS_LATEST=()
declare -A IPMI_LATEST=()
declare -A RAID_LATEST=()

_FW_RAW=$(wget -q -O- --timeout=10 "$FW_MANIFEST_URL" 2>/dev/null)
if [ -n "$_FW_RAW" ]; then
    _section=""
    while IFS= read -r _line; do
        _line="${_line%%#*}"
        _line=$(printf '%s' "$_line" | sed -E 's/^[[:space:]]+//; s/[[:space:]]+$//')
        [ -z "$_line" ] && continue
        if [[ "$_line" == SECTION=* ]]; then
            _section="${_line#SECTION=}"
            continue
        fi
        [[ "$_line" != *=* ]] && continue
        _key="${_line%%=*}"
        _val="${_line#*=}"
        case "$_section" in
            BIOS) BIOS_LATEST["$_key"]="$_val" ;;
            IPMI) IPMI_LATEST["$_key"]="$_val" ;;
            RAID) RAID_LATEST["$_key"]="$_val" ;;
        esac
    done <<< "$_FW_RAW"
fi
unset _FW_RAW _section _line _key _val


# =============================================================================
#  PARALLEL PRE-GATHER
# =============================================================================
_GATHER_DIR=$(mktemp -d -t qa_new_gather.XXXXXX)
trap 'rm -rf "$_GATHER_DIR" /tmp/_ram_check 2>/dev/null' EXIT INT TERM

(dmidecode -t 2            >"$_GATHER_DIR/dmi2"      2>/dev/null) &
(dmidecode -t 16           >"$_GATHER_DIR/dmi16"     2>/dev/null) &
(dmidecode -t 17           >"$_GATHER_DIR/dmi17"     2>/dev/null) &
(dmidecode -s bios-version >"$_GATHER_DIR/biosver"   2>/dev/null) &
(lspci                     >"$_GATHER_DIR/lspci"     2>/dev/null) &
(lspci -v                  >"$_GATHER_DIR/lspci_v"   2>/dev/null) &
(ipmicfg -ver              >"$_GATHER_DIR/ipmi_ver"  2>/dev/null) &
(ipmicfg -fan              >"$_GATHER_DIR/ipmi_fan"  2>/dev/null) &
(ipmicfg -sdr full         >"$_GATHER_DIR/ipmi_sdr"  2>/dev/null) &
(ipmicfg -sel list         >"$_GATHER_DIR/ipmi_sel"  2>/dev/null) &
(ipmicfg -summary          >"$_GATHER_DIR/ipmi_sum"  2>/dev/null) &
if command -v storcli >/dev/null 2>&1; then
    (storcli /c0 show              >"$_GATHER_DIR/sc_c0"       2>/dev/null) &
    (storcli /call/eall/sall show  >"$_GATHER_DIR/sc_pdall"    2>/dev/null) &
    (storcli /c0/vall show         >"$_GATHER_DIR/sc_vall"     2>/dev/null) &
    (storcli /call/vall show       >"$_GATHER_DIR/sc_callvall" 2>/dev/null) &
    (storcli /c0/bbu show          >"$_GATHER_DIR/sc_bbu"      2>/dev/null) &
    (storcli /c0/cv show           >"$_GATHER_DIR/sc_cv"       2>/dev/null) &
fi
wait

_DMI2=$(cat "$_GATHER_DIR/dmi2" 2>/dev/null)
_DMI16=$(cat "$_GATHER_DIR/dmi16" 2>/dev/null)
_DMI17=$(cat "$_GATHER_DIR/dmi17" 2>/dev/null)
_BIOSVER=$(cat "$_GATHER_DIR/biosver" 2>/dev/null | tr -d '[:space:]')
_LSPCI=$(cat "$_GATHER_DIR/lspci" 2>/dev/null)
_LSPCI_V=$(cat "$_GATHER_DIR/lspci_v" 2>/dev/null)
_IPMI_VER_RAW=$(cat "$_GATHER_DIR/ipmi_ver" 2>/dev/null)
_IPMI_FAN_RAW=$(cat "$_GATHER_DIR/ipmi_fan" 2>/dev/null)
_IPMI_SDR_RAW=$(cat "$_GATHER_DIR/ipmi_sdr" 2>/dev/null)
_IPMI_SEL_RAW=$(cat "$_GATHER_DIR/ipmi_sel" 2>/dev/null)
_IPMI_SUM_RAW=$(cat "$_GATHER_DIR/ipmi_sum" 2>/dev/null)
_SC_C0=$(cat "$_GATHER_DIR/sc_c0" 2>/dev/null)
_SC_PDALL=$(cat "$_GATHER_DIR/sc_pdall" 2>/dev/null)
_SC_VALL=$(cat "$_GATHER_DIR/sc_vall" 2>/dev/null)
_SC_CALLVALL=$(cat "$_GATHER_DIR/sc_callvall" 2>/dev/null)
[ -s "$_GATHER_DIR/sc_bbu" ] && _SC_HAS_BBU=1 || _SC_HAS_BBU=0
[ -s "$_GATHER_DIR/sc_cv"  ] && _SC_HAS_CV=1  || _SC_HAS_CV=0


# =============================================================================
#  COLORS / BOX-DRAWING PRIMITIVES
# =============================================================================
R=$'\033[1;31m'
G=$'\033[1;32m'
Y=$'\033[1;33m'
C=$'\033[1;36m'
B=$'\033[1;34m'
M=$'\033[1;35m'
DIM=$'\033[0;37m'
GRAY=$'\033[1;90m'
RST=$'\033[0m'
BOLD=$'\033[1m'
BGR=$'\033[41m'
BGG=$'\033[42m'
BGY=$'\033[43m'
BLK=$'\033[1;37m'

W=74
INNER=74

rep() {
    local i out=''
    for (( i=0; i<$2; i++ )); do out+="$1"; done
    printf '%s' "$out"
}

_TL() { printf '\xe2\x95\x94'; }
_EQ() { printf '\xe2\x95\x90'; }
_TR() { printf '\xe2\x95\x97'; }
_ML() { printf '\xe2\x95\xa0'; }
_MR() { printf '\xe2\x95\xa3'; }
_VB() { printf '\xe2\x95\x91'; }
_BL() { printf '\xe2\x95\x9a'; }
_BR() { printf '\xe2\x95\x9d'; }
_HD() { printf '\xe2\x94\x80'; }

hline()   { rep "$(_EQ)" $W; }
divline() { rep "$(_HD)" $INNER; }

_BOX_COLOR="$C"

box_open() {
    local title="$1" color="${2:-$C}"
    _BOX_COLOR="$color"
    local tlen=${#title}
    local lpad=$(( (W - tlen - 2) / 2 ))
    local rpad=$(( W - tlen - 2 - lpad ))
    printf '\n'
    printf "%b%s%s%s%b\n"  "$color" "$(_TL)" "$(hline)" "$(_TR)" "$RST"
    printf "%b%s%s%b%b%b %s %b%b%s%s%b\n" "$color" "$(_VB)" "$(rep ' ' $lpad)" "$RST" "$BOLD" "$Y" "$title" "$RST" "$color" "$(rep ' ' $rpad)" "$(_VB)" "$RST"
    printf "%b%s%s%s%b\n"  "$color" "$(_ML)" "$(hline)" "$(_MR)" "$RST"
}

box_close() {
    local color="${1:-$_BOX_COLOR}"
    printf "%b%s%s%s%b\n"  "$color" "$(_BL)" "$(hline)" "$(_BR)" "$RST"
}

bline() {
    local text="$1" bc="${2:-$_BOX_COLOR}"
    local vis
    vis=$(printf '%s' "$text" | sed -E 's/\x1b\[[0-9;:]*[mGKHFJA-Za-z]//g; s/\x1b\([A-Z]//g')
    local pad=$(( INNER - ${#vis} ))
    [ "$pad" -lt 0 ] && pad=0
    printf "%b%s%b%s%s%b%s%b\n" "$bc" "$(_VB)" "$RST" "$text" "$(rep ' ' $pad)" "$bc" "$(_VB)" "$RST"
}

bempty()   { bline '' "${1:-$_BOX_COLOR}"; }
bdivider() { bline "$(printf "  %b%s%b" "$DIM" "$(rep "$(_HD)" 70)" "$RST")" "${1:-$_BOX_COLOR}"; }

bkv() {
    local key="$1" val="$2" lc="${3:-$G}" vc="${4:-$RST}" bc="${5:-$_BOX_COLOR}"
    bline "$(printf "  %b%-22s%b%b%s%b" "$lc" "$key" "$RST" "$vc" "$val" "$RST")" "$bc"
}


# =============================================================================
#  SMART HELPERS
# =============================================================================

print_smart_attrs() {
    local smart_out="$1" is_ssd="$2"
    bline "$(printf "    %b%-20s%b" "$G" "SMART Attributes:" "$RST")"
    while read -r id attr f v w t tp up wf raw; do
        case "$attr" in
            Current_Pending_Sector|Power_On_Hours|Reallocated_Sector_Ct|Offline_Uncorrectable)
                if { [ "$v" -lt "$t" ] 2>/dev/null; } || \
                   { [ "$raw" -gt 0 ] 2>/dev/null && echo "$attr" | grep -qE "Reallocated|Pending|Offline"; }; then
                    bline "$(printf "      %b%s: %s%b" "$R"   "$attr" "$raw" "$RST")"
                else
                    bline "$(printf "      %b%s: %s%b" "$DIM" "$attr" "$raw" "$RST")"
                fi ;;
            Reported_Uncorrect|UDMA_CRC_Error_Count)
                if [ "$raw" -gt 0 ] 2>/dev/null; then
                    bline "$(printf "      %b%s: %s%b" "$R"   "$attr" "$raw" "$RST")"
                else
                    bline "$(printf "      %b%s: %s%b" "$DIM" "$attr" "$raw" "$RST")"
                fi ;;
            Total_LBAs_Written)
                [ "$is_ssd" -gt 0 ] 2>/dev/null && \
                    bline "$(printf "      %b%s: %s%b" "$DIM" "$attr" "$raw" "$RST")" ;;
            Media_Wearout_Indicator|Wear_Leveling_Count)
                if [ "$is_ssd" -gt 0 ] 2>/dev/null; then
                    local wcolor="$G"
                    [ "$v" -lt 80 ] 2>/dev/null && wcolor="$Y"
                    [ "$v" -lt 50 ] 2>/dev/null && wcolor="$R"
                    bline "$(printf "      %b%s: %s%b" "$wcolor" "$attr" "$v" "$RST")"
                fi ;;
        esac
    done < <(printf '%s' "$smart_out" | grep -E "Current_Pending|Power_On_Hours|Reallocated_Sector|Offline_Unco|Media_Wearout|Wear_Leveling|Reported_Uncorrect|UDMA_CRC_Error|Total_LBAs_Written")
}

drive_entry() {
    local label="$1"; shift
    local smart_out model serial size fw
    smart_out=$(smartctl "$@" 2>/dev/null)
    model=$(printf '%s' "$smart_out"  | grep -E "Device Model|Model Number"  | head -1 | cut -d: -f2 | xargs)
    serial=$(printf '%s' "$smart_out" | grep "Serial Number"                 | head -1 | cut -d: -f2 | xargs)
    fw=$(printf '%s' "$smart_out"     | grep "Firmware Version"              | head -1 | cut -d: -f2 | xargs)

    _size_bytes=$(lsblk -bdno SIZE "$label" 2>/dev/null | head -1)
    if [ -n "$_size_bytes" ] && [ "$_size_bytes" -gt 0 ] 2>/dev/null; then
        size=$(awk -v b="$_size_bytes" 'BEGIN{
            if      (b>=1000000000000) printf "%.2f TB", b/1000000000000
            else if (b>=1000000000)    printf "%.2f GB", b/1000000000
            else if (b>=1000000)       printf "%.2f MB", b/1000000
            else                       printf "%d B",    b
        }')
    else
        size=$(printf '%s' "$smart_out" | grep "User Capacity" | head -1 | cut -d'[' -f2 | cut -d']' -f1 | xargs)
    fi
    unset _size_bytes

    local is_ssd=0 disk_type="HDD"
    if printf '%s' "$smart_out" | grep -qi "NVM Express\|nvme"; then
        disk_type="NVMe"; is_ssd=1
    elif printf '%s' "$smart_out" | grep -qi "Solid State\|Rotation Rate.*Solid"; then
        disk_type="SSD"; is_ssd=1
    elif ! printf '%s' "$smart_out" | grep -q "Rotation Rate"; then
        disk_type="SSD"; is_ssd=1
    fi

    local sst_badge
    sst_badge=$(sst_badge_for "$serial")

    bline "$(printf "  %b%b%s%b  %b[Non-RAID]%b" "$BOLD" "$C" "$label" "$RST" "$DIM" "$RST")"
    bline "$(printf "    %b%-20s%b%b%s%b" "$G" "Type:"     "$RST" "$Y"   "$disk_type"           "$RST")"
    bline "$(printf "    %b%-20s%b%b%s%b" "$G" "Model:"    "$RST" "$Y"   "${model:-(unknown)}"  "$RST")"
    bline "$(printf "    %b%-20s%b%b%s%b" "$G" "Serial:"   "$RST" "$DIM" "${serial:-(unknown)}" "$RST")"
    bline "$(printf "    %b%-20s%b%b%s%b" "$G" "Size:"     "$RST" "$C"   "${size:-(unknown)}"   "$RST")"
    bline "$(printf "    %b%-20s%b%b%s%b%s" "$G" "Firmware:" "$RST" "$C" "${fw:-(unknown)}" "$RST" "${sst_badge:+  $sst_badge}")"

    local _part_count _disk_fs _part_label
    _part_count=$(lsblk -lno NAME "$label" 2>/dev/null | grep -v "^$(basename "$label")$" | wc -l)
    _disk_fs=$(lsblk -dno FSTYPE "$label" 2>/dev/null)
    if [ "$_part_count" -eq 0 ] && [ -z "$_disk_fs" ]; then
        bline "$(printf "    %b%-20s%b%b%b NO PARTITIONS / EMPTY %b" "$G" "Partitions:" "$RST" "$BGY" "$BLK" "$RST")"
    else
        _part_label="${_part_count} partition(s)"
        [ "$_part_count" -eq 0 ] && [ -n "$_disk_fs" ] && _part_label="filesystem: ${_disk_fs} (no partition table)"
        bline "$(printf "    %b%-20s%b%b%s%b" "$G" "Partitions:" "$RST" "$DIM" "$_part_label" "$RST")"
    fi
    unset _part_count _disk_fs _part_label

    if [ "$disk_type" = "NVMe" ] && command -v nvme >/dev/null 2>&1; then
        local _ctrl="${1%n*}"
        [ -e "$_ctrl" ] || _ctrl="$1"
        local _nvme_log
        _nvme_log=$(nvme smart-log "$_ctrl" 2>/dev/null)
        if [ -n "$_nvme_log" ]; then
            local _pct _spare _warn _temp
            _pct=$(printf '%s' "$_nvme_log" | awk -F: '/percentage_used/{gsub(/[^0-9]/,"",$2); print $2+0}')
            _spare=$(printf '%s' "$_nvme_log" | awk -F: '/available_spare[^_]/{gsub(/[^0-9]/,"",$2); print $2+0}')
            _warn=$(printf '%s' "$_nvme_log" | awk -F: '/critical_warning/{gsub(/[^0-9a-fx]/,"",$2); print $2}')
            _temp=$(printf '%s' "$_nvme_log" | awk -F: '/^temperature /{gsub(/[^0-9]/,"",$2); print $2+0}')
            bline "$(printf "    %b%-20s%b" "$G" "NVMe Health:" "$RST")"
            [ -n "$_pct" ]   && bline "$(printf "      %b%-22s%b%s%%" "$DIM" "Percentage Used:" "$RST" "$_pct")"
            [ -n "$_spare" ] && bline "$(printf "      %b%-22s%b%s%%" "$DIM" "Available Spare:" "$RST" "$_spare")"
            [ -n "$_temp" ]  && bline "$(printf "      %b%-22s%b%s C" "$DIM" "Temperature:" "$RST" "$_temp")"
            if [ -n "$_warn" ] && [ "$_warn" != "0x00" ] && [ "$_warn" != "0" ]; then
                bline "$(printf "      %b%-22s%b%b%s%b" "$R" "Critical Warning:" "$RST" "$R" "$_warn" "$RST")"
            else
                bline "$(printf "      %b%-22s%b%bOK%b" "$DIM" "Critical Warning:" "$RST" "$G" "$RST")"
            fi
        fi
    else
        print_smart_attrs "$smart_out" "$is_ssd"
    fi
    bempty
    # Show partitions
    _part_count=$(lsblk -lno NAME "$label" 2>/dev/null | grep -v "^$(basename "$label")$" | wc -l)
    if [ "$_part_count" -gt 0 ]; then
        bline "$(printf "    %b%-20s%b%b%d partition(s)%b" "$G" "Partitions:" "$RST" "$DIM" "$_part_count" "$RST")"
        lsblk -lno NAME,SIZE,FSTYPE "$label" 2>/dev/null | grep -v "^$(basename "$label")[[:space:]]" | while read -r pname psize pfs; do
            [ -z "$pname" ] && continue
            bline "$(printf "      %b%-18s %-10s %s%b" "$DIM" "$pname" "$psize" "${pfs:--}" "$RST")"
        done
    else
        bline "$(printf "    %b%-20s%b%bno partitions%b" "$G" "Partitions:" "$RST" "$BGY" "$RST")"
    fi
}


# =============================================================================
#  SST -- install ONLY if Intel SSDs are detected
# =============================================================================
# Scan block devices for Intel SSD models before attempting SST install.
# Intel SSDs have model strings starting with SSDSC, SSDPE, SSDPF, SSDPK,
# SSDSA, SSDMCE, or branded as "INTEL SSD" in smartctl output.
_HAS_INTEL_SSD=0
for _chkdev in $(lsblk -dno NAME,TYPE 2>/dev/null | awk '$2=="disk"{print "/dev/"$1}'); do
    _chkmodel=$(smartctl -i "$_chkdev" 2>/dev/null | grep -iE "Device Model|Model Number" | head -1)
    if echo "$_chkmodel" | grep -qiE "INTEL|^SSDSC|^SSDPE|^SSDPF|^SSDPK|^SSDSA|^SSDMCE"; then
        _HAS_INTEL_SSD=1
        break
    fi
done
# Also check RAID physical drives if storcli is available
if [ "$_HAS_INTEL_SSD" -eq 0 ] && command -v storcli >/dev/null 2>&1; then
    if printf '%s\n' "$_SC_PDALL" | grep -qiE "SSDSC|SSDPE|SSDPF|SSDPK|INTEL"; then
        _HAS_INTEL_SSD=1
    fi
fi
unset _chkdev _chkmodel

if [ "$_HAS_INTEL_SSD" -eq 0 ]; then
    _TOOL_STATUSES+=("SST=skipped")
elif [ -f /usr/bin/sst ]; then
    _TOOL_STATUSES+=("SST=present")
else
    if [ "$_OS" = "debian" ]; then
        wget -q --timeout=15 --tries=1 "${SST_URL}/sst-cli-linux-deb--2-3.zip" >/dev/null 2>&1 \
            && unzip -q sst-cli-linux-deb--2-3.zip >/dev/null 2>&1 \
            && dpkg -i sst_2.3.320-0_amd64.deb >/dev/null 2>&1
    elif [ "$_OS" = "rhel" ]; then
        wget -q --timeout=15 --tries=1 "${SST_URL}/sst-cli-linux-rpm--2-3.zip" >/dev/null 2>&1 \
            && unzip -q sst-cli-linux-rpm--2-3.zip >/dev/null 2>&1 \
            && rpm -ivh sst-2.3.320-0.x86_64.rpm >/dev/null 2>&1
    fi
    [ -f /usr/bin/sst ] && _TOOL_STATUSES+=("SST=installed") || _TOOL_STATUSES+=("SST=failed")
fi
unset _HAS_INTEL_SSD


# =============================================================================
#  SST firmware scan + update
# =============================================================================
declare -A SST_STATUS_BY_SERIAL
if command -v sst >/dev/null 2>&1 && [ "${SKIP_SST_FW_UPDATE:-0}" != "1" ]; then
    sst set -system EnableLSIAdapter=true >/dev/null 2>&1
    _SST_DATA=$(sst show -ssd 2>/dev/null)

    while IFS="|" read -r idx path mdl serial fw status; do
        [ -z "$serial" ] && continue
        if echo "$mdl" | grep -qiE "^SMC[0-9]|^MegaRAID|^Avago|^Broadcom"; then
            continue
        fi
        if echo "$mdl" | grep -qiE "^(TOSHIBA|MG0[0-9]|ST[0-9]|HUS[0-9]|WD[0-9]|HGST|SEAGATE|HITACHI)"; then
            SST_STATUS_BY_SERIAL["$serial"]="HDD-SKIPPED"; continue
        fi
        if echo "$path" | grep -qiE "^/dev/bus/" && echo "$mdl" | grep -qiE "^$|^[0-9]+$"; then
            continue
        fi
        if [ "$status" = "UP-TO-DATE" ]; then
            SST_STATUS_BY_SERIAL["$serial"]="UP-TO-DATE"
        elif [ "$status" = "UPDATE-AVAILABLE" ]; then
            sst load -f -ssd "$idx" >/dev/null 2>&1 \
                && SST_STATUS_BY_SERIAL["$serial"]="UPDATED" \
                || SST_STATUS_BY_SERIAL["$serial"]="FAILED"
        else
            SST_STATUS_BY_SERIAL["$serial"]="UNKNOWN"
        fi
    done < <(printf '%s' "$_SST_DATA" | awk '
        function flush() {
            if (f[1]!=""&&f[2]!="") print f[1]"|"f[2]"|"f[3]"|"f[4]"|"f[5]"|"f[6]
        }
        BEGIN { f[1]="";f[2]="";f[3]="";f[4]="";f[5]="";f[6]="" }
        /^- .* -$/             { flush(); f[1]="";f[2]="";f[3]="";f[4]="";f[5]="";f[6]="" }
        /^Index[ 	]*:/        { f[1]=$NF }
        /^DevicePath[ 	]*:/   { f[2]=$NF }
        /^ModelNumber[ 	]*:/  { f[3]=""; for(i=2;i<=NF;i++) if($i!=":") f[3]=f[3](f[3]!=""?" ":"")$i }
        /^SerialNumber[ 	]*:/ { f[4]=$NF }
        /^Firmware[ 	]*:/     { f[5]=$NF }
        /^FirmwareUpdateAvailable/ { f[6]=($0~/current firmware/)?"UP-TO-DATE":"UPDATE-AVAILABLE" }
        END { flush() }
    ')
fi

# Build SST summary line for SERVER SUMMARY box -- always show a status
_SST_SUMMARY=""
if [ "${SKIP_SST_FW_UPDATE:-0}" = "1" ]; then
    _SST_SUMMARY="skipped by config"
elif ! command -v sst >/dev/null 2>&1; then
    # SST not installed -- determine why
    _had_intel=0
    for _entry in "${_TOOL_STATUSES[@]}"; do
        case "$_entry" in
            SST=skipped) _SST_SUMMARY="no Intel SSDs detected -- SST not installed"; break ;;
            SST=failed)  _SST_SUMMARY="SST install failed";  _had_intel=1; break ;;
        esac
    done
    [ -z "$_SST_SUMMARY" ] && _SST_SUMMARY="SST unavailable"
    unset _entry _had_intel
elif [ "${#SST_STATUS_BY_SERIAL[@]}" -eq 0 ]; then
    _SST_SUMMARY="no Intel SSDs found by sst show"
else
    _sst_uptodate=0; _sst_updated=0; _sst_failed=0; _sst_unknown=0
    for _sv in "${SST_STATUS_BY_SERIAL[@]}"; do
        case "$_sv" in
            UP-TO-DATE)  _sst_uptodate=$(( _sst_uptodate + 1 )) ;;
            UPDATED)     _sst_updated=$(( _sst_updated  + 1 )) ;;
            FAILED)      _sst_failed=$(( _sst_failed   + 1 )) ;;
            UNKNOWN)     _sst_unknown=$(( _sst_unknown  + 1 )) ;;
        esac
    done
    _SST_SUMMARY=""
    [ "$_sst_uptodate" -gt 0 ] && _SST_SUMMARY="${_sst_uptodate} already latest"
    [ "$_sst_updated"  -gt 0 ] && _SST_SUMMARY="${_SST_SUMMARY:+$_SST_SUMMARY, }${_sst_updated} updated"
    [ "$_sst_failed"   -gt 0 ] && _SST_SUMMARY="${_SST_SUMMARY:+$_SST_SUMMARY, }${_sst_failed} FAILED"
    [ "$_sst_unknown"  -gt 0 ] && _SST_SUMMARY="${_SST_SUMMARY:+$_SST_SUMMARY, }${_sst_unknown} unknown"
    [ -z "$_SST_SUMMARY" ] && _SST_SUMMARY="checked but no status returned"
    unset _sv _sst_uptodate _sst_updated _sst_failed _sst_unknown
fi

sst_badge_for() {
    local key="$1"
    [ -z "$key" ] && return
    [ "${#SST_STATUS_BY_SERIAL[@]}" -eq 0 ] && return
    local state="${SST_STATUS_BY_SERIAL[$key]:-}"
    [ -z "$state" ] && return
    case "$state" in
        UP-TO-DATE)  printf '%b%b  UP TO DATE  %b' "$BGG" "$BLK"  "$RST" ;;
        UPDATED)     printf '%b%b  UPDATED  %b'    "$BGG" "$BLK"  "$RST" ;;
        FAILED)      printf '%b%b  FW FAILED  %b'  "$BGR" "$BOLD" "$RST" ;;
        HDD-SKIPPED) printf '%b  HDD - NO FW  %b'  "$DIM"         "$RST" ;;
        UNKNOWN)     printf '%b  FW UNKNOWN  %b'   "$DIM"         "$RST" ;;
    esac
}

unset _OS _OS_PRETTY _SST_DATA


# =============================================================================
#  GATHER: PSU status
# =============================================================================
declare -a _PSU_ENTRIES=()
_PSU_DETECTED=0; _PSU_FAIL_COUNT=0
_SDR_FULL_PSU="$_IPMI_SDR_RAW"
if [ "${SKIP_PSU_CHECK:-0}" != "1" ]; then
    _SDR_PSU=$(printf '%s' "$_SDR_FULL_PSU" | grep -iE "PS[0-9]+[[:space:]]+Status|Power Supply[[:space:]]+[0-9]")

    if [ -n "$_SDR_PSU" ]; then
        while IFS= read -r _psu_line; do
            [ -z "$_psu_line" ] && continue
            _psu_stat=$(echo "$_psu_line" | awk -F'|' '{gsub(/^[ 	]+|[ 	]+$/,"",$1); print $1}')
            _psu_name=$(echo "$_psu_line" | awk -F'|' '{gsub(/^[ 	]+|[ 	]+$/,"",$2); gsub(/\([0-9]+\)[[:space:]]*/,"",$2); print $2}')
            _psu_reading=$(echo "$_psu_line" | awk -F'|' '{gsub(/^[ 	]+|[ 	]+$/,"",$4); print $4}')
            [ -z "$_psu_name" ] && continue
            _PSU_DETECTED=$(( _PSU_DETECTED + 1 ))
            if echo "$_psu_stat" | grep -qi "^OK"; then
                _PSU_ENTRIES+=("${_psu_name}|${_psu_reading:-Presence detected}|OK")
            else
                _PSU_ENTRIES+=("${_psu_name}|${_psu_reading:-${_psu_stat}}|FAIL")
                _PSU_FAIL_COUNT=$(( _PSU_FAIL_COUNT + 1 ))
            fi
        done <<< "$_SDR_PSU"
    fi

    if [ "$_PSU_DETECTED" -eq 0 ]; then
        while IFS= read -r _psu_line; do
            [ -z "$_psu_line" ] && continue
            _psu_num=$(echo "$_psu_line" | grep -oE '(Power Supply|PSU|PS)[[:space:]]*[0-9]+' | grep -oE '[0-9]+' | head -1)
            _psu_status=$(echo "$_psu_line" | cut -d: -f2 | xargs)
            [ -z "$_psu_num" ] && continue
            _PSU_DETECTED=$(( _PSU_DETECTED + 1 ))
            if echo "$_psu_status" | grep -qi "Power OK\|Present.*OK"; then
                _PSU_ENTRIES+=("PSU${_psu_num}|${_psu_status}|OK")
            else
                _PSU_ENTRIES+=("PSU${_psu_num}|${_psu_status}|FAIL")
                _PSU_FAIL_COUNT=$(( _PSU_FAIL_COUNT + 1 ))
            fi
        done < <(printf '%s\n' "$_IPMI_SUM_RAW" | grep -iE "Power Supply|PSU|^PS[[:space:]]+[0-9]")
    fi
fi
unset _SDR_FULL_PSU _SDR_PSU


# =============================================================================
#  GATHER: NVMe health
# =============================================================================
declare -a _NVME_DEVS _NVME_MODELS _NVME_PCT _NVME_SPARE _NVME_WARN _NVME_STATUS
_NVME_FAIL=0
if [ "${SKIP_NVME_HEALTH:-0}" != "1" ] && command -v nvme >/dev/null 2>&1; then
    for _nc in /dev/nvme[0-9]*; do
        [[ "$(basename "$_nc")" =~ ^nvme[0-9]+$ ]] || continue
        [ -e "$_nc" ] || continue
        _nm=$(nvme id-ctrl "$_nc" 2>/dev/null \
            | awk -F: '/^mn /{gsub(/^[ \t]+/,"",$2); print $2; exit}' | xargs)
        [ -z "$_nm" ] && _nm="(unknown)"
        _ns=$(nvme smart-log "$_nc" 2>/dev/null)
        _np=$(printf '%s' "$_ns" | awk -F: '/percentage_used/{gsub(/[^0-9]/,"",$2);print $2+0}')
        _nsp=$(printf '%s' "$_ns" | awk -F: '/available_spare[^_]/{gsub(/[^0-9]/,"",$2);print $2+0}')
        _nw=$(printf '%s' "$_ns" | awk -F: '/critical_warning/{gsub(/[^0-9a-fx]/,"",$2);print $2}')
        [ -z "$_np" ] && _np="-"
        [ -z "$_nsp" ] && _nsp="-"
        [ -z "$_nw" ] && _nw="-"
        _nst="PASS"
        [ "$_np" != "-" ] && [ "$_np" -ge "$NVME_PCT_USED_FAIL" ] 2>/dev/null && _nst="FAIL"
        [ "$_nsp" != "-" ] && [ "$_nsp" -lt "$NVME_SPARE_WARN" ] 2>/dev/null && [ "$_nst" = "PASS" ] && _nst="WARN"
        [ "$_nw" != "-" ] && [ "$_nw" != "0x00" ] && [ "$_nw" != "0" ] && _nst="FAIL"
        _NVME_DEVS+=("$_nc"); _NVME_MODELS+=("$_nm")
        _NVME_PCT+=("$_np"); _NVME_SPARE+=("$_nsp")
        _NVME_WARN+=("$_nw"); _NVME_STATUS+=("$_nst")
        [ "$_nst" = "FAIL" ] && _NVME_FAIL=$(( _NVME_FAIL + 1 ))
    done
fi


# =============================================================================
#  GATHER: Bond health
# =============================================================================
declare -a _BOND_ENTRIES=()
if [ "${SKIP_BOND_CHECK:-0}" != "1" ]; then
    for _bp in /proc/net/bonding/bond*; do
        [ -r "$_bp" ] || continue
        _bn=$(basename "$_bp")
        _bmode=$(awk -F: '/^Bonding Mode:/{gsub(/^[ \t]+/,"",$2);print $2}' "$_bp" | xargs)
        _btotal=$(grep -c "^Slave Interface:" "$_bp" 2>/dev/null || echo 0)
        _bactive=$(grep -c "MII Status: up" "$_bp" 2>/dev/null || echo 0)
        _bdown=$(awk '/^Slave Interface:/{iface=$NF}/MII Status: down/{print iface}' "$_bp" | paste -sd ',' -)
        if [ "$_bactive" -eq 0 ]; then
            _bv="FAIL"
        elif [ -n "$_bdown" ]; then
            _bv="WARN"
        else
            _bv="PASS"
        fi
        _bd="${_bactive}/${_btotal} slaves up  mode: ${_bmode:-unknown}"
        [ -n "$_bdown" ] && _bd="${_bd}  down: ${_bdown}"
        _BOND_ENTRIES+=("${_bn}|${_bd}|${_bv}")
    done
fi


# =============================================================================
#  GATHER: lspci (RAID + 10G NICs with physical slot)
# =============================================================================
declare -A _PCI_SEEN=()
if [ "${SKIP_LSPCI:-0}" != "1" ]; then
    _SLOTTED_PCI=$(printf '%s\n' "$_LSPCI_V" | awk '
        /^[0-9a-f]/{bdf=$1; has_slot=0; slot_num=0}
        /Physical Slot:/{slot_num=$NF+0; if(slot_num>0) has_slot=1}
        /^$/ && has_slot{print bdf}
    ')
    if [ -n "$_SLOTTED_PCI" ]; then
        while IFS= read -r _bdf; do
            _pl=$(printf '%s\n' "$_LSPCI" | grep -i "^${_bdf} ")
            [ -z "$_pl" ] && continue
            if echo "$_pl" | grep -qiE "RAID|MegaRAID|Fibre Channel"; then
                _ps=$(echo "$_pl" | sed -E 's/^[0-9a-f:.]+ //; s/^[^:]+:[[:space:]]*//')
                _PCI_SEEN["$_ps"]=$(( ${_PCI_SEEN["$_ps"]:-0} + 1 ))
            elif echo "$_pl" | grep -qiE "Ethernet" && echo "$_pl" | grep -qiE \
                "10-Gigabit|10GbE|10GBASE|X520|X540|X550|X710|X722|XL710|XXV710|E810|82599|Connect[Xx]|57711|57810|57840|BCM578|NetXtreme-E|Aquantia|Chelsio"; then
                _ps=$(echo "$_pl" | sed -E 's/^[0-9a-f:.]+ //; s/^[^:]+:[[:space:]]*//')
                _PCI_SEEN["$_ps"]=$(( ${_PCI_SEEN["$_ps"]:-0} + 1 ))
            fi
        done <<< "$_SLOTTED_PCI"
    fi
    unset _SLOTTED_PCI _bdf _pl
fi


# =============================================================================
#  GATHER: SEL events
# =============================================================================
_SEL_CRITICAL=""; _SEL_WARN=""; _SEL_INFO=""
_SEL_CRIT_COUNT=0; _SEL_WARN_COUNT=0; _SEL_INFO_COUNT=0
if [ "${SKIP_SEL:-0}" != "1" ]; then
    _SEL_RAW=$(printf '%s\n' "$_IPMI_SEL_RAW" \
        | grep -vE "^$|^SEL|No.*entries|List is empty|ACPowerOn|AC Power on|First AC" \
        | grep -vE "^[[:space:]]*-+[[:space:]]*$" \
        | grep -v "^[[:space:]]*$")
    if [ -n "$_SEL_RAW" ]; then
        _SEL_JOINED=$(printf '%s\n' "$_SEL_RAW" | awk '
            /^[[:space:]]*[0-9]+[[:space:]]*\|/ {
                if (buf != "") print buf
                buf = $0
                next
            }
            { if (buf != "") buf = buf " " $0 }
            END { if (buf != "") print buf }
        ')
        while IFS= read -r _sl; do
            [ -z "$_sl" ] && continue
            if echo "$_sl" | grep -qiE "\|[[:space:]]*Critical[[:space:]]*\|"; then
                _SEL_CRITICAL="${_SEL_CRITICAL}${_sl}
"
                _SEL_CRIT_COUNT=$(( _SEL_CRIT_COUNT + 1 ))
            elif echo "$_sl" | grep -qiE "\|[[:space:]]*Warning[[:space:]]*\|"; then
                _SEL_WARN="${_SEL_WARN}${_sl}
"
                _SEL_WARN_COUNT=$(( _SEL_WARN_COUNT + 1 ))
            else
                _SEL_INFO="${_SEL_INFO}${_sl}
"
                _SEL_INFO_COUNT=$(( _SEL_INFO_COUNT + 1 ))
            fi
        done <<< "$_SEL_JOINED"
    fi
fi


# =============================================================================
#  BIOS / IPMI FIRMWARE STATUS
# =============================================================================
_BOARD_RAW=$(printf '%s\n' "$_DMI2" | grep 'Product Name' | awk '{print $NF}' | tr -d '[:space:]')
_CURRENT_FW=$(printf '%s\n' "$_IPMI_VER_RAW" | grep -oE '[0-9]+\.[0-9]+(\.[0-9]+)?' | head -1)
_CURRENT_BIOS="$_BIOSVER"
_IPMI_UPDATE_MSG=" $(printf "%b UNABLE TO DETERMINE %b" "$DIM" "$RST")"
_BIOS_UPDATE_MSG=" $(printf "%b UNABLE TO DETERMINE %b" "$DIM" "$RST")"

_fw_normalize() { echo "$1" | awk -F. '{ printf "%02d.%02d.%02d",$1+0,$2+0,$3+0 }'; }

_LATEST_BIOS="${BIOS_LATEST[${_BOARD_RAW}]:-}"
_LATEST_FW="${IPMI_LATEST[${_BOARD_RAW}]:-}"

if [ -n "$_LATEST_FW" ] && [ -n "$_CURRENT_FW" ]; then
    _cn=$(_fw_normalize "$_CURRENT_FW"); _ln=$(_fw_normalize "$_LATEST_FW")
    if [[ "$_cn" < "$_ln" ]]; then
        _IPMI_UPDATE_MSG=" $(printf "%b%b UPDATE REQUIRED -> %s %b" "$BGR" "$BOLD" "$_LATEST_FW" "$RST")"
    elif [[ "$_cn" = "$_ln" ]]; then
        _IPMI_UPDATE_MSG=" $(printf "%b%b LATEST %b" "$BOLD" "$G" "$RST")"
    fi
elif [ -z "$_LATEST_FW" ] && [ -n "$_BOARD_RAW" ]; then
    _IPMI_UPDATE_MSG=" $(printf "%b (no version on record) %b" "$DIM" "$RST")"
fi

if [ -n "$_LATEST_BIOS" ] && [ -n "$_CURRENT_BIOS" ]; then
    _cb=$(_fw_normalize "$_CURRENT_BIOS"); _lb=$(_fw_normalize "$_LATEST_BIOS")
    if [[ "$_cb" < "$_lb" ]]; then
        _BIOS_UPDATE_MSG=" $(printf "%b%b UPDATE AVAILABLE -> %s %b" "$BGY" "$BLK" "$_LATEST_BIOS" "$RST")"
    elif [[ "$_cb" = "$_lb" ]]; then
        _BIOS_UPDATE_MSG=" $(printf "%b%b LATEST %b" "$BOLD" "$G" "$RST")"
    fi
elif [ -z "$_LATEST_BIOS" ] && [ -n "$_BOARD_RAW" ]; then
    _BIOS_UPDATE_MSG=" $(printf "%b (no version on record) %b" "$DIM" "$RST")"
fi


# =============================================================================
#  SERVER SUMMARY BOX
# =============================================================================
if [ "${SKIP_SERVER_SUMMARY:-0}" != "1" ]; then
box_open "SERVER SUMMARY" "$C"
bkv "Hostname:" "$(uname -n) -- $(ip -4 route get 8.8.8.8 2>/dev/null | grep -oE 'src [0-9.]+' | awk '{print $2}')" "$C" "$BOLD"
bdivider

CPU_COUNT=$(grep "physical id" /proc/cpuinfo | sort -u | wc -l)
CPU_NAME=$(grep "model name" /proc/cpuinfo | head -1 | cut -d: -f2 | xargs \
    | sed -E 's/\(R\)//g;s/\(TM\)//g;s/CPU //;s/ @ [0-9.]+GHz//;s/  +/ /g')
[ "$CPU_COUNT" -eq 1 ] && bkv "CPU:" "1x ${CPU_NAME}" "$G" "$Y"
[ "$CPU_COUNT" -ge 2 ] && bkv "CPU:" "${CPU_COUNT}x ${CPU_NAME}" "$G" "$Y"
bkv "Physical CPUs:" "$CPU_COUNT" "$G" "$C"
bkv "Logical Cores:" "$(grep 'model name' /proc/cpuinfo | wc -l)" "$G" "$C"
unset CPU_COUNT CPU_NAME

bdivider

bkv "Motherboard:"  "$(printf '%s\n' "$_DMI2" | grep 'Product Name' | awk '{print $3}')" "$G" "$Y"
bkv "Manufacturer:" "$(printf '%s\n' "$_DMI2" | grep Manufacturer | cut -d: -f2 | xargs)" "$G" "$Y"
bkv "BIOS Version:" "${_CURRENT_BIOS}${_BIOS_UPDATE_MSG}" "$G" "$C"
bkv "IPMI Version:" "${_CURRENT_FW}${_IPMI_UPDATE_MSG}" "$G" "$C"

# SST SSD firmware check results -- always shown (defaulted to a message above)
_sst_color="$G"
if echo "$_SST_SUMMARY" | grep -qiE "FAILED|install failed|unavailable"; then
    _sst_color="$R"
elif echo "$_SST_SUMMARY" | grep -qi "updated"; then
    _sst_color="$Y"
elif echo "$_SST_SUMMARY" | grep -qiE "no Intel SSDs|skipped|no status"; then
    _sst_color="$DIM"
fi
bkv "SSD Firmware:" "$_SST_SUMMARY" "$G" "$_sst_color"
unset _sst_color

_FAN_MODE_RAW=$(printf '%s\n' "$_IPMI_FAN_RAW" | grep -i "Current Fan Speed Mode" \
    | sed 's/.*:[[:space:]]*//' | tr -d '[]' | xargs)
if   printf '%s' "$_FAN_MODE_RAW" | grep -qi "Heavy IO"; then _FAN_MODE="Heavy IO"
elif printf '%s' "$_FAN_MODE_RAW" | grep -qi "Optimal";  then _FAN_MODE="Optimal"
elif printf '%s' "$_FAN_MODE_RAW" | grep -qi "Standard"; then _FAN_MODE="Standard"
elif printf '%s' "$_FAN_MODE_RAW" | grep -qi "Full";     then _FAN_MODE="Full Speed"
else _FAN_MODE="$_FAN_MODE_RAW"; fi

# Parse supported mode numbers dynamically from ipmicfg -fan output.
# Boards differ: some use 2:Optimal, others 3:PUE2 Optimal, etc.
_fan_num_for() {
    local keyword="$1"
    printf '%s\n' "$_IPMI_FAN_RAW" | grep -iE "^[[:space:]]*[0-9]+:.*${keyword}" | grep -oE "^[[:space:]]*[0-9]+" | tr -d ' ' | head -1
}
_FAN_NUM_OPTIMAL=$(_fan_num_for "Optimal")
_FAN_NUM_HEAVYIO=$(_fan_num_for "Heavy")
[ -z "$_FAN_NUM_OPTIMAL" ] && _FAN_NUM_OPTIMAL=2
[ -z "$_FAN_NUM_HEAVYIO" ] && _FAN_NUM_HEAVYIO=4

_SLOTTED_BDFS=$(printf '%s\n' "$_LSPCI_V" | awk '
    /^[0-9a-f]/{bdf=$1; has_slot=0; slot_num=0}
    /Physical Slot:/{slot_num=$NF+0; if(slot_num>0) has_slot=1}
    /^$/ && has_slot{print bdf}
')
_HAS_RAID=0
_HAS_10G=0

# Check if a BDF is a true add-in card by verifying its parent bridge has Slot Implemented+
_is_addon_card() {
    local bus
    bus=$(printf '%s' "$1" | cut -d: -f1)
    local parent
    parent=$(lspci -vvv 2>/dev/null | awk -v tgt="$bus" '
        /^[0-9a-f]/ { cur=$1 }
        /Secondary bus:/ { sec=$NF+0; if (sprintf("%02x",sec)==tgt) { print cur; exit } }
    ')
    [ -n "$parent" ] && lspci -vvv -s "$parent" 2>/dev/null | grep -q "Slot Implemented+"
}

while IFS= read -r _line; do
    _bdf=$(printf '%s' "$_line" | awk '{print $1}')
    [ -z "$_bdf" ] && continue
    # Check if in a physical slot
    _in_slot=0
    printf '%s\n' "$_SLOTTED_BDFS" | grep -q "^${_bdf}$" && _in_slot=1
    [ "$_in_slot" -eq 0 ] && _is_addon_card "$_bdf" && _in_slot=1
    [ "$_in_slot" -eq 0 ] && continue
    if echo "$_line" | grep -qiE "RAID bus controller|RAID controller|Serial Attached SCSI controller|SCSI storage controller"; then
        _HAS_RAID=1
    elif echo "$_line" | grep -qiE "MegaRAID|PERC|Adaptec|SmartRAID|RS3[A-Z]{2}|RMS3[A-Z]{2}|SAS-?[23]|SAS[0-9]{4}|Avago|LSI Logic.*SAS|Broadcom.*SAS|Invader|Fury|Cutlass|Intruder|Crusader"; then
        _HAS_RAID=1
    fi
    echo "$_line" | grep -qiE "Ethernet" && echo "$_line" | grep -qiE \
        "10-Gigabit|10GbE|10GBASE|10G[ -]?SFP|X520|X540|X550|X710|X722|XL710|XXV710|E810|82599|Connect[Xx]-[3-7]|57711|57810|57840|BCM578|Aquantia|Chelsio T[3-6]|MT2[789]|MT4[0-9]" \
        && _HAS_10G=1
done < <(printf '%s\n' "$_LSPCI" | grep -iE "RAID|MegaRAID|SAS|Avago|Broadcom.*SAS|LSI|Ethernet")

unset _SLOTTED_BDFS _bdf _line _in_slot _is_addon_card

if [ "$_HAS_RAID" -eq 1 ] || [ "$_HAS_10G" -eq 1 ]; then
    TARGET_FAN_MODE_NUM=$_FAN_NUM_HEAVYIO; TARGET_FAN_MODE_NAME="Heavy IO"
    _FAN_REASON=""
    [ "$_HAS_RAID" -eq 1 ] && _FAN_REASON="PCIe RAID"
    [ "$_HAS_10G"  -eq 1 ] && _FAN_REASON="${_FAN_REASON:+$_FAN_REASON+}PCIe 10G"
else
    TARGET_FAN_MODE_NUM=$_FAN_NUM_OPTIMAL; TARGET_FAN_MODE_NAME="Optimal"
    _FAN_REASON="no PCIe RAID/10G"
fi

_FAN_OK=0
case "$TARGET_FAN_MODE_NUM" in
    $_FAN_NUM_HEAVYIO) printf '%s' "$_FAN_MODE" | grep -qi "Heavy IO"  && _FAN_OK=1 ;;
    $_FAN_NUM_OPTIMAL) printf '%s' "$_FAN_MODE" | grep -qiE "Optimal"  && _FAN_OK=1 ;;
esac

if [ "$_FAN_OK" -eq 1 ]; then
    bline "$(printf "  %b%-22s%b%b%b%s%b  %b(%s)%b" \
        "$G" "Fan Mode:" "$RST" "$BGG" "$BLK" "$_FAN_MODE" "$RST" "$DIM" "$_FAN_REASON" "$RST")"
else
    _FAN_FIX_REASON="$_FAN_REASON"
    [ ${#_FAN_FIX_REASON} -gt 20 ] && _FAN_FIX_REASON="RAID+10G"
    bline "$(printf "  %b%-22s%b%b%bFixing %s -> %s%b" \
        "$G" "Fan Mode:" "$RST" "$BGR" "$BOLD" "${_FAN_MODE}" "$TARGET_FAN_MODE_NAME" "$RST")"
    _FAN_SET_OK=0
    for _attempt in 1 2; do
        ipmicfg -fan "$TARGET_FAN_MODE_NUM" &>/dev/null
        sleep 0.2
        _FAN_MODE_NEW_RAW=$(ipmicfg -fan 2>/dev/null | grep -i "Current Fan Speed Mode" \
            | sed 's/.*:[[:space:]]*//' | tr -d '[]' | xargs)
        if [ "$TARGET_FAN_MODE_NUM" -eq "$_FAN_NUM_HEAVYIO" ] && printf '%s' "$_FAN_MODE_NEW_RAW" | grep -qi "Heavy IO"; then
            _FAN_SET_OK=1; break
        elif [ "$TARGET_FAN_MODE_NUM" -eq "$_FAN_NUM_OPTIMAL" ] && printf '%s' "$_FAN_MODE_NEW_RAW" | grep -qi "Optimal"; then
            _FAN_SET_OK=1; break
        fi
    done
    if   printf '%s' "$_FAN_MODE_NEW_RAW" | grep -qi "Heavy IO"; then _FAN_MODE_NEW="Heavy IO"
    elif printf '%s' "$_FAN_MODE_NEW_RAW" | grep -qi "Optimal";  then _FAN_MODE_NEW="Optimal"
    elif printf '%s' "$_FAN_MODE_NEW_RAW" | grep -qi "Standard"; then _FAN_MODE_NEW="Standard"
    else _FAN_MODE_NEW="$_FAN_MODE_NEW_RAW"; fi
    if [ "$_FAN_SET_OK" -eq 1 ]; then
        bline "$(printf "  %b%-22s%b%b%b%s%b" \
            "$G" "Fan Mode Now:" "$RST" "$BGG" "$BLK" "${_FAN_MODE_NEW}" "$RST")"
    else
        bline "$(printf "  %b%-22s%b%b%b%s%b  %b(SET FAILED - still %s)%b" \
            "$G" "Fan Mode Now:" "$RST" "$BGR" "$BLK" "${_FAN_MODE_NEW}" "$RST" "$Y" "${_FAN_MODE_NEW}" "$RST")"
    fi
    unset _FAN_SET_OK _FAN_FIX_REASON _attempt
fi
unset _HAS_RAID _HAS_10G TARGET_FAN_MODE_NUM TARGET_FAN_MODE_NAME _FAN_REASON _FAN_OK _FAN_MODE_NEW _FAN_MODE_NEW_RAW _FAN_MODE_RAW _FAN_NUM_OPTIMAL _FAN_NUM_HEAVYIO _fan_num_for

{ _tz_vis=$(timedatectl 2>/dev/null | grep 'Time zone' | awk '{print $3,$4,$5}'); [ -n "$_DC_NAME" ] && [ "$_DC_NAME" != "Unknown" ] && _tz_vis="${_tz_vis}  ($_DC_NAME)"; bkv "Timezone:" "$_tz_vis" "$G" "$DIM"; }

# Private IP ping check (eth1)
_PRIV_IP=$(ip -4 -o addr show eth1 2>/dev/null | awk '{print $4}' | cut -d/ -f1 | head -1)
if [ -n "$_PRIV_IP" ]; then
    if ping -c 1 -W 2 "$_PRIV_IP" >/dev/null 2>&1; then
        bkv "Private Net:" "${_PRIV_IP} (pinging)" "$G" "$G"
    else
        bkv "Private Net:" "${_PRIV_IP} (not pinging)" "$G" "$R"
    fi
fi
unset _PRIV_IP

bdivider

if [ "${SKIP_PSU_CHECK:-0}" != "1" ]; then
    if [ "$_PSU_DETECTED" -gt 0 ]; then
        for _pe in "${_PSU_ENTRIES[@]}"; do
            IFS='|' read -r _pl _ps _pv <<< "$_pe"
            case "$_pv" in
                OK)   bline "$(printf "  %b%-22s%b%b%b %s %b" "$G" "${_pl}:" "$RST" "$BGG" "$BLK" "$_ps" "$RST")" ;;
                WARN) bline "$(printf "  %b%-22s%b%b%b %s %b" "$G" "${_pl}:" "$RST" "$BGY" "$BLK" "$_ps" "$RST")" ;;
                FAIL) bline "$(printf "  %b%-22s%b%b%b %s %b" "$G" "${_pl}:" "$RST" "$BGR" "$BOLD" "$_ps" "$RST")" ;;
            esac
        done
        if [ "$_PSU_DETECTED" -lt "$PSU_EXPECTED_COUNT" ] 2>/dev/null; then
            bline "$(printf "  %b%-22s%b%b%b Only %d of %d PSUs detected %b" \
                "$G" "PSU Warning:" "$RST" "$BGR" "$BOLD" "$_PSU_DETECTED" "$PSU_EXPECTED_COUNT" "$RST")"
        fi
    fi
    unset _pe _pl _ps _pv
    bdivider
fi

printf '%s\n' "$_DMI17" | grep -iE "Part" \
    | grep -ve "NO DIMM" -ve "CPU" -ve "Not" -ve "PartNum" -ve "Empty" -ve "Series" \
    | sort -u > /tmp/_ram_check
RAM_TOTAL="$(free --giga -h -t | grep 'Mem:' | awk '{print $2}')"

if [ "$(<"/tmp/_ram_check" wc -l)" != "1" ]; then
    bline "$(printf "  %b%-22s%b%b%b %s -- WARNING: MISMATCH %b" "$G" "RAM:" "$RST" "$BGR" "$BOLD" "$RAM_TOTAL" "$RST")"
    bempty
    # Show partitions
    _part_count=$(lsblk -lno NAME "$label" 2>/dev/null | grep -v "^$(basename "$label")$" | wc -l)
    if [ "$_part_count" -gt 0 ]; then
        bline "$(printf "    %b%-20s%b%b%d partition(s)%b" "$G" "Partitions:" "$RST" "$DIM" "$_part_count" "$RST")"
        lsblk -lno NAME,SIZE,FSTYPE "$label" 2>/dev/null | grep -v "^$(basename "$label")[[:space:]]" | while read -r pname psize pfs; do
            [ -z "$pname" ] && continue
            bline "$(printf "      %b%-18s %-10s %s%b" "$DIM" "$pname" "$psize" "${pfs:--}" "$RST")"
        done
    else
        bline "$(printf "    %b%-20s%b%bno partitions%b" "$G" "Partitions:" "$RST" "$BGY" "$RST")"
    fi
    printf '%s\n' "$_DMI17" | grep -iE "Locator|Part" | grep -ve "Bank" \
        | sed -e 's/^[ \t]*//' | sed '0~2 a\\' \
        | while IFS= read -r line; do
            bline "$(printf "    %b%s%b" "$Y" "$line" "$RST")"
        done
else
    bline "$(printf "  %b%-22s%b%b%b%b %s -- MATCHES %b" "$G" "RAM:" "$RST" "$BGG" "$BLK" "$BOLD" "$RAM_TOTAL" "$RST")"
fi
rm -f /tmp/_ram_check

_DIMM_LINES=$(printf '%s' "$_DMI17" | awk '
    function emit() { if(size!=""&&size!~/No Module/&&size!~/^[ \t]*$/) print size"|"type"|"speed"|"mfg"|"part"|"detail; size="";type="";speed="";mfg="";part="";detail="" }
    BEGIN{size="";type="";speed="";mfg="";part="";detail=""}
    /^Memory Device$/                        {emit()}
    /^[ \t]*Size:/                           {sub(/^[ \t]*Size:[ \t]*/,"");size=$0}
    /^[ \t]*Type:/&&!/Type Detail/           {sub(/^[ \t]*Type:[ \t]*/,"");type=$0}
    /^[ \t]*Type Detail:/                    {sub(/^[ \t]*Type Detail:[ \t]*/,"");detail=$0}
    /^[ \t]*Speed:/&&!/Configured/           {sub(/^[ \t]*Speed:[ \t]*/,"");speed=$0}
    /^[ \t]*Configured Memory Speed:/        {if(speed==""||speed~/Unknown/){sub(/^[ \t]*Configured Memory Speed:[ \t]*/,"");speed=$0}}
    /^[ \t]*Configured Clock Speed:/         {if(speed==""||speed~/Unknown/){sub(/^[ \t]*Configured Clock Speed:[ \t]*/,"");speed=$0}}
    /^[ \t]*Manufacturer:/                   {sub(/^[ \t]*Manufacturer:[ \t]*/,"");mfg=$0}
    /^[ \t]*Part Number:/                    {sub(/^[ \t]*Part Number:[ \t]*/,"");sub(/[ \t]+$/,"");part=$0}
    END{emit()}')
_RAM_ECC=""
printf '%s\n' "$_DMI16" | grep -qiE "Error Correction Type:[[:space:]]*(Single|Multi|ECC)" && _RAM_ECC="ECC"

# Determine register/buffer type from DMI Type Detail and/or part number conventions:
#   Samsung:  M393* = RDIMM, M386* = LRDIMM, M378/M391 = UDIMM
#   Micron:   MTA18ASF* / MTA36ASF* = RDIMM, MTA72ASS* = LRDIMM, MTA9ASF* = UDIMM
#   Hynix:    HMA84*/HMA82* = RDIMM, HMAA8* = LRDIMM
#   Crucial:  CT*RFS* / 36ASF* = RDIMM
#   Kingston: KSM* = RDIMM
_RAM_REG=""
_first_part=$(printf '%s\n' "$_DIMM_LINES" | grep -v '^$' | head -1 | awk -F'|' '{print $5}')
_first_detail=$(printf '%s\n' "$_DIMM_LINES" | grep -v '^$' | head -1 | awk -F'|' '{print $6}')
# Type Detail wins if it explicitly mentions a buffer type
if echo "$_first_detail" | grep -qi "LRDIMM\|Load Reduced"; then
    _RAM_REG="LRDIMM"
elif echo "$_first_detail" | grep -qi "Registered\|Buffered"; then
    _RAM_REG="RDIMM"
elif echo "$_first_detail" | grep -qi "Unbuffered"; then
    _RAM_REG="UDIMM"
fi
# Fall back to part number prefix
if [ -z "$_RAM_REG" ] && [ -n "$_first_part" ]; then
    case "$_first_part" in
        M386*|HMAA8*|MTA72ASS*)                  _RAM_REG="LRDIMM" ;;
        M393*|HMA84*|HMA82*|HMA81*|MTA18ASF*|MTA36ASF*|36ASF*|KSM*) _RAM_REG="RDIMM" ;;
        M378*|M391*|MTA9ASF*)                    _RAM_REG="UDIMM" ;;
    esac
fi

# Build the combined ECC/REG label -- just two states: ECC (unbuffered) vs ECC/REG (registered/LR)
if [ -n "$_RAM_ECC" ] && [ -n "$_RAM_REG" ] && [ "$_RAM_REG" != "UDIMM" ]; then
    _RAM_LABEL="ECC/REG "
elif [ -n "$_RAM_ECC" ]; then
    _RAM_LABEL="ECC "
else
    _RAM_LABEL=""
fi

_DIMM_GROUPS=$(printf '%s\n' "$_DIMM_LINES" | grep -v '^$' | awk -F'|' '{print $1"|"$2"|"$3"|"$4"|"$5}' | sort | uniq -c \
    | awk '{count=$1;$1="";sub(/^ /,"");print count"|"$0}')
_TOTAL_DIMMS=$(printf '%s\n' "$_DIMM_LINES" | grep -cv '^$')
if [ "$_TOTAL_DIMMS" -gt 0 ]; then
    while IFS='|' read -r count size type speed mfg part; do
        [ -z "$count" ] && continue
        size=$(echo "$size" | sed 's/ //g')
        speed=$(echo "$speed" | sed -E 's/ +/ /g;s/^ //;s/ $//')
        mfg=$(echo "$mfg" | sed -E 's/[ \t]+$//')
        part=$(echo "$part" | sed -E 's/[ \t]+$//')
        { [ -z "$mfg" ]  || [ "$mfg"  = "Unknown" ]; } && mfg=""
        { [ -z "$part" ] || [ "$part" = "Unknown" ]; } && part=""
        if [ -n "$mfg" ] && [ -n "$part" ]; then ident="${mfg}-${part}"
        elif [ -n "$part" ]; then ident="$part"
        elif [ -n "$mfg" ]; then  ident="$mfg"
        else                       ident="(unknown part)"; fi
        line="${count}x ${size} ${type} ${_RAM_LABEL}${ident}"
        [ -n "$speed" ] && [ "$speed" != "Unknown" ] && line="${line} ${speed}"
        bline "$(printf "    %b%s%b" "$C" "$line" "$RST")"
    done <<< "$_DIMM_GROUPS"
fi
unset _DMI17 _DIMM_LINES _DIMM_GROUPS _TOTAL_DIMMS _RAM_ECC _RAM_REG _RAM_LABEL _first_part _first_detail

bdivider

if [ "${SKIP_BOND_CHECK:-0}" != "1" ] && [ "${#_BOND_ENTRIES[@]}" -gt 0 ]; then
    bline "$(printf "  %b%bBond Interfaces:%b" "$BOLD" "$G" "$RST")"
    for _be in "${_BOND_ENTRIES[@]}"; do
        IFS='|' read -r _bn _bd _bv <<< "$_be"
        case "$_bv" in
            PASS) bline "$(printf "    %b%-12s%b %b%s%b" "$BGG$BLK" "$_bn" "$RST" "$G" "$_bd" "$RST")" ;;
            WARN) bline "$(printf "    %b%-12s%b %b%s%b" "$BGY$BLK" "$_bn" "$RST" "$Y" "$_bd" "$RST")" ;;
            FAIL) bline "$(printf "    %b%-12s%b %b%s%b" "$BGR$BOLD" "$_bn" "$RST" "$R" "$_bd" "$RST")" ;;
        esac
    done
    unset _be _bn _bd _bv
    bdivider
fi

if [ "${SKIP_LSPCI:-0}" != "1" ] && [ "${#_PCI_SEEN[@]}" -gt 0 ]; then
    bline "$(printf "  %b%bPCI Devices:%b" "$BOLD" "$G" "$RST")"
    for _ps in "${!_PCI_SEEN[@]}"; do
        _pc=${_PCI_SEEN["$_ps"]}
        if [ "$_pc" -gt 1 ]; then
            bline "$(printf "    %b%dx  %s%b" "$DIM" "$_pc" "$_ps" "$RST")"
        else
            bline "$(printf "    %b%s%b" "$DIM" "$_ps" "$RST")"
        fi
    done
    unset _ps _pc
    bdivider
fi

if [ "${SKIP_NVME_HEALTH:-0}" != "1" ] && [ "${#_NVME_DEVS[@]}" -gt 0 ]; then
    bline "$(printf "  %b%bNVMe Health (nvme smart-log):%b" "$BOLD" "$G" "$RST")"
    bline "$(printf "    %b%-10s  %-28s  %-7s  %-7s  %-10s  %s%b" \
        "$BOLD" "Device" "Model" "Used%" "Spare%" "CritWarn" "Status" "$RST")"
    for _ni in "${!_NVME_DEVS[@]}"; do
        _ns="${_NVME_STATUS[$_ni]}"
        case "$_ns" in
            PASS) _nc="$G" ;;
            WARN) _nc="$Y" ;;
            *)    _nc="$R" ;;
        esac
        bline "$(printf "    %b%-10s%b  %-28s  %-7s  %-7s  %-10s  %b%s%b" \
            "$DIM" "$(basename "${_NVME_DEVS[$_ni]}")" "$RST" \
            "${_NVME_MODELS[$_ni]}" \
            "${_NVME_PCT[$_ni]}" \
            "${_NVME_SPARE[$_ni]}" \
            "${_NVME_WARN[$_ni]}" \
            "$_nc" "$_ns" "$RST")"
    done
    unset _ni _ns _nc
    bdivider
fi

if [ "${SKIP_SEL:-0}" != "1" ]; then
    _SEL_TOTAL=$(( _SEL_CRIT_COUNT + _SEL_WARN_COUNT + _SEL_INFO_COUNT ))
    if [ "$_SEL_TOTAL" -eq 0 ]; then
        bkv "SEL:" "no events" "$G" "$G"
    else
        _sel_summary="${_SEL_TOTAL} event(s)"
        [ "$_SEL_CRIT_COUNT" -gt 0 ] && _sel_summary="${_sel_summary}  ${_SEL_CRIT_COUNT} critical"
        [ "$_SEL_WARN_COUNT" -gt 0 ] && _sel_summary="${_sel_summary}  ${_SEL_WARN_COUNT} warning"
        [ "$_SEL_INFO_COUNT" -gt 0 ] && _sel_summary="${_sel_summary}  ${_SEL_INFO_COUNT} info"
        [ "$_SEL_CRIT_COUNT" -gt 0 ] && bkv "SEL:" "$_sel_summary" "$G" "$R" || bkv "SEL:" "$_sel_summary" "$G" "$Y"
        if [ -n "$_SEL_CRITICAL" ]; then
            bline "$(printf "    %b%bCRITICAL:%b" "$BOLD" "$R" "$RST")"
            printf '%s\n' "$_SEL_CRITICAL" | while IFS= read -r _sl; do
                [ -z "$_sl" ] && continue
                _sv=$(printf '%s' "$_sl" | sed -E 's/\x1b\[[0-9;:]*[mGKHFJA-Za-z]//g')
                [ ${#_sv} -gt 68 ] && _sl="${_sv:0:65}..."
                bline "$(printf "      %b%s%b" "$R" "$_sl" "$RST")"
            done
        fi
        if [ -n "$_SEL_WARN" ]; then
            bline "$(printf "    %b%bWARNING:%b" "$BOLD" "$Y" "$RST")"
            printf '%s\n' "$_SEL_WARN" | while IFS= read -r _sl; do
                [ -z "$_sl" ] && continue
                _sv=$(printf '%s' "$_sl" | sed -E 's/\x1b\[[0-9;:]*[mGKHFJA-Za-z]//g')
                [ ${#_sv} -gt 68 ] && _sl="${_sv:0:65}..."
                bline "$(printf "      %b%s%b" "$Y" "$_sl" "$RST")"
            done
        fi
        if [ -n "$_SEL_INFO" ]; then
            bline "$(printf "    %b%bINFO:%b" "$BOLD" "$DIM" "$RST")"
            printf '%s\n' "$_SEL_INFO" | while IFS= read -r _sl; do
                [ -z "$_sl" ] && continue
                _sv=$(printf '%s' "$_sl" | sed -E 's/\x1b\[[0-9;:]*[mGKHFJA-Za-z]//g')
                [ ${#_sv} -gt 68 ] && _sl="${_sv:0:65}..."
                bline "$(printf "      %b%s%b" "$DIM" "$_sl" "$RST")"
            done
        fi
    fi
    bdivider
fi

bkv "OS:" "$(grep PRETTY_NAME /etc/*release 2>/dev/null | cut -d'"' -f2)" "$G" "$M"
box_close "$C"
fi # END: Server summary


# =============================================================================
#  TOOL INSTALLATION RESULT BOX
# =============================================================================
_TOOL_BITS=""
for entry in "${_TOOL_STATUSES[@]}"; do
    name="${entry%%=*}"; state="${entry##*=}"
    token=$(tool_state_token "$state")
    [ -n "$_TOOL_BITS" ] && _TOOL_BITS="${_TOOL_BITS}, "
    _TOOL_BITS="${_TOOL_BITS}${BOLD}${name}${RST}: ${token}"
done
_TOOL_VIS=$(printf '%s' "  $_TOOL_BITS  " | sed -E 's/\x1b\[[0-9;:]*[mGKHFJA-Za-z]//g')
_TOOL_VLEN=${#_TOOL_VIS}
_TOOL_OLD_W=$W; _TOOL_OLD_INNER=$INNER
[ "$_TOOL_VLEN" -gt "$W" ] && { W=$_TOOL_VLEN; INNER=$_TOOL_VLEN; }

if [ "${SKIP_TOOL_BOX:-0}" != "1" ]; then
box_open "TOOL INSTALLATION" "$C"
bline "  $_TOOL_BITS"
box_close "$C"
fi

W=$_TOOL_OLD_W; INNER=$_TOOL_OLD_INNER
unset _TOOL_BITS _TOOL_VIS _TOOL_VLEN _TOOL_OLD_W _TOOL_OLD_INNER _TOOL_STATUSES


# =============================================================================
#  STORAGE BOX
# =============================================================================
RAID_CARD=$(printf '%s\n' "$_SC_C0" | grep -c "Product Name")
RAID_PD_COUNT=$(printf '%s\n' "$_SC_C0" | grep -i "Physical Drives" | head -1 \
    | awk -F'=' '{print $2}' | xargs)
[ -z "$RAID_PD_COUNT" ] && RAID_PD_COUNT=0
RAID_DRIVE_ROWS=$(printf '%s\n' "$_SC_PDALL" \
    | awk '/[0-9]+:[0-9]+/ && /UGood|Onln|Offln|UBad|GHS|DHS|JBOD/' | wc -l)

if [ "$RAID_CARD" -gt 0 ] 2>/dev/null && \
   { [ "$RAID_PD_COUNT" -gt 0 ] 2>/dev/null || [ "$RAID_DRIVE_ROWS" -gt 0 ] 2>/dev/null; }; then
    IS_RAID=true
else
    IS_RAID=false
fi

if [ "${SKIP_STORAGE:-0}" != "1" ]; then
box_open "STORAGE" "$M"

if $IS_RAID; then
    IS_BBU=1; IS_CV=1
    [ "$_SC_HAS_BBU" = "1" ] && IS_BBU=0
    [ "$_SC_HAS_CV"  = "1" ] && IS_CV=0
    CTRL_NAME=$(printf '%s\n' "$_SC_C0" | grep 'Product Name' | cut -d'=' -f2 | xargs)
    CTRL_FW=$(printf '%s\n' "$_SC_C0" | grep 'FW Package Build' | cut -d'=' -f2 | xargs)

    _RAID_UPDATE_MSG=" $(printf "%b UNABLE TO DETERMINE IF LATEST FW %b" "$DIM" "$RST")"
    _LATEST_RAID_FW=""
    if [ "${#RAID_LATEST[@]}" -gt 0 ] && [ -n "$CTRL_NAME" ]; then
        for _tok in $CTRL_NAME; do
            if [ -n "${RAID_LATEST[$_tok]:-}" ]; then
                _LATEST_RAID_FW="${RAID_LATEST[$_tok]}"; break
            fi
        done
        if [ -z "$_LATEST_RAID_FW" ]; then
            _mod=$(echo "$CTRL_NAME" | grep -oE '[0-9]{4}' | head -1)
            [ -n "$_mod" ] && _LATEST_RAID_FW="${RAID_LATEST[$_mod]:-}"
        fi
    fi
    if [ "$_LATEST_RAID_FW" = "EOL" ]; then
        _RAID_UPDATE_MSG=" $(printf "%b%b !! END OF LIFE -- NO UPDATES %b" "$BGR" "$BOLD" "$RST")"
    elif [ -n "$_LATEST_RAID_FW" ] && [ -n "$CTRL_FW" ]; then
        _crn=$(echo "$CTRL_FW"         | tr '-' '.' | awk -F. '{printf "%05d%05d%05d%05d",$1+0,$2+0,$3+0,$4+0}')
        _lrn=$(echo "$_LATEST_RAID_FW" | tr '-' '.' | awk -F. '{printf "%05d%05d%05d%05d",$1+0,$2+0,$3+0,$4+0}')
        if [[ "$_crn" < "$_lrn" ]]; then
            _RAID_UPDATE_MSG=" $(printf "%b%b UPDATE REQUIRED -> %s %b" "$BGR" "$BOLD" "$_LATEST_RAID_FW" "$RST")"
        elif [[ "$_crn" = "$_lrn" ]]; then
            _RAID_UPDATE_MSG=" $(printf "%b%b LATEST %b" "$BOLD" "$G" "$RST")"
        fi
    fi

    bkv "RAID Controller:" "$CTRL_NAME" "$G" "$Y"
    bkv "Card Firmware:"   "${CTRL_FW}${_RAID_UPDATE_MSG}" "$G" "$C"

    if [ "$IS_BBU" -eq 0 ] || [ "$IS_CV" -eq 0 ]; then
        _bbu_cv_stat="Yes"
        [ "$_SC_HAS_BBU" = "1" ] && _bbu_cv_stat="${_bbu_cv_stat} - Optimal"
        bline "$(printf "  %b%-22s%b%b%b %s %b" "$G" "BBU/CV:" "$RST" "$BGG" "$BLK" "$_bbu_cv_stat" "$RST")"
    else
        bline "$(printf "  %b%-22s%b%b%s%b" "$G" "BBU/CV:" "$RST" "$DIM" "none detected" "$RST")"
    fi

    _VD_OUT="$_SC_VALL"
    _VD_ROWS=$(printf '%s\n' "$_VD_OUT" | grep -E '^ *[0-9][0-9]*/[0-9]')
    if [ -z "$_VD_ROWS" ]; then
        _VD_OUT="$_SC_CALLVALL"
        _VD_ROWS=$(printf '%s\n' "$_VD_OUT" | grep -E '^ *[0-9][0-9]*/[0-9]')
    fi
    _VD_HDR=$(printf '%s\n' "$_VD_OUT" | grep 'DG/VD' | head -1)
    if [ -n "$_VD_ROWS" ]; then
        _VD_DIV=$(printf '%s' "$_VD_HDR" | sed 's/./-/g')
        bdivider
        bline "$(printf "  %b%bVirtual Drives:%b" "$BOLD" "$G" "$RST")"
        bempty
        bline "$(printf "    %b%s%b" "$DIM" "$_VD_DIV" "$RST")"
        bline "$(printf "    %b%s%b" "$BOLD" "$_VD_HDR" "$RST")"
        bline "$(printf "    %b%s%b" "$DIM" "$_VD_DIV" "$RST")"
        while IFS= read -r _vd_line; do
            bline "$(printf "    %b%s%b" "$C" "$_vd_line" "$RST")"
        done < <(printf '%s\n' "$_VD_ROWS")
        bline "$(printf "    %b%s%b" "$DIM" "$_VD_DIV" "$RST")"
        bempty
    fi
    unset _VD_OUT _VD_HDR _VD_ROWS _VD_DIV _vd_line

    _PD_OUT="$_SC_PDALL"
    _PD_ROWS=$(printf '%s' "$_PD_OUT" | grep -E "^[[:space:]]*[0-9]+:[0-9]+" | grep -E "UGood|Onln|Offln|UBad|GHS|DHS|JBOD" | sed 's/^[[:space:]]*//')
    if [ -n "$_PD_ROWS" ]; then
        bdivider
        bline "$(printf "  %b%bPhysical Drives:%b" "$BOLD" "$G" "$RST")"
        bempty
        _PD_HDR=$(printf "%-9s %-5s %-2s %-9s %-4s %-3s %s" "Slot" "State" "DG" "Size" "Intf" "Med" "Model")
        bline "$(printf "    %b%s%b" "$DIM" "$_PD_HDR" "$RST")"
        while IFS= read -r _pd_line; do
            _pd_fmt=$(printf '%s' "$_pd_line" | awk '{size=$5" "$6;model=$12" "$13;printf "%-9s %-5s %-2s %-9s %-4s %-3s %s",$1,$3,$4,size,$7,$8,model}')
            bline "$(printf "    %b%s%b" "$C" "$_pd_fmt" "$RST")"
        done < <(printf '%s\n' "$_PD_ROWS")
        bempty
    fi
    unset _PD_OUT _PD_ROWS _pd_line _pd_fmt _PD_HDR

    bdivider
    bline "$(printf "  %b%bHard Drives:%b" "$BOLD" "$G" "$RST")"
    bempty
    # Show partitions
    _part_count=$(lsblk -lno NAME "$label" 2>/dev/null | grep -v "^$(basename "$label")$" | wc -l)
    if [ "$_part_count" -gt 0 ]; then
        bline "$(printf "    %b%-20s%b%b%d partition(s)%b" "$G" "Partitions:" "$RST" "$DIM" "$_part_count" "$RST")"
        lsblk -lno NAME,SIZE,FSTYPE "$label" 2>/dev/null | grep -v "^$(basename "$label")[[:space:]]" | while read -r pname psize pfs; do
            [ -z "$pname" ] && continue
            bline "$(printf "      %b%-18s %-10s %s%b" "$DIM" "$pname" "$psize" "${pfs:--}" "$RST")"
        done
    else
        bline "$(printf "    %b%-20s%b%bno partitions%b" "$G" "Partitions:" "$RST" "$BGY" "$RST")"
    fi

    _SMART_DRIVES=$(printf '%s\n' "$_SC_PDALL" \
        | awk '/[0-9]+:[0-9]+/ && /UGood|Onln|Offln|UBad|GHS|DHS|JBOD/ { print $1,$2,$3 }')
    _SMART_DIR=$(mktemp -d -t qa_smart.XXXXXX)

    # For JBOD drives, megaraid passthrough doesn't work -- they're exposed
    # as direct /dev/sdX. Build slot-to-blockdev map for JBOD fallback.
    declare -A _JBOD_TO_BLOCKDEV=()
    _jbod_slots=()
    while IFS= read -r _jline; do
        _slot=$(echo "$_jline" | awk '{print $1}')
        [ -n "$_slot" ] && _jbod_slots+=("$_slot")
    done < <(printf '%s\n' "$_SC_PDALL" | awk '/[0-9]+:[0-9]+/ && /JBOD/')
    _blk_devs_jbod=()
    while IFS= read -r _blkl; do
        _blk_devs_jbod+=("/dev/$(echo "$_blkl" | awk '{print $1}')")
    done < <(lsblk -dno NAME,TYPE 2>/dev/null | awk '$2=="disk"' | sort)
    for _ji in "${!_jbod_slots[@]}"; do
        [ -n "${_blk_devs_jbod[$_ji]:-}" ] && _JBOD_TO_BLOCKDEV["${_jbod_slots[$_ji]}"]="${_blk_devs_jbod[$_ji]}"
    done
    unset _jbod_slots _blk_devs_jbod _ji _jline _slot _blkl

    unset _SMART_DRIVES _SMART_DIR

else
    if [ "$RAID_CARD" -gt 0 ] 2>/dev/null; then
        CTRL_NAME=$(printf '%s\n' "$_SC_C0" | grep 'Product Name' | cut -d'=' -f2 | xargs)
        bkv "Controller:" "${CTRL_NAME} (HBA / pass-through)" "$G" "$Y"
        bdivider
    fi
    bline "$(printf "  %b%bHard Drives:%b" "$BOLD" "$G" "$RST")"
    bempty
    # Show partitions
    _part_count=$(lsblk -lno NAME "$label" 2>/dev/null | grep -v "^$(basename "$label")$" | wc -l)
    if [ "$_part_count" -gt 0 ]; then
        bline "$(printf "    %b%-20s%b%b%d partition(s)%b" "$G" "Partitions:" "$RST" "$DIM" "$_part_count" "$RST")"
        lsblk -lno NAME,SIZE,FSTYPE "$label" 2>/dev/null | grep -v "^$(basename "$label")[[:space:]]" | while read -r pname psize pfs; do
            [ -z "$pname" ] && continue
            bline "$(printf "      %b%-18s %-10s %s%b" "$DIM" "$pname" "$psize" "${pfs:--}" "$RST")"
        done
    else
        bline "$(printf "    %b%-20s%b%bno partitions%b" "$G" "Partitions:" "$RST" "$BGY" "$RST")"
    fi
    while IFS= read -r dev; do
        [ -b "$dev" ] || continue
        drive_entry "$dev" -a "$dev"
    done < <(lsblk -dno NAME,TYPE 2>/dev/null | awk '$2=="disk"{print "/dev/"$1}' | sort)
fi

bdivider
bline "$(printf "  %b%bBlock Devices: (lsblk)%b" "$BOLD" "$G" "$RST")"
bempty

declare -A _lb_model_map=()
while IFS= read -r _lm; do
    _lmn=$(echo "$_lm" | awk '{print $1}')
    _lmv=$(echo "$_lm" | cut -d' ' -f2- | xargs)
    [ -n "$_lmn" ] && _lb_model_map["$_lmn"]="$_lmv"
done < <(lsblk -dno NAME,MODEL 2>/dev/null)
if command -v nvme >/dev/null 2>&1; then
    for _nctrl in /dev/nvme[0-9]*; do
        [[ "$(basename "$_nctrl")" =~ ^nvme[0-9]+$ ]] || continue
        _cidx=$(basename "$_nctrl" | grep -oE '[0-9]+$')
        _nsname="nvme${_cidx}n1"
        if [ -z "${_lb_model_map[$_nsname]:-}" ]; then
            _nmod=$(nvme id-ctrl "$_nctrl" 2>/dev/null | awk -F: '/^mn /{gsub(/^[ \t]+/,"",$2); print $2; exit}' | xargs)
            [ -n "$_nmod" ] && _lb_model_map["$_nsname"]="$_nmod"
        fi
    done
fi

while IFS= read -r _lb_line; do
    [ -z "$_lb_line" ] && continue
    _lb_raw_name=$(printf '%s' "$_lb_line" | awk '{print $1}')
    _lb_dev=$(printf '%s' "$_lb_raw_name" | tr -d 'ââââ¦++ ')
    _lb_bytes=$(printf '%s' "$_lb_line" | awk '{print $2}')
    _lb_rest=$(printf '%s' "$_lb_line" | awk '{$1=$2=""; sub(/^  */,""); print}')
    _lb_model="${_lb_model_map[$_lb_dev]:-}"
    _lb_size=$(awk -v b="$_lb_bytes" 'BEGIN{
        if (b+0==0)                    { print "      -" }
        else if (b>=1000000000000)     { printf "%8.2f TB", b/1000000000000 }
        else if (b>=1000000000)        { printf "%8.2f GB", b/1000000000 }
        else if (b>=1000000)           { printf "%8.2f MB", b/1000000 }
        else                           { printf "%8d B",    b }
    }' 2>/dev/null)
    _is_top=0
    printf '%s' "$_lb_raw_name" | grep -qE "^[a-zA-Z]" && _is_top=1
    if [ "$_is_top" -eq 1 ]; then
        bline "$(printf "    %b%-10s%b%s  %b%-6s%b  %b%s%b" \
            "$C"   "$_lb_dev"  "$RST" "$_lb_size" "$DIM" "$_lb_rest" "$RST" "$DIM" "$_lb_model" "$RST")"
    else
        bline "$(printf "    %b%-10s%b%s  %b%-6s%b  %b%s%b" \
            "$DIM" "$_lb_raw_name" "$RST" "$_lb_size" "$DIM" "$_lb_rest" "$RST" "$DIM" "$_lb_model" "$RST")"
    fi
done < <(lsblk -e 7 --bytes -o NAME,SIZE,TYPE,FSTYPE,MOUNTPOINT --noheadings 2>/dev/null)
bempty
box_close "$M"
fi # END: Storage


# =============================================================================
#  PER-DISK SMART BOXES (non-RAID only)
# =============================================================================
if ! $IS_RAID && [ "${SKIP_SMART_PER_DISK:-0}" != "1" ]; then
for dev in sda sdb sdc sdd; do
    [ -b "/dev/${dev}" ] || continue
    box_open "/dev/${dev} SMART" "$B"
    MODEL=$(smartctl -a "/dev/${dev}" 2>/dev/null | grep "Device Model"     | cut -d: -f2 | xargs)
    FW=$(   smartctl -a "/dev/${dev}" 2>/dev/null | grep "Firmware Version" | cut -d: -f2 | xargs)
    bkv "Device Model:" "$MODEL" "$G" "$Y"
    bkv "Firmware:"     "$FW"    "$G" "$C"
    bempty
    # Show partitions
    _part_count=$(lsblk -lno NAME "$label" 2>/dev/null | grep -v "^$(basename "$label")$" | wc -l)
    if [ "$_part_count" -gt 0 ]; then
        bline "$(printf "    %b%-20s%b%b%d partition(s)%b" "$G" "Partitions:" "$RST" "$DIM" "$_part_count" "$RST")"
        lsblk -lno NAME,SIZE,FSTYPE "$label" 2>/dev/null | grep -v "^$(basename "$label")[[:space:]]" | while read -r pname psize pfs; do
            [ -z "$pname" ] && continue
            bline "$(printf "      %b%-18s %-10s %s%b" "$DIM" "$pname" "$psize" "${pfs:--}" "$RST")"
        done
    else
        bline "$(printf "    %b%-20s%b%bno partitions%b" "$G" "Partitions:" "$RST" "$BGY" "$RST")"
    fi
    bline "$(printf "  %b%b%-4s %-30s   %s%b" "$BOLD" "$C" "ID#" "ATTRIBUTE" "VALUE" "$RST")"
    bline "$(printf "  %b%s%b" "$DIM" "$(rep "$(_HD)" 70)" "$RST")"
    smartctl -a "/dev/${dev}" 2>/dev/null \
        | grep -E "Power_On_Hours|Reallocated_Sector|Current_Pending|Wear_Leveling|Media_Wearout|Offline_Unco|Reported_Uncorrect|UDMA_CRC_Error|Total_LBAs_Written" \
        | while read -r id attr f v w t tp up wf raw; do
            case "$attr" in
                Media_Wearout_Indicator|Wear_Leveling_Count)
                    show="$v"; wcolor="$DIM"
                    [ "$v" -lt 80 ] 2>/dev/null && wcolor="$Y"
                    [ "$v" -lt 50 ] 2>/dev/null && wcolor="$R"
                    bline "$(printf "  %b%-4s %-30s   %s%b" "$wcolor" "$id" "$attr" "$show" "$RST")" ;;
                *)
                    show="$raw"
                    if { [ "$v" -lt "$t" ] 2>/dev/null; } || \
                       { [ "$raw" -gt 0 ] 2>/dev/null && echo "$attr" | grep -qE "Reallocated|Pending|Offline_Unco|Reported_Uncorrect|UDMA_CRC_Error"; }; then
                        bline "$(printf "  %b%-4s %-30s   %s%b" "$R"   "$id" "$attr" "$show" "$RST")"
                    else
                        bline "$(printf "  %b%-4s %-30s   %s%b" "$DIM" "$id" "$attr" "$show" "$RST")"
                    fi ;;
            esac
        done
    box_close "$B"
done
fi # END: Per-disk SMART

rm -f "$0"
exit 0