CPUTempMonitoring.sh

#!/bin/bash

# CPU Temperature Monitor with Color Coding & Bar Graph
# Displays all CPU cores with temperatures color-coded from blue (idle) to red (critical)
# Automatically adjusts temperature zones based on detected CPU model
# Truvis Thornton [ http://truv.is ]

# ============================================================================
# Default Configuration Variables
# ============================================================================

STATS_TIME_WINDOW=24
HIDE_NA_CORES=false
SHOW_STATS=true
SHOW_FREQUENCY=true
TEMP_DISPLAY="both"
USE_MEMORY_TRACKING=false
REFRESH_INTERVAL=2
LOG_FILE="/var/log/cpu_temps.log"

# ============================================================================
# Command Line Argument Parsing
# ============================================================================

show_help() {
    cat << EOF
CPU Temperature Monitor - Version 2
Usage: $(basename "$0") [OPTIONS]

Options:
  -h, --help              Show this help message
  -w, --window HOURS      Set stats time window (default: 24 hours)
  -r, --refresh SECONDS   Set refresh interval (default: 2 seconds)
  -t, --temp FORMAT       Temperature format: both|celsius|fahrenheit (default: both)
  -s, --hide-stats        Hide min/max statistics column
  -f, --hide-freq         Hide frequency column
  -n, --hide-na           Hide cores with no temperature data
  -m, --memory            Use in-memory tracking (no log file)
  -l, --logfile PATH      Set log file path (default: /var/log/cpu_temps.log)

Examples:
  $(basename "$0")                          # Use default settings
  $(basename "$0") -w 12 -r 5               # 12h window, 5s refresh
  $(basename "$0") -t celsius -s            # Celsius only, hide stats
  $(basename "$0") --hide-stats --hide-freq # Minimal view with just temps

EOF
    exit 0
}

while [[ $# -gt 0 ]]; do
    case $1 in
        -h|--help) show_help ;;
        -w|--window)
            STATS_TIME_WINDOW="$2"
            if ! [[ "$STATS_TIME_WINDOW" =~ ^[0-9]+$ ]]; then
                echo "Error: Time window must be a positive integer"
                exit 1
            fi
            shift 2 ;;
        -r|--refresh)
            REFRESH_INTERVAL="$2"
            if ! [[ "$REFRESH_INTERVAL" =~ ^[0-9]+$ ]]; then
                echo "Error: Refresh interval must be a positive integer"
                exit 1
            fi
            shift 2 ;;
        -t|--temp)
            TEMP_DISPLAY="$2"
            if [[ ! "$TEMP_DISPLAY" =~ ^(both|celsius|fahrenheit)$ ]]; then
                echo "Error: Temperature format must be 'both', 'celsius', or 'fahrenheit'"
                exit 1
            fi
            shift 2 ;;
        -s|--hide-stats) SHOW_STATS=false; shift ;;
        -f|--hide-freq) SHOW_FREQUENCY=false; shift ;;
        -n|--hide-na) HIDE_NA_CORES=true; shift ;;
        -m|--memory) USE_MEMORY_TRACKING=true; shift ;;
        -l|--logfile) LOG_FILE="$2"; shift 2 ;;
        *)
            echo "Error: Unknown option: $1"
            echo "Use -h or --help for usage information"
            exit 1 ;;
    esac
done

# ============================================================================
# Validation & Setup
# ============================================================================

if [ "$EUID" -ne 0 ]; then
    echo "Please run as root (sudo)"
    exit 1
fi

if ! command -v sensors &> /dev/null; then
    echo "sensors command not found. Please install lm-sensors:"
    echo "  Ubuntu/Debian: sudo apt install lm-sensors"
    echo "  RHEL/CentOS:   sudo yum install lm-sensors"
    echo "  Arch:          sudo pacman -S lm_sensors"
    echo ""
    echo "After installation, run: sudo sensors-detect"
    exit 1
fi

# ============================================================================
# Global Variables
# ============================================================================

IDLE_MAX=40
NORMAL_MAX=75
CAUTION_MAX=85
WARM_MAX=94
CRITICAL_START=95
TJMAX=100
CPU_TYPE="Generic"
IS_LAPTOP=false

RESET="\033[0m"
BOLD="\033[1m"
LIGHTBLUE="\033[38;5;117m"
CYAN="\033[38;5;51m"
GRAY="\033[38;5;240m"
YELLOW="\033[38;5;226m"
WHITE="\033[38;5;15m"
BLACK="\033[38;5;16m"
DARKBLUE_BG="\033[48;5;17m"
PURPLE_BG="\033[48;5;54m"
TEMPINFO_BG="\033[48;5;240m"
YELLOW_BG="\033[48;5;220m"

declare -A MEMORY_LOG

# ============================================================================
# CPU Detection Function
# ============================================================================

detect_cpu_and_set_thresholds() {
    local cpu_model=$(lscpu | grep "Model name:" | cut -d: -f2 | xargs)
    
    if [ -d "/sys/class/power_supply/BAT0" ] || [ -d "/sys/class/power_supply/BAT1" ] || \
       grep -qi "laptop\|notebook\|portable" /sys/devices/virtual/dmi/id/chassis_type 2>/dev/null; then
        IS_LAPTOP=true
    fi
    
    # Intel 12th-14th Gen
    if echo "$cpu_model" | grep -qi "i[3579]-1[234][0-9]\{3\}"; then
        if echo "$cpu_model" | grep -qi "HX\|HK\|H\|P\|U"; then
            CPU_TYPE="Intel 12th-14th Gen Mobile"
            IDLE_MAX=50; NORMAL_MAX=85; CAUTION_MAX=90; WARM_MAX=95; CRITICAL_START=96; TJMAX=100
        else
            CPU_TYPE="Intel 12th-14th Gen Desktop"
            IDLE_MAX=40; NORMAL_MAX=75; CAUTION_MAX=85; WARM_MAX=95; CRITICAL_START=96; TJMAX=100
        fi
    # Intel 11th Gen and older
    elif echo "$cpu_model" | grep -qi "i[3579]-1[01][0-9]\{3\}"; then
        if echo "$cpu_model" | grep -qi "HX\|HK\|H\|P\|U"; then
            CPU_TYPE="Intel 11th Gen or Older Mobile"
            IDLE_MAX=45; NORMAL_MAX=80; CAUTION_MAX=85; WARM_MAX=90; CRITICAL_START=91; TJMAX=100
        else
            CPU_TYPE="Intel 11th Gen or Older Desktop"
            IDLE_MAX=35; NORMAL_MAX=70; CAUTION_MAX=80; WARM_MAX=90; CRITICAL_START=91; TJMAX=100
        fi
    # AMD Ryzen 7000 Series
    elif echo "$cpu_model" | grep -qi "Ryzen.*7[0-9]\{3\}"; then
        if echo "$cpu_model" | grep -qi "X3D"; then
            CPU_TYPE="AMD Ryzen 7000 X3D"
            IDLE_MAX=45; NORMAL_MAX=70; CAUTION_MAX=80; WARM_MAX=85; CRITICAL_START=86; TJMAX=89
        elif echo "$cpu_model" | grep -qi "HS\|H\|U"; then
            CPU_TYPE="AMD Ryzen 7000 Mobile"
            IDLE_MAX=50; NORMAL_MAX=85; CAUTION_MAX=90; WARM_MAX=93; CRITICAL_START=94; TJMAX=95
        else
            CPU_TYPE="AMD Ryzen 7000 Desktop"
            IDLE_MAX=45; NORMAL_MAX=80; CAUTION_MAX=88; WARM_MAX=92; CRITICAL_START=93; TJMAX=95
        fi
    # AMD Ryzen 5000 Series
    elif echo "$cpu_model" | grep -qi "Ryzen.*5[0-9]\{3\}"; then
        if echo "$cpu_model" | grep -qi "X3D"; then
            CPU_TYPE="AMD Ryzen 5000 X3D"
            IDLE_MAX=40; NORMAL_MAX=70; CAUTION_MAX=80; WARM_MAX=85; CRITICAL_START=86; TJMAX=90
        elif echo "$cpu_model" | grep -qi "5600X"; then
            CPU_TYPE="AMD Ryzen 5 5600X"
            IDLE_MAX=35; NORMAL_MAX=70; CAUTION_MAX=85; WARM_MAX=90; CRITICAL_START=91; TJMAX=95
        elif echo "$cpu_model" | grep -qi "5800X"; then
            CPU_TYPE="AMD Ryzen 7 5800X"
            IDLE_MAX=45; NORMAL_MAX=75; CAUTION_MAX=82; WARM_MAX=87; CRITICAL_START=88; TJMAX=90
        elif echo "$cpu_model" | grep -qi "HS\|H\|U"; then
            CPU_TYPE="AMD Ryzen 5000 Mobile"
            IDLE_MAX=45; NORMAL_MAX=80; CAUTION_MAX=85; WARM_MAX=88; CRITICAL_START=89; TJMAX=95
        else
            CPU_TYPE="AMD Ryzen 5000 Desktop"
            IDLE_MAX=40; NORMAL_MAX=70; CAUTION_MAX=80; WARM_MAX=87; CRITICAL_START=88; TJMAX=90
        fi
    # AMD Ryzen 3000/4000 Series
    elif echo "$cpu_model" | grep -qi "Ryzen.*[34][0-9]\{3\}"; then
        if echo "$cpu_model" | grep -qi "HS\|H\|U"; then
            CPU_TYPE="AMD Ryzen 3000/4000 Mobile"
            IDLE_MAX=45; NORMAL_MAX=75; CAUTION_MAX=85; WARM_MAX=90; CRITICAL_START=91; TJMAX=95
        else
            CPU_TYPE="AMD Ryzen 3000/4000 Desktop"
            IDLE_MAX=35; NORMAL_MAX=65; CAUTION_MAX=75; WARM_MAX=85; CRITICAL_START=86; TJMAX=95
        fi
    # Generic fallback
    else
        if [ "$IS_LAPTOP" = true ]; then
            CPU_TYPE="Generic Laptop CPU"
            IDLE_MAX=50; NORMAL_MAX=80; CAUTION_MAX=85; WARM_MAX=90; CRITICAL_START=91; TJMAX=100
        else
            CPU_TYPE="Generic Desktop CPU"
            IDLE_MAX=40; NORMAL_MAX=70; CAUTION_MAX=80; WARM_MAX=90; CRITICAL_START=91; TJMAX=100
        fi
    fi
}

# ============================================================================
# Color Functions
# ============================================================================

get_color() {
    local temp=$1
    
    if [ "$temp" -le "$IDLE_MAX" ]; then
        if [ "$temp" -le 5 ]; then echo -e "\033[38;5;93m"
        elif [ "$temp" -le 25 ]; then echo -e "\033[38;5;51m"
        elif [ "$temp" -le 30 ]; then echo -e "\033[38;5;45m"
        else echo -e "\033[38;5;39m"; fi
    elif [ "$temp" -le "$NORMAL_MAX" ]; then
        local green_range=$((NORMAL_MAX - IDLE_MAX))
        local temp_in_range=$((temp - IDLE_MAX))
        local pct=$((temp_in_range * 100 / green_range))
        
        if [ $pct -le 20 ]; then echo -e "\033[38;5;46m"
        elif [ $pct -le 40 ]; then echo -e "\033[38;5;82m"
        elif [ $pct -le 60 ]; then echo -e "\033[38;5;118m"
        elif [ $pct -le 80 ]; then echo -e "\033[38;5;154m"
        else echo -e "\033[38;5;190m"; fi
    elif [ "$temp" -le "$CAUTION_MAX" ]; then
        echo -e "\033[38;5;226m"
    elif [ "$temp" -le "$WARM_MAX" ]; then
        echo -e "\033[38;5;208m"
    else
        echo -e "\033[38;5;196m"
    fi
}

create_bar_with_temp() {
    local temp=$1
    local temp_f=$2
    local target_width=$3
    local min_temp=28
    local max_temp=$((TJMAX + 5))
    local bar_length=$target_width
    
    local bar="｢"
    local filled=0

    if [ "$temp" -le "$min_temp" ]; then
        filled=1
        if [ "$temp" -le 5 ]; then
            bar+="\033[38;5;93m■${RESET}"
        else
            bar+="\033[38;5;117m■${RESET}"
        fi
    else
        if [ "$temp" -gt "$max_temp" ]; then temp=$max_temp; fi
        filled=$((temp - min_temp + 1))
        bar+="\033[38;5;117m■${RESET}"
        for ((i=1; i<filled; i++)); do
            local actual_temp=$((min_temp + i))
            local pos_color=$(get_color "$actual_temp")
            bar+="${pos_color}■${RESET}"
        done
    fi

    local empty=$((bar_length - filled))
    for ((i=0; i<empty; i++)); do
        bar+="\033[48;5;232m\033[38;5;240m■\033[0m"
    done

    local current_temp_color=$(get_color "$temp")
    local temp_display
    
    if [ "$TEMP_DISPLAY" = "celsius" ]; then
        temp_display="${current_temp_color}$(printf "%2d" "$temp")°C${RESET}"
    elif [ "$TEMP_DISPLAY" = "fahrenheit" ]; then
        temp_display="${current_temp_color}$(printf "%3d" "$temp_f")°F${RESET}"
    else
        temp_display="${current_temp_color}$(printf "%2d" "$temp")°C${RESET}${BOLD}${WHITE}/${RESET}${current_temp_color}$(printf "%3d" "$temp_f")°F${RESET}"
    fi
    
    bar+="\033[0m｣ ${temp_display}"
    echo -e "$bar"
}

# ============================================================================
# Logging Functions
# ============================================================================

log_temperature() {
    local core=$1
    local temp=$2
    local timestamp=$(date +%s)
    
    if [ "$USE_MEMORY_TRACKING" = "true" ]; then
        MEMORY_LOG["${timestamp}:${core}"]="${timestamp}|${core}|${temp}"
    else
        echo "${timestamp}|${core}|${temp}" >> "$LOG_FILE"
    fi
}

get_stats() {
    local core=$1
    local cutoff=$(($(date +%s) - (STATS_TIME_WINDOW * 3600)))

    if [ "$USE_MEMORY_TRACKING" = "true" ]; then
        local temps=""
        for key in "${!MEMORY_LOG[@]}"; do
            local entry="${MEMORY_LOG[$key]}"
            local timestamp=$(echo "$entry" | cut -d'|' -f1)
            local entry_core=$(echo "$entry" | cut -d'|' -f2)
            local temp=$(echo "$entry" | cut -d'|' -f3)
            
            if [ "$entry_core" = "$core" ] && [ "$timestamp" -ge "$cutoff" ]; then
                temps="${temps}${temp}"$'\n'
            fi
        done
        
        if [ -z "$temps" ]; then
            echo "N/A|N/A"
            return
        fi
        
        local min=$(echo "$temps" | grep -v '^$' | sort -n | head -1)
        local max=$(echo "$temps" | grep -v '^$' | sort -n | tail -1)
        echo "${min}|${max}"
    else
        if [ ! -f "$LOG_FILE" ]; then
            echo "N/A|N/A"
            return
        fi

        local temps=$(awk -F'|' -v c="$core" -v cutoff="$cutoff" '$1 >= cutoff && $2 == c {print $3}' "$LOG_FILE")
        if [ -z "$temps" ]; then
            echo "N/A|N/A"
            return
        fi

        local min=$(echo "$temps" | sort -n | head -1)
        local max=$(echo "$temps" | sort -n | tail -1)
        echo "${min}|${max}"
    fi
}

clean_old_logs() {
    local cutoff=$(($(date +%s) - (STATS_TIME_WINDOW * 3600)))
    
    if [ "$USE_MEMORY_TRACKING" = "true" ]; then
        for key in "${!MEMORY_LOG[@]}"; do
            local entry="${MEMORY_LOG[$key]}"
            local timestamp=$(echo "$entry" | cut -d'|' -f1)
            if [ "$timestamp" -lt "$cutoff" ]; then
                unset MEMORY_LOG["$key"]
            fi
        done
    else
        if [ ! -f "$LOG_FILE" ]; then return; fi
        local temp_file=$(mktemp)
        awk -F'|' -v c="$cutoff" '$1 >= c' "$LOG_FILE" > "$temp_file"
        if [ -s "$temp_file" ]; then
            mv "$temp_file" "$LOG_FILE"
        else
            > "$LOG_FILE"
            rm -f "$temp_file"
        fi
    fi
}

# ============================================================================
# Main Execution
# ============================================================================

detect_cpu_and_set_thresholds

trap 'echo -e "\n${GRAY}Monitoring stopped.${RESET}"; exit 0' INT

while true; do
    clean_old_logs
    clear

    TERM_WIDTH=$(tput cols)
    BORDER_LINE=$(printf '═%.0s' $(seq 1 $((TERM_WIDTH - 2))))

    # Header
    echo -e "${PURPLE_BG}${BOLD}${LIGHTBLUE}╔${BORDER_LINE}╗${RESET}"
    TITLE="CPU Temperature Monitor - Version 2 [ Truvis Thornton - http://truv.is ]"
    TITLE_PAD=$((TERM_WIDTH - ${#TITLE} - 4))
    if [ $TITLE_PAD -lt 0 ]; then TITLE_PAD=0; fi
    echo -e "${PURPLE_BG}${BOLD}${LIGHTBLUE}║${RESET}${PURPLE_BG} ${BOLD}${YELLOW}${TITLE}$(printf ' %.0s' $(seq 1 $TITLE_PAD)) ${RESET}${PURPLE_BG}${BOLD}${LIGHTBLUE}║${RESET}"
    
    REFRESH_TEXT="Refreshing every ${REFRESH_INTERVAL}s - Stats: ${STATS_TIME_WINDOW}h$([ "$USE_MEMORY_TRACKING" = "true" ] && echo " (Memory)") - Ctrl+C to exit"
    REFRESH_PAD=$((TERM_WIDTH - ${#REFRESH_TEXT} - 4))
    if [ $REFRESH_PAD -lt 0 ]; then REFRESH_PAD=0; fi
    echo -e "${PURPLE_BG}${BOLD}${LIGHTBLUE}║${RESET}${PURPLE_BG} ${WHITE}${REFRESH_TEXT}$(printf ' %.0s' $(seq 1 $REFRESH_PAD)) ${RESET}${PURPLE_BG}${BOLD}${LIGHTBLUE}║${RESET}"
    echo -e "${PURPLE_BG}${BOLD}${LIGHTBLUE}╠${BORDER_LINE}╣${RESET}"

    # CPU Info & Temp Zones
    TJMAX_F=$(( (TJMAX * 9 / 5) + 32 ))
    IDLE_MAX_F=$(( (IDLE_MAX * 9 / 5) + 32 ))
    NORMAL_START=$((IDLE_MAX + 1))
    NORMAL_START_F=$(( (NORMAL_START * 9 / 5) + 32 ))
    NORMAL_MAX_F=$(( (NORMAL_MAX * 9 / 5) + 32 ))
    CAUTION_START=$((NORMAL_MAX + 1))
    CAUTION_START_F=$(( (CAUTION_START * 9 / 5) + 32 ))
    CAUTION_MAX_F=$(( (CAUTION_MAX * 9 / 5) + 32 ))
    WARM_START=$((CAUTION_MAX + 1))
    WARM_START_F=$(( (WARM_START * 9 / 5) + 32 ))
    WARM_MAX_F=$(( (WARM_MAX * 9 / 5) + 32 ))
    CRITICAL_START_F=$(( (CRITICAL_START * 9 / 5) + 32 ))
    
    CPU_INFO="Detected: ${CPU_TYPE} | TJmax: ${TJMAX}°C (${TJMAX_F}°F)"
    CPU_PAD=$((TERM_WIDTH - ${#CPU_INFO} - 4))
    if [ $CPU_PAD -lt 0 ]; then CPU_PAD=0; fi
    echo -e "${PURPLE_BG}${BOLD}${LIGHTBLUE}║${RESET}${TEMPINFO_BG} ${BOLD}${CYAN}${CPU_INFO}$(printf ' %.0s' $(seq 1 $CPU_PAD)) ${RESET}${PURPLE_BG}${BOLD}${LIGHTBLUE}║${RESET}"

    # Temperature zones
    INFO1_VISIBLE="🌡️ Idle: ≤${IDLE_MAX}°C (≤${IDLE_MAX_F}°F) - Blue (Light CPU Activity)"
    INFO1_PAD=$((TERM_WIDTH - ${#INFO1_VISIBLE} - 3))
    if [ $INFO1_PAD -lt 0 ]; then INFO1_PAD=0; fi
    echo -e "${PURPLE_BG}${BOLD}${LIGHTBLUE}║${RESET}${TEMPINFO_BG} ${LIGHTBLUE}🌡️${RESET}${TEMPINFO_BG}${WHITE} Idle: ≤${IDLE_MAX}°C (≤${IDLE_MAX_F}°F) - Blue (Light CPU Activity)${RESET}${TEMPINFO_BG}$(printf ' %.0s' $(seq 1 $INFO1_PAD)) ${RESET}${PURPLE_BG}${BOLD}${LIGHTBLUE}║${RESET}"

    INFO2_VISIBLE="🌡️ Normal: ${NORMAL_START}°C to ${NORMAL_MAX}°C (${NORMAL_START_F}°F to ${NORMAL_MAX_F}°F) - Green (Under Workloads)"
    INFO2_PAD=$((TERM_WIDTH - ${#INFO2_VISIBLE} - 3))
    if [ $INFO2_PAD -lt 0 ]; then INFO2_PAD=0; fi
    echo -e "${PURPLE_BG}${BOLD}${LIGHTBLUE}║${RESET}${TEMPINFO_BG} \033[38;5;46m🌡️${RESET}${TEMPINFO_BG}${WHITE} Normal: ${NORMAL_START}°C to ${NORMAL_MAX}°C (${NORMAL_START_F}°F to ${NORMAL_MAX_F}°F) - Green (Under Workloads)${RESET}${TEMPINFO_BG}$(printf ' %.0s' $(seq 1 $INFO2_PAD)) ${RESET}${PURPLE_BG}${BOLD}${LIGHTBLUE}║${RESET}"

    INFO3_VISIBLE="🌡️ Caution: ${CAUTION_START}°C to ${CAUTION_MAX}°C (${CAUTION_START_F}°F to ${CAUTION_MAX_F}°F) - Yellow (Elevated)"
    INFO3_PAD=$((TERM_WIDTH - ${#INFO3_VISIBLE} - 3))
    if [ $INFO3_PAD -lt 0 ]; then INFO3_PAD=0; fi
    echo -e "${PURPLE_BG}${BOLD}${LIGHTBLUE}║${RESET}${TEMPINFO_BG} \033[38;5;226m🌡️${RESET}${TEMPINFO_BG}${WHITE} Caution: ${CAUTION_START}°C to ${CAUTION_MAX}°C (${CAUTION_START_F}°F to ${CAUTION_MAX_F}°F) - Yellow (Elevated)${RESET}${TEMPINFO_BG}$(printf ' %.0s' $(seq 1 $INFO3_PAD)) ${RESET}${PURPLE_BG}${BOLD}${LIGHTBLUE}║${RESET}"

    INFO4_VISIBLE="🌡️ Warm: ${WARM_START}°C to ${WARM_MAX}°C (${WARM_START_F}°F to ${WARM_MAX_F}°F) - Orange (Degradation Risk)"
    INFO4_PAD=$((TERM_WIDTH - ${#INFO4_VISIBLE} - 3))
    if [ $INFO4_PAD -lt 0 ]; then INFO4_PAD=0; fi
    echo -e "${PURPLE_BG}${BOLD}${LIGHTBLUE}║${RESET}${TEMPINFO_BG} \033[38;5;208m🌡️${RESET}${TEMPINFO_BG}${WHITE} Warm: ${WARM_START}°C to ${WARM_MAX}°C (${WARM_START_F}°F to ${WARM_MAX_F}°F) - Orange (Degradation Risk)${RESET}${TEMPINFO_BG}$(printf ' %.0s' $(seq 1 $INFO4_PAD)) ${RESET}${PURPLE_BG}${BOLD}${LIGHTBLUE}║${RESET}"

    INFO5_VISIBLE="🌡️ Critical: ≥${CRITICAL_START}°C (≥${CRITICAL_START_F}°F) - Red (Throttling/Shutdown Risk)"
    INFO5_PAD=$((TERM_WIDTH - ${#INFO5_VISIBLE} - 3))
    if [ $INFO5_PAD -lt 0 ]; then INFO5_PAD=0; fi
    echo -e "${PURPLE_BG}${BOLD}${LIGHTBLUE}║${RESET}${TEMPINFO_BG} \033[38;5;196m🌡️${RESET}${TEMPINFO_BG}${WHITE} Critical: ≥${CRITICAL_START}°C (≥${CRITICAL_START_F}°F) - Red (Throttling/Shutdown Risk)${RESET}${TEMPINFO_BG}$(printf ' %.0s' $(seq 1 $INFO5_PAD)) ${RESET}${PURPLE_BG}${BOLD}${LIGHTBLUE}║${RESET}"

    echo -e "${PURPLE_BG}${BOLD}${LIGHTBLUE}╚${BORDER_LINE}╝${RESET}"

    # System info
    HOSTNAME=$(hostname)
    IP=$(hostname -I | awk '{print $1}')
    CPU_MODEL=$(lscpu | grep "Model name:" | cut -d: -f2- | xargs | sed 's/  */ /g')
    if [ -z "$CPU_MODEL" ]; then
        CPU_MODEL="Unknown CPU"
    fi
    CORES=$(lscpu | grep "^Core(s) per socket:" | awk '{print $NF}')
    SOCKETS=$(lscpu | grep "^Socket(s):" | awk '{print $NF}')
    TOTAL_CORES=$((CORES * SOCKETS))
    LOGICAL=$(nproc)

    echo -e "${YELLOW_BG}${BLACK}╔${BORDER_LINE}╗${RESET}"
    HOST_INFO="🖥️  ${HOSTNAME} • 🖧 ${IP:-No IP}"
    HOST_PAD=$((TERM_WIDTH - ${#HOST_INFO} - 2))
    if [ $HOST_PAD -lt 0 ]; then HOST_PAD=0; fi
    echo -e "${YELLOW_BG}${BLACK}║${RESET}${YELLOW_BG}${BLACK} ${HOST_INFO}$(printf ' %.0s' $(seq 1 $HOST_PAD))${RESET}${YELLOW_BG}${BLACK}║${RESET}"
    
    CPU_INFO_LINE="🔲 ${CPU_MODEL}"
    CPU_PAD=$((TERM_WIDTH - ${#CPU_INFO_LINE} - 4))
    if [ $CPU_PAD -lt 0 ]; then CPU_PAD=0; fi
    echo -e "${YELLOW_BG}${BLACK}║${RESET}${YELLOW_BG}${BLACK} ${CPU_INFO_LINE}$(printf ' %.0s' $(seq 1 $CPU_PAD))${RESET}${YELLOW_BG}${BLACK}║${RESET}"
    
    CORE_INFO="⚙️  ${TOTAL_CORES} Physical Cores / ${LOGICAL} Logical Processors"
    CORE_PAD=$((TERM_WIDTH - ${#CORE_INFO} - 2))
    if [ $CORE_PAD -lt 0 ]; then CORE_PAD=0; fi
    echo -e "${YELLOW_BG}${BLACK}║${RESET}${YELLOW_BG}${BLACK} ${CORE_INFO}$(printf ' %.0s' $(seq 1 $CORE_PAD))${RESET}${YELLOW_BG}${BLACK}║${RESET}"
    echo -e "${YELLOW_BG}${BLACK}╠${BORDER_LINE}╣${RESET}"
    echo -e "${BOLD}${LIGHTBLUE}╠${BORDER_LINE}╣${RESET}"

    # Calculate visible widths for each component
    case "$TEMP_DISPLAY" in
        "celsius")
            TEMP_VISIBLE_WIDTH=4  # "35°C"
            ;;
        "fahrenheit")
            TEMP_VISIBLE_WIDTH=5  # " 95°F"
            ;;
        *)  # both
            TEMP_VISIBLE_WIDTH=11  # "35°C/ 95°F"
            ;;
    esac
    
    # Calculate stats column width
    if [ "$SHOW_STATS" = "true" ]; then
        case "$TEMP_DISPLAY" in
            "celsius")
                STATS_CONTENT_WIDTH=9  # "25°C-60°C"
                ;;
            "fahrenheit")
                STATS_CONTENT_WIDTH=11  # " 77°F-140°F"
                ;;
            *)  # both
                STATS_CONTENT_WIDTH=23  # "25°C/ 77°F-60°C/140°F"
                ;;
        esac
        STATS_TOTAL_WIDTH=$((STATS_CONTENT_WIDTH + 4))  # content + [ + space + space + ]
    else
        STATS_TOTAL_WIDTH=0
        STATS_CONTENT_WIDTH=0
    fi
    
    # Calculate frequency column width
    if [ "$SHOW_FREQUENCY" = "true" ]; then
        FREQ_CONTENT_WIDTH=8  # "4700 MHz"
        FREQ_TOTAL_WIDTH=$((FREQ_CONTENT_WIDTH + 4))  # content + [ + space + space + ]
    else
        FREQ_TOTAL_WIDTH=0
        FREQ_CONTENT_WIDTH=0
    fi
    
    # Fixed widths
    CORE_LABEL_WIDTH=14  # "[ Core 0     ]"
    BAR_BRACKETS=3  # "｢｣ "
    BORDERS=4  # "║ " and " ║"
    
    # Calculate bar width
    # Total = Border(4) + CoreLabel(14) + Space(1) + BarBrackets(3) + BarBlocks(?) + Temp(?) + Stats(?) + Freq(?)
    FIXED_WIDTH=$((BORDERS + CORE_LABEL_WIDTH + 1 + BAR_BRACKETS + TEMP_VISIBLE_WIDTH))
    
    if [ "$SHOW_STATS" = "true" ]; then
        FIXED_WIDTH=$((FIXED_WIDTH + 1 + STATS_TOTAL_WIDTH))  # space + stats column
    fi
    
    if [ "$SHOW_FREQUENCY" = "true" ]; then
        FIXED_WIDTH=$((FIXED_WIDTH + 1 + FREQ_TOTAL_WIDTH))  # space + freq column
    fi
    
    BAR_WIDTH=$((TERM_WIDTH - FIXED_WIDTH))
    if [ $BAR_WIDTH -lt 50 ]; then
        BAR_WIDTH=50
    fi

    # Header row
    printf "${LIGHTBLUE}║${RESET}${DARKBLUE_BG} ${LIGHTBLUE}[${RESET}${DARKBLUE_BG} ${BOLD}${CYAN}%-10s${RESET}${DARKBLUE_BG} ${LIGHTBLUE}]${RESET}${DARKBLUE_BG} ${BOLD}${CYAN}TEMPERATURE" "CPU CORE"
    
    # Pad temperature column to align with bar + temp display
    TEMP_COL_WIDTH=$((BAR_WIDTH + BAR_BRACKETS + TEMP_VISIBLE_WIDTH))
    TEMP_HEADER_LEN=11  # "TEMPERATURE"
    TEMP_PAD=$((TEMP_COL_WIDTH - TEMP_HEADER_LEN - 2))
    printf "%${TEMP_PAD}s${RESET}${DARKBLUE_BG}" ""
    
    if [ "$SHOW_STATS" = "true" ]; then
        STATS_HEADER="${STATS_TIME_WINDOW}H MIN/MAX"
        STATS_HEADER_LEN=${#STATS_HEADER}
        STATS_PAD=$((STATS_CONTENT_WIDTH - STATS_HEADER_LEN))
        printf " ${LIGHTBLUE}[${RESET}${DARKBLUE_BG} ${BOLD}${CYAN}${STATS_HEADER}"
        printf "%${STATS_PAD}s${RESET}${DARKBLUE_BG} ${LIGHTBLUE}]${RESET}${DARKBLUE_BG}" ""
    fi
    
    if [ "$SHOW_FREQUENCY" = "true" ]; then
        FREQ_HEADER="FREQUENCY"
        FREQ_HEADER_LEN=9
        FREQ_PAD=$((FREQ_CONTENT_WIDTH - FREQ_HEADER_LEN))
        printf " ${LIGHTBLUE}[${RESET}${DARKBLUE_BG} ${BOLD}${CYAN}${FREQ_HEADER}"
        printf "%${FREQ_PAD}s${RESET}${DARKBLUE_BG} ${LIGHTBLUE}]${RESET}${DARKBLUE_BG}" ""
    fi
    
    printf " ${LIGHTBLUE}║${RESET}\n"
    printf "${LIGHTBLUE}║${RESET} $(printf -- '-%.0s' $(seq 1 $((TERM_WIDTH - 4)))) ${LIGHTBLUE}║${RESET}\n"

    # Parse temps
    declare -A CORE_TEMPS
    declare -A PACKAGE_TEMP
    
    while IFS= read -r line; do
        if echo "$line" | grep -qi "^Core [0-9]"; then
            core_num=$(echo "$line" | grep -oP 'Core \K[0-9]+')
            temp_str=$(echo "$line" | grep -oP '\+\d+\.\d+°C' | head -1 | tr -d '+°C')
            [ -n "$temp_str" ] && CORE_TEMPS[$core_num]=$(printf "%.0f" "$temp_str" 2>/dev/null)
        elif echo "$line" | grep -qi "^Package\|^Tctl\|^Tdie"; then
            temp_str=$(echo "$line" | grep -oP '\+\d+\.\d+°C' | head -1 | tr -d '+°C')
            [ -n "$temp_str" ] && PACKAGE_TEMP[0]=$(printf "%.0f" "$temp_str" 2>/dev/null)
        fi
    done <<< "$(sensors 2>/dev/null)"

    # Display cores
    THREADS_PER_CORE=$((LOGICAL / TOTAL_CORES))
    for ((core=0; core<TOTAL_CORES; core++)); do
        temp=${CORE_TEMPS[$core]:-${PACKAGE_TEMP[0]}}
        [ -z "$temp" ] && continue
        
        temp_f=$(( (temp * 9 / 5) + 32 ))
        bar=$(create_bar_with_temp "$temp" "$temp_f" "$BAR_WIDTH")
        log_temperature "Core $core" "$temp"
        
        printf "${LIGHTBLUE}║${RESET} ${LIGHTBLUE}[${RESET} ${BOLD}${WHITE}%-10s${RESET} ${LIGHTBLUE}]${RESET} " "Core $core"
        echo -n "$bar"
        
        if [ "$SHOW_STATS" = "true" ]; then
            stats=$(get_stats "Core $core")
            min_t=$(echo "$stats" | cut -d'|' -f1)
            max_t=$(echo "$stats" | cut -d'|' -f2)
            
            printf " ${LIGHTBLUE}[${RESET} "
            if [ "$min_t" = "N/A" ]; then
                printf "${GRAY}%-${STATS_CONTENT_WIDTH}s${RESET}" "N/A"
            else
                min_c=$(get_color "$min_t")
                max_c=$(get_color "$max_t")
                if [ "$TEMP_DISPLAY" = "celsius" ]; then
                    printf "${min_c}%2d°C${RESET}-${max_c}%2d°C${RESET}" "$min_t" "$max_t"
                elif [ "$TEMP_DISPLAY" = "fahrenheit" ]; then
                    min_f=$(( (min_t * 9 / 5) + 32 ))
                    max_f=$(( (max_t * 9 / 5) + 32 ))
                    printf "${min_c}%3d°F${RESET}-${max_c}%3d°F${RESET}" "$min_f" "$max_f"
                else
                    min_f=$(( (min_t * 9 / 5) + 32 ))
                    max_f=$(( (max_t * 9 / 5) + 32 ))
                    printf "${min_c}%2d°C${RESET}/${min_c}%3d°F${RESET}-${max_c}%2d°C${RESET}/${max_c}%3d°F${RESET}" "$min_t" "$min_f" "$max_t" "$max_f"
                fi
            fi
            printf " ${LIGHTBLUE}]${RESET}"
        fi
        
        if [ "$SHOW_FREQUENCY" = "true" ]; then
            cpu_id=$((core * THREADS_PER_CORE))
            printf " ${LIGHTBLUE}[${RESET} "
            if [ -f "/sys/devices/system/cpu/cpu${cpu_id}/cpufreq/scaling_cur_freq" ]; then
                freq=$(cat /sys/devices/system/cpu/cpu${cpu_id}/cpufreq/scaling_cur_freq 2>/dev/null)
                freq_mhz=$((freq / 1000))
                printf "${WHITE}%4d MHz${RESET}" "$freq_mhz"
            else
                printf "${WHITE}%-${FREQ_CONTENT_WIDTH}s${RESET}" "N/A"
            fi
            printf " ${LIGHTBLUE}]${RESET}"
        fi
        
        printf " ${LIGHTBLUE}║${RESET}\n"
    done

    echo -e "${BOLD}${LIGHTBLUE}╚${BORDER_LINE}╝${RESET}"
    echo ""
    
    sleep $REFRESH_INTERVAL
done