#!/bin/bash

# -- Colors --------------------------------------------------------------------
R=$'\033[1;31m'
G=$'\033[1;32m'
Y=$'\033[1;33m'
C=$'\033[1;36m'
DIM=$'\033[0;37m'
GRAY=$'\033[1;90m'
RST=$'\033[0m'
BOLD=$'\033[1m'
BGG=$'\033[42m'
BGR=$'\033[41m'
BGC=$'\033[46m'
BLK=$'\033[0;30m'

W=74
INNER=74

# -- Box helpers ---------------------------------------------------------------
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; }

_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 ))
    local ls rs
    ls=$(rep ' ' $lpad)
    rs=$(rep ' ' $rpad)
    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)" "$ls" "$RST" "$BOLD" "$Y" "$title" "$RST" "$color" "$rs" "$(_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 vlen=${#vis}
    local pad=$(( INNER - vlen ))
    [ "$pad" -lt 0 ] && pad=0
    local spaces
    spaces=$(rep ' ' "$pad")
    printf "%b%s%b%s%s%b%s%b\n" "$bc" "$(_VB)" "$RST" "$text" "$spaces" "$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}"
    bline "$(printf "    %b%-20s%b%b%s%b" "$lc" "$key" "$RST" "$vc" "$val" "$RST")"
}

# -- Detect OS -----------------------------------------------------------------
if [ -f /etc/debian_version ]; then
    OS="debian"
elif [ -f /etc/redhat-release ]; then
    OS="rhel"
else
    printf "%b%s%b\n" "$R" "Unsupported OS." "$RST"
    exit 1
fi

# Pull pretty name + code name from /etc/os-release if available.
# Examples:
#   PRETTY_NAME="Ubuntu 22.04.4 LTS"  VERSION_CODENAME=jammy
#   PRETTY_NAME="Debian GNU/Linux 12 (bookworm)"  VERSION_CODENAME=bookworm
#   PRETTY_NAME="Red Hat Enterprise Linux 8.10 (Ootpa)"  (no codename var, in parens)
OS_PRETTY=""
OS_CODENAME=""
if [ -r /etc/os-release ]; then
    # shellcheck disable=SC1091
    . /etc/os-release
    OS_PRETTY="${PRETTY_NAME:-}"
    OS_CODENAME="${VERSION_CODENAME:-}"
    # If VERSION_CODENAME wasn't set (e.g. RHEL), try to pull a parenthesized
    # codename out of PRETTY_NAME: "Red Hat Enterprise Linux 8.10 (Ootpa)"
    if [ -z "$OS_CODENAME" ] && [ -n "$OS_PRETTY" ]; then
        OS_CODENAME=$(printf '%s' "$OS_PRETTY" | grep -oE '\([^)]+\)' | head -1 | tr -d '()')
    fi
fi
# Fallback for ancient systems without /etc/os-release
[ -z "$OS_PRETTY" ] && [ "$OS" = "debian" ] && OS_PRETTY="$(cat /etc/debian_version 2>/dev/null)"
[ -z "$OS_PRETTY" ] && [ "$OS" = "rhel" ]   && OS_PRETTY="$(cat /etc/redhat-release 2>/dev/null)"
[ -z "$OS_PRETTY" ] && OS_PRETTY="$(echo "$OS" | tr '[:lower:]' '[:upper:]')"

# ----------------------------------------------------------------------------
# TOOL INSTALLATION (combined into one box)
# ----------------------------------------------------------------------------
# Helper that prints a single status line for a tool. State is one of:
#   present   = was already installed
#   installed = was missing, install succeeded
#   failed    = was missing, install failed
tool_status_line() {
    local name="$1" state="$2"
    case "$state" in
        present)
            bline "$(printf "    %b%-12s%b  %b%b  ALREADY INSTALLED  %b" \
                "$BOLD" "$name" "$RST" "$BGG" "$BLK" "$RST")"
            ;;
        installed)
            bline "$(printf "    %b%-12s%b  %b%b  INSTALLED  %b" \
                "$BOLD" "$name" "$RST" "$BGG" "$BLK" "$RST")"
            ;;
        failed)
            bline "$(printf "    %b%-12s%b  %b%b  INSTALL FAILED  %b" \
                "$BOLD" "$name" "$RST" "$BGR" "$BOLD" "$RST")"
            ;;
    esac
}

box_open "TOOL INSTALLATION" "$C"

# Family label for the row -- "RHEL-based" or "Debian-based"
if [ "$OS" = "debian" ]; then
    OS_FAMILY="Debian-based"
else
    OS_FAMILY="RHEL-based"
fi

# Show OS info as the first rows inside the box
bline "$(printf "    %b%-12s%b  %b%s%b" "$BOLD" "OS:" "$RST" "$Y" "${OS_PRETTY}" "$RST")"
if [ -n "$OS_CODENAME" ]; then
    bline "$(printf "    %b%-12s%b  %b%s%b" "$BOLD" "Codename:" "$RST" "$DIM" "${OS_CODENAME}" "$RST")"
fi
bline "$(printf "    %b%-12s%b  %b%s%b" "$BOLD" "Family:" "$RST" "$C" "${OS_FAMILY}" "$RST")"
bdivider

# -- SST -----------------------------------------------------------------------
SST_URL="http://216.104.40.250/tools/sst"
if [ -f /usr/bin/sst ]; then
    tool_status_line "SST" "present"
else
    if [ "$OS" = "debian" ]; then
        export DEBIAN_FRONTEND=noninteractive
        wget -q "${SST_URL}/sst-cli-linux-deb--2-3.zip" \
            && unzip -q sst-cli-linux-deb--2-3.zip \
            && dpkg -i sst_2.3.320-0_amd64.deb >/dev/null 2>&1
    elif [ "$OS" = "rhel" ]; then
        wget -q "${SST_URL}/sst-cli-linux-rpm--2-3.zip" \
            && unzip -q sst-cli-linux-rpm--2-3.zip \
            && rpm -ivh sst-2.3.320-0.x86_64.rpm >/dev/null 2>&1
    fi
    if [ -f /usr/bin/sst ]; then
        tool_status_line "SST" "installed"
    else
        tool_status_line "SST" "failed"
    fi
fi

# -- IPMICFG -------------------------------------------------------------------
IPMI_URL="http://216.104.40.250/tools/ipmi"
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"

if [ -f "$IPMI_SYMLINK" ] || [ -f /usr/local/bin/ipmicfg ]; then
    tool_status_line "IPMICFG" "present"
else
    wget -q -P /usr/src "${IPMI_URL}/${IPMI_ZIP}" \
        && unzip -q "/usr/src/${IPMI_ZIP}" -d /usr/src \
        && ln -s "$IPMI_BINARY" "$IPMI_SYMLINK" \
        && chmod +x "$IPMI_SYMLINK"
    if [ -f "$IPMI_SYMLINK" ]; then
        tool_status_line "IPMICFG" "installed"
    else
        tool_status_line "IPMICFG" "failed"
    fi
fi

# -- STORCLI -------------------------------------------------------------------
STOR_URL="http://184.154.112.130/raid/lsi/cli"
STOR_BINARY="/opt/MegaRAID/storcli/storcli64"
STOR_SYMLINK="/usr/bin/storcli"

if [ -f "$STOR_SYMLINK" ] || [ -f "$STOR_BINARY" ]; then
    tool_status_line "STORCLI" "present"
else
    if [ "$OS" = "debian" ]; then
        PKG="storcli_007.1017.0000.0000_all.deb"
        wget -q "${STOR_URL}/${PKG}" -P /usr/src \
            && dpkg -i "/usr/src/${PKG}" >/dev/null 2>&1
    elif [ "$OS" = "rhel" ]; then
        PKG="storcli-007.1017.0000.0000-1.noarch.rpm"
        wget -q "${STOR_URL}/${PKG}" -P /usr/src \
            && rpm -ivh "/usr/src/${PKG}" >/dev/null 2>&1
    fi
    if [ -f "$STOR_BINARY" ]; then
        cp "$STOR_BINARY" "$STOR_SYMLINK" && chmod +x "$STOR_SYMLINK"
        tool_status_line "STORCLI" "installed"
    else
        tool_status_line "STORCLI" "failed"
    fi
fi

box_close "$C"

# ----------------------------------------------------------------------------
# SSD / NVME FIRMWARE UPDATES
# ----------------------------------------------------------------------------
box_open "SSD / NVME FIRMWARE UPDATES" "$C"

sst set -system EnableLSIAdapter=true >/dev/null 2>&1

SST_DATA=$(sst show -ssd 2>/dev/null)
SST_TMP=$(mktemp)

echo "$SST_DATA" | awk '
    function flush() {
        if (idx != "" && path != "")
            print idx "|" path "|" model "|" serial "|" fw "|" status
    }
    BEGIN { idx=""; path=""; model=""; serial=""; fw=""; status="" }
    /^- .* -$/ { flush(); idx=""; path=""; model=""; serial=""; fw=""; status="" }
    /^Index[ \t]*:/            { idx=$NF }
    /^DevicePath[ \t]*:/       { path=$NF }
    /^ModelNumber[ \t]*:/      { model=""; for(i=2;i<=NF;i++) if($i!=":") model=model (model!=""?" ":"") $i }
    /^SerialNumber[ \t]*:/     { serial=$NF }
    /^Firmware[ \t]*:/         { fw=$NF }
    /^FirmwareUpdateAvailable/ { status=($0 ~ /current firmware/) ? "UP-TO-DATE" : "UPDATE-AVAILABLE" }
    END { flush() }
' > "$SST_TMP"

DISK_NUM=0
while IFS="|" read -r idx path model serial fw status; do

    size=$(echo "$SST_DATA" | awk -v p="$path" '
        /^- .* -$/ { cap="" }
        /^Capacity/ { cap=$3 " " $4 }
        /^DevicePath/ && $NF==p { print cap; exit }
    ')

    # Silently skip RAID controller only
    if echo "$model" | grep -qiE "^SMC[0-9]|^MegaRAID|^Avago|^Broadcom" \
    || echo "$path"  | grep -qiE "^/dev/bus/"; then
        DISK_NUM=$(( DISK_NUM + 1 ))
        continue
    fi

    bempty
    bdivider

    # Show HDDs as skipped (behind RAID controller = LSI path, or known HDD model)
    if echo "$path"  | grep -qiE "^LSI[0-9]*$" \
    || echo "$model" | grep -qiE "TOSHIBA|MG0[0-9]|ST[0-9]|HUS[0-9]|WD[0-9]|HGST|SEAGATE|HITACHI"; then
        bline "$(printf "  %b%bDISK%s:%b  %b[HDD - SKIPPED]%b" "$BOLD" "$GRAY" "$DISK_NUM" "$RST" "$DIM" "$RST")"
        bkv "Model:"    "${model:-N/A}"  "$DIM" "$GRAY"
        bkv "Serial:"   "${serial:-N/A}" "$DIM" "$GRAY"
        bkv "Size:"     "${size:-N/A}"   "$DIM" "$GRAY"
        bkv "Firmware:" "${fw:-N/A}"     "$DIM" "$GRAY"
        DISK_NUM=$(( DISK_NUM + 1 ))
        continue
    fi

    # Intel SSD / NVMe
    if [ "$status" = "UP-TO-DATE" ]; then
        badge="${BGG}${BLK}${BOLD}  UP-TO-DATE  ${RST}"
        label_color="$G"
    elif [ "$status" = "UPDATE-AVAILABLE" ]; then
        if sst load -f -ssd "$idx" >/dev/null 2>&1; then
            badge="${BGG}${BLK}${BOLD}  UPDATED  ${RST}"
            label_color="$Y"
        else
            badge="${BGR}${BOLD}  FAILED  ${RST}"
            label_color="$R"
        fi
    else
        badge="${DIM}  UNKNOWN  ${RST}"
        label_color="$DIM"
    fi

    bline "$(printf "  %b%bDISK%s:%b  %b" "$BOLD" "$label_color" "$DISK_NUM" "$RST" "$badge")"
    bkv "Model:"    "${model:-N/A}"   "$G" "$C"
    bkv "Serial:"   "${serial:-N/A}"  "$G" "$DIM"
    bkv "Size:"     "${size:-N/A}"    "$G" "$C"
    bkv "Firmware:" "${fw:-N/A}"      "$G" "$Y"
    DISK_NUM=$(( DISK_NUM + 1 ))

done < "$SST_TMP"
rm -f "$SST_TMP"

bempty
box_close "$C"