#!/bin/bash

###############################################################
# MOTD/Login Quick Information script                         #
# This script pulls information from a variety of sources     #
# in a Linux system, and aggregates it into a small table     #
# that is displayed upon terminal login to the system.        #
#                                                             #
#           Written by Alan "pyr0ball" Weinstock              #
#           Enhanced for multi-distro compatibility           #
###############################################################

quickinfo_version=4.0.0
prbl_functons_req_ver=2.1.0

# Source PRbL Functions locally or retrieve from online
if [ ! -z $prbl_functions ] ; then
    source $prbl_functions
else
    if [ -f ${rundir}/functions ] ; then
        source ${rundir}/functions
    else
        # Iterate through get commands and fall back on next if unavailable
        if command -v curl >/dev/null 2>&1; then
            source <(curl -ks 'https://raw.githubusercontent.com/pyr0ball/PRbL/main/functions')
        elif command -v wget >/dev/null 2>&1; then
            source <(wget -qO- 'https://raw.githubusercontent.com/pyr0ball/PRbL/main/functions')
        elif command -v fetch >/dev/null 2>&1; then
            source <(fetch -qo- 'https://raw.githubusercontent.com/pyr0ball/PRbL/main/functions')
        else
            echo "Error: curl, wget, and fetch commands are not available. Please install one to retrieve PRbL functions."
            exit 1
        fi
    fi
fi

# Locate script information
scriptname="${BASH_SOURCE[0]##*/}"
rundir="${BASH_SOURCE[0]%/*}"

########################################
# Default quickinfo bashrc Preferences #
########################################

# Disable run on non-interactive sessions (set true to disable)
interactive_only=false

# Network Adapter Preferences
# set false to hide network adapters without valid IP's
show_disconnected=true

# Ignored network adapter names (regex match)
# separate adapter names with '\|' ex. "lo\|tun0"
filtered_adapters="lo"

# Disks
allowed_disk_prefixes=(
  sd
  md
  mapper
  nvme
  mmcblk
  root
  vd  # For virtual disks (KVM/Xen)
  xvd # For Xen virtual disks
)

disallowed_disk_prefixes=(
  boot
  snap # Exclude snap mounts
  loop # Exclude loop devices
)

# Settings for additional information display
show_gpu_info=true
show_container_info=true
show_service_status=true
show_security_info=true
show_smart_status=false # Requires root privileges or sudo config
show_top_processes=true

# Services to check (space separated list)
critical_services="sshd nginx apache2 mysqld mariadb docker containerd kubelet cron"

#######################################################
# Do not change these unless you know what you're doing
# convert array to grep string
for prefix in "${allowed_disk_prefixes[@]}" ; do
  allowed_disk_prefixes_string+="\\|$prefix"
done
# Remove the leading '\|' from the grep string
allowed_disk_prefixes_string="${allowed_disk_prefixes_string:2}"

for prefix in "${disallowed_disk_prefixes[@]}" ; do
  disallowed_disk_prefixes_string+="\\|$prefix"
done
disallowed_disk_prefixes_string="${disallowed_disk_prefixes_string:2}"

# check PRbL functions version
if command -v vercomp >/dev/null 2>&1; then
  if [[ $(vercomp $functionsrev $prbl_functons_req_ver) == 2 ]] ; then
    warn "PRbL functions installed are lower than recommended ($prbl_functons_req_ver)"
    warn "Some features may not work as expected"
  fi
fi

################################
# Enhanced OS Detection Function
################################

detect_os() {
  # Initialize OS info variables
  OS="Unknown"
  VER="Unknown"
  ID="Unknown"
  
  # Method 1: lsb_release
  if command -v lsb_release >/dev/null 2>&1; then
    OS=$(lsb_release -si)
    VER=$(lsb_release -sr)
    ID=$(lsb_release -si | tr '[:upper:]' '[:lower:]')
    return
  fi
  
  # Method 2: /etc/os-release
  if [ -f /etc/os-release ]; then
    . /etc/os-release
    OS=$NAME
    VER=$VERSION_ID
    ID=${ID:-$NAME}
    ID=$(echo $ID | tr '[:upper:]' '[:lower:]')
    return
  fi
  
  # Method 3: /etc/lsb-release
  if [ -f /etc/lsb-release ]; then
    . /etc/lsb-release
    OS=$DISTRIB_ID
    VER=$DISTRIB_RELEASE
    ID=$(echo $DISTRIB_ID | tr '[:upper:]' '[:lower:]')
    return
  fi
  
  # Method 4: /etc/{system}-release files
  for release_file in /etc/*-release; do
    if [ -f "$release_file" ] && [ "$release_file" != "/etc/os-release" ] && [ "$release_file" != "/etc/lsb-release" ]; then
      OS=$(head -n1 "$release_file" | cut -d' ' -f1)
      VER=$(head -n1 "$release_file" | grep -o -E '[0-9]+\.[0-9]+' | head -n1)
      ID=$(echo $OS | tr '[:upper:]' '[:lower:]')
      return
    fi
  done
  
  # Method 5: Fallback to uname
  OS=$(uname -s)
  VER=$(uname -r)
  ID=$(echo $OS | tr '[:upper:]' '[:lower:]')
}

################################
# Package Manager Detection
################################

detect_package_manager() {
  package_manager="unknown"
  update_cmd=""
  update_check_cmd=""
  
  if command -v apt >/dev/null 2>&1 || command -v apt-get >/dev/null 2>&1; then
    package_manager="apt"
    update_cmd="apt update && apt upgrade"
    if [ -f /usr/lib/update-notifier/apt-check ]; then
      update_check_cmd="/usr/lib/update-notifier/apt-check --human-readable"
    else
      update_check_cmd="apt list --upgradable 2>/dev/null | grep -c ^"
    fi
  elif command -v dnf >/dev/null 2>&1; then
    package_manager="dnf"
    update_cmd="dnf upgrade"
    update_check_cmd="dnf check-update --quiet | grep -v \"^$\" | wc -l"
  elif command -v yum >/dev/null 2>&1; then
    package_manager="yum"
    update_cmd="yum update"
    update_check_cmd="yum check-update --quiet | grep -v \"^$\" | wc -l"
  elif command -v pacman >/dev/null 2>&1; then
    package_manager="pacman"
    update_cmd="pacman -Syu"
    update_check_cmd="pacman -Qu | wc -l"
  elif command -v zypper >/dev/null 2>&1; then
    package_manager="zypper"
    update_cmd="zypper update"
    update_check_cmd="zypper list-updates | grep -c \"^v \""
  elif command -v apk >/dev/null 2>&1; then
    package_manager="apk"
    update_cmd="apk update && apk upgrade"
    update_check_cmd="apk version -v | grep -c upgradable"
  fi
}

################################
# Check for Updates
################################

check_for_updates() {
  packages_available=0
  security_updates=0
  need_updates=false
  
  case $package_manager in
    apt)
      if [ -f /usr/lib/update-notifier/apt-check ]; then
        packages_available=$(/usr/lib/update-notifier/apt-check 2>&1 | cut -d';' -f1)
        security_updates=$(/usr/lib/update-notifier/apt-check 2>&1 | cut -d';' -f2)
        
        if [ $packages_available -gt 0 ]; then
          packages="${packages_available} updates can be installed"
          need_updates=true
        else
          packages="0 updates available"
        fi
        
        if [ $security_updates -gt 0 ]; then
          supdates="${security_updates} security updates"
          need_updates=true
        else
          supdates="0 security updates"
        fi
      else
        # If apt-check isn't available, try an alternative method
        if command -v apt >/dev/null 2>&1; then
          # This method requires root/sudo, will be empty if not available
          packages_available=$(apt list --upgradable 2>/dev/null | grep -c upgradable || echo "unknown")
          if [[ "$packages_available" != "unknown" && $packages_available -gt 0 ]]; then
            packages="${packages_available} updates can be installed"
            need_updates=true
          else
            packages="unknown updates available"
          fi
        fi
      fi
      ;;
      
    dnf|yum)
      # Check if we can run as non-root
      if timeout 5 $package_manager check-update -q &>/dev/null; then
        packages_available=$($update_check_cmd)
        if [ $packages_available -gt 0 ]; then
          packages="${packages_available} updates can be installed"
          need_updates=true
        else
          packages="0 updates available"
        fi
      else
        packages="Need root to check updates"
      fi
      ;;
      
    pacman)
      if pacman -Qu &>/dev/null; then
        packages_available=$(pacman -Qu | wc -l)
        if [ $packages_available -gt 0 ]; then
          packages="${packages_available} updates can be installed"
          need_updates=true
        else
          packages="0 updates available"
        fi
      else
        packages="Need to run 'pacman -Sy' to check updates"
      fi
      ;;
      
    zypper)
      if timeout 5 zypper list-updates &>/dev/null; then
        packages_available=$(zypper list-updates | grep '^v ' | wc -l)
        if [ $packages_available -gt 0 ]; then
          packages="${packages_available} updates can be installed"
          need_updates=true
        else
          packages="0 updates available"
        fi
      else
        packages="Need root to check updates"
      fi
      ;;
      
    apk)
      if timeout 5 apk version -v &>/dev/null; then
        packages_available=$(apk version -v | grep -c upgradable)
        if [ $packages_available -gt 0 ]; then
          packages="${packages_available} updates can be installed"
          need_updates=true
        else
          packages="0 updates available"
        fi
      else
        packages="Need root to check updates"
      fi
      ;;
      
    *)
      packages="Unknown package manager"
      ;;
  esac
  
  # Check for release upgrade
  release_upgrade=""
  if [ -x /usr/lib/ubuntu-release-upgrader/release-upgrade-motd ]; then
    if [ -f /var/lib/ubuntu-release-upgrader/release-upgrade-available ]; then
      release_upgrade="$(cat /var/lib/ubuntu-release-upgrader/release-upgrade-available)"
      need_updates=true
    fi
  fi
}

################################
# CPU Temperature
################################

get_cpu_temp() {
  cputemp="N/A"
  
  # Method 1: lm-sensors
  if command -v sensors >/dev/null 2>&1; then
    temp=$(sensors | grep -m 1 -E 'Core 0|CPU Temp|Tdie' | grep -o -E '[0-9]+\.[0-9]+' | head -n1)
    if [ ! -z "$temp" ]; then
      cputemp=$(printf "%.0f" $temp)
    fi
  fi
  
  # Method 2: /sys/class/thermal
  if [ "$cputemp" = "N/A" ] && [ -d /sys/class/thermal ]; then
    for zone in /sys/class/thermal/thermal_zone*/temp; do
      if [ -f "$zone" ]; then
        temp=$(cat "$zone")
        if [ $temp -gt 0 ]; then
          # Convert millidegrees to degrees
          cputemp=$(( temp / 1000 ))
          break
        fi
      fi
    done
  fi
  
  # Method 3: Raspberry Pi specific
  if [ "$cputemp" = "N/A" ] && [ -f /sys/class/thermal/thermal_zone0/temp ]; then
    temp=$(cat /sys/class/thermal/thermal_zone0/temp)
    cputemp=$(( temp / 1000 ))
  fi
  
  # Add color warning if temperature is high
  if [[ "$cputemp" != "N/A" ]]; then
    if [[ "$cputemp" -gt "65" ]]; then
      cputemp="${ong}${blk}${cputemp}°C${dfl}"
    else
      cputemp="${cputemp}°C"
    fi
  fi
}

################################
# GPU Information
################################

get_gpu_info() {
  gpu_info="N/A"
  gpu_temp="N/A"
  gpu_util="N/A"
  
  # Check for NVIDIA GPU with nvidia-smi
  if command -v nvidia-smi >/dev/null 2>&1; then
    gpu_info=$(nvidia-smi --query-gpu=name --format=csv,noheader | head -n1 | cut -c -30)
    gpu_temp=$(nvidia-smi --query-gpu=temperature.gpu --format=csv,noheader | head -n1)
    gpu_util=$(nvidia-smi --query-gpu=utilization.gpu --format=csv,noheader | head -n1 | cut -d' ' -f1)
    
    # Add color to GPU temperature
    if [[ "$gpu_temp" != "N/A" ]]; then
      if [[ "$gpu_temp" -gt "70" ]]; then
        gpu_temp="${ong}${blk}${gpu_temp}°C${dfl}"
      else
        gpu_temp="${gpu_temp}°C"
      fi
    fi
    
    have_gpu=true
    return
  fi
  
  # Check for AMD GPU with rocm-smi
  if command -v rocm-smi >/dev/null 2>&1; then
    gpu_info=$(rocm-smi --showproductname | grep -v "===" | head -n1 | awk '{print $2}' | cut -c -30)
    gpu_temp=$(rocm-smi --showtemp | grep -v "===" | head -n1 | awk '{print $2}')
    
    # Add color to GPU temperature
    if [[ "$gpu_temp" != "N/A" ]]; then
      if [[ "$gpu_temp" -gt "70" ]]; then
        gpu_temp="${ong}${blk}${gpu_temp}°C${dfl}"
      else
        gpu_temp="${gpu_temp}°C"
      fi
    fi
    
    have_gpu=true
    return
  fi
  
  # Basic GPU detection through lspci
  if command -v lspci >/dev/null 2>&1; then
    gpu_info=$(lspci | grep -i 'vga\|3d\|display' | head -n1 | cut -d: -f3 | cut -c -30)
    if [ ! -z "$gpu_info" ]; then
      have_gpu=true
      return
    fi
  fi
  
  have_gpu=false
}

################################
# Get Container/VM Information
################################

get_container_info() {
  container_type="N/A"
  container_stats="N/A"
  in_container=false
  
  # Check if running in Docker
  if [ -f /.dockerenv ] || grep -q docker /proc/1/cgroup 2>/dev/null; then
    container_type="Docker"
    in_container=true
  fi
  
  # Check if running in LXC/LXD
  if grep -q lxc /proc/1/cgroup 2>/dev/null; then
    container_type="LXC"
    in_container=true
  fi
  
  # Check if running in Kubernetes
  if [ -f /var/run/secrets/kubernetes.io/serviceaccount/namespace ]; then
    container_type="Kubernetes Pod"
    in_container=true
  fi
  
  # Check for systemd-nspawn
  if [ -d /run/systemd/nspawn ]; then
    container_type="systemd-nspawn"
    in_container=true
  fi
  
  # Check for VM
  if [ "$in_container" = false ]; then
    if command -v systemd-detect-virt >/dev/null 2>&1; then
      virt=$(systemd-detect-virt)
      if [ "$virt" != "none" ]; then
        container_type="VM ($virt)"
        in_container=true
      fi
    elif [ -e /proc/cpuinfo ]; then
      if grep -q "hypervisor" /proc/cpuinfo; then
        container_type="VM (unknown)"
        in_container=true
      fi
    fi
  fi
  
  # Get Docker container stats if Docker is installed
  if command -v docker >/dev/null 2>&1 && [ "$in_container" = false ]; then
    container_count=$(docker ps -q 2>/dev/null | wc -l || echo "0")
    if [ "$container_count" -gt 0 ]; then
      container_stats="$container_count running Docker containers"
      have_containers=true
    else
      container_stats="No running containers"
      have_containers=false
    fi
  fi
  
  # Get LXC container stats if LXC is installed
  if command -v lxc >/dev/null 2>&1 && [ "$in_container" = false ]; then
    container_count=$(lxc list --format csv -c s | grep -c RUNNING 2>/dev/null || echo "0")
    if [ "$container_count" -gt 0 ]; then
      container_stats="$container_stats, $container_count running LXC containers"
      have_containers=true
    fi
  fi
}

################################
# Get Service Status
################################

get_service_status() {
  services_down=()
  
  if command -v systemctl >/dev/null 2>&1; then
    for service in $critical_services; do
      if systemctl is-active --quiet $service 2>/dev/null; then
        # Service is running, do nothing
        :
      elif systemctl is-enabled --quiet $service 2>/dev/null; then
        # Service is enabled but not running
        services_down+=("$service")
      fi
    done
  elif command -v service >/dev/null 2>&1; then
    for service in $critical_services; do
      if service $service status &>/dev/null; then
        # Service is running, do nothing
        :
      else
        # Check if service exists but is not running
        if [ -f "/etc/init.d/$service" ]; then
          services_down+=("$service")
        fi
      fi
    done
  fi
  
  if [ ${#services_down[@]} -gt 0 ]; then
    service_status="${lrd}Services down: ${services_down[*]}${dfl}"
    have_service_issues=true
  else
    service_status="${grn}All monitored services running${dfl}"
    have_service_issues=false
  fi
}

################################
# Get Security Information
################################

get_security_info() {
  failed_logins=0
  last_login="N/A"
  ssh_sessions=0
  
  # Get failed login attempts
  if command -v journalctl >/dev/null 2>&1; then
    failed_logins=$(journalctl -u sshd --since yesterday | grep -c "Failed password")
  elif [ -f /var/log/auth.log ]; then
    failed_logins=$(grep -c "Failed password" /var/log/auth.log)
  fi
  
  # Get last successful login
  if command -v last >/dev/null 2>&1; then
    last_user=$(who am i | awk '{print $1}')
    if [ ! -z "$last_user" ]; then
      last_login=$(last -n 2 $last_user | head -n 1 | awk '{print $4" "$5" "$6" "$7}')
    fi
  fi
  
  # Get current SSH sessions
  if command -v who >/dev/null 2>&1; then
    ssh_sessions=$(who | grep -c "pts")
  fi
  
  # Get firewall status
  if command -v ufw >/dev/null 2>&1; then
    firewall_status=$(ufw status | head -n 1)
  elif command -v firewall-cmd >/dev/null 2>&1; then
    firewall_status="firewalld: $(firewall-cmd --state)"
  elif command -v iptables >/dev/null 2>&1; then
    iptables_rules=$(iptables -L -n | grep -c "REJECT\|DROP")
    if [ $iptables_rules -gt 0 ]; then
      firewall_status="iptables: $iptables_rules blocking rules active"
    else
      firewall_status="iptables: No blocking rules found"
    fi
  else
    firewall_status="No firewall detected"
  fi
}

################################
# Get SMART Disk Status
################################

get_smart_status() {
  smart_alerts=()
  
  if command -v smartctl >/dev/null 2>&1; then
    for disk in $(lsblk -d -o name | grep -E "^($allowed_disk_prefixes_string)" | grep -v -E "^($disallowed_disk_prefixes_string)"); do
      # Try to run smartctl without sudo first
      smart_status=$(smartctl -H /dev/$disk 2>/dev/null)
      if [ $? -ne 0 ]; then
        # If failed, try with sudo if available (won't work without password prompt in most cases)
        if command -v sudo >/dev/null 2>&1; then
          smart_status=$(sudo -n smartctl -H /dev/$disk 2>/dev/null || echo "Permission denied")
        else
          smart_status="Permission denied"
        fi
      fi
      
      if echo "$smart_status" | grep -q "FAILED"; then
        smart_alerts+=("${lrd}/dev/$disk FAILED${dfl}")
      elif echo "$smart_status" | grep -q "Permission denied"; then
        continue
      fi
    done
  fi
  
  if [ ${#smart_alerts[@]} -gt 0 ]; then
    smart_status="${lrd}SMART Alerts: ${smart_alerts[*]}${dfl}"
    have_smart_issues=true
  else
    smart_status="${grn}No SMART alerts detected${dfl}"
    have_smart_issues=false
  fi
}

################################
# Get Top Processes
################################

get_top_processes() {
  if command -v ps >/dev/null 2>&1; then
    # Get top 3 CPU processes
    top_cpu=$(ps -eo pcpu,pid,user,args --sort=-pcpu | head -n 4 | tail -n 3 | awk '{printf "%-5s %-8s %-15.15s\n", $1"%", $3, $4}')
    
    # Get top 3 memory processes
    top_mem=$(ps -eo pmem,pid,user,args --sort=-pmem | head -n 4 | tail -n 3 | awk '{printf "%-5s %-8s %-15.15s\n", $1"%", $3, $4}')
  fi
}

################################
# Main Logic
################################

# Run detection functions
detect_os
detect_package_manager
check_for_updates
get_cpu_temp

# Get network information
location=$(uname -a | awk '{print $2}')
image_version=$(uname -r)
software_version="$OS $VER"
mem_usage=$(free -m | grep Mem | awk '{print $3"M/"$2"M"}')

# Get swap usage
swap_usage=$(free -m | grep Swap | awk '{if ($2 > 0) print $3"M/"$2"M"; else print "None"}')

# Get number of CPUs and load averages
num_cpus=$(nproc 2>/dev/null || grep -c ^processor /proc/cpuinfo 2>/dev/null || echo 1)
load_check=$(uptime | sed -r 's|.*load average: ([\.0-9]+), ([\.0-9]+), ([\.0-9]+)|\1 \2 \3|g')
load_averages=$(echo "$load_check $num_cpus" | awk '{printf "5min: %.0f%% ", $1/$4*100} {printf "10min: %.0f%% ", $2/$4*100} {printf "15min: %.0f%%", $3/$4*100}' ORS=' ')

# Calculate CPU utilization
# Read /proc/stat file (for first datapoint)
read cpu user nice system idle iowait irq softirq steal guest < /proc/stat
# compute active and total utilizations
cpu_active_prev=$((user+system+nice+softirq+steal))
cpu_total_prev=$((user+system+nice+softirq+steal+idle+iowait))
sleep 0.3
# Read /proc/stat file (for second datapoint)
read cpu user nice system idle iowait irq softirq steal guest < /proc/stat
# compute active and total utilizations
cpu_active_cur=$((user+system+nice+softirq+steal))
cpu_total_cur=$((user+system+nice+softirq+steal+idle+iowait))
# compute CPU utilization (%)
cpu_util=$((100*( cpu_active_cur-cpu_active_prev ) / (cpu_total_cur-cpu_total_prev) ))

# Get uptime in human-readable format
if [[ "$(uptime | grep -iq day ; echo $?)" == "0" ]] ; then
    # first logic gate, if the system has been online for at least a day
    if [[ "$(uptime | grep -iq min ; echo $?)" == "0" ]] ; then
        # nested logic gate. If the system has been online for more than a day
        # but less than a day and an hour, the tokens shift and requires alternate parsing
        s_uptime=$(uptime | awk '{print $3 " " $4 " " $5 " Minutes"}')
    else # gate for if the system has been online longer than one day and one hour
        s_uptime=$(uptime | awk '{print $3 " " $4 " " $5 " Hours"}')
    fi
else # logic gate for if the system has been online less than a day but more than an hour
    if [[ "$(uptime | grep -iq min ; echo $?)" == "1" ]] ; then
        s_uptime=$(uptime | awk '{print $3 " Hours  "}')
    else
        s_uptime=$(uptime | awk '{print $3 " Minutes    "}')
    fi
fi

# Get additional information if enabled
if [ "$show_gpu_info" = true ]; then
  get_gpu_info
fi

if [ "$show_container_info" = true ]; then
  get_container_info
fi

if [ "$show_service_status" = true ]; then
  get_service_status
fi

if [ "$show_security_info" = true ]; then
  get_security_info
fi

if [ "$show_smart_status" = true ]; then
  get_smart_status
fi

if [ "$show_top_processes" = true ]; then
  get_top_processes
fi

# Check for fsck message
if [ -x /usr/lib/update-notifier/update-motd-fsck-at-reboot ]; then
    fsck_needed="$(exec /usr/lib/update-notifier/update-motd-fsck-at-reboot)"
fi

# Check if reboot required by updates
reboot_required=""
if [ -f /var/run/reboot-required ]; then
    reboot_required=$(cat /var/run/reboot-required)
fi

# Network display and filtering
declare -a adapters=()
declare -a ips=()
declare -a macs=()
declare -a ifups=()
for device in $(ls /sys/class/net/ 2>/dev/null | grep -v "$filtered_adapters"); do
  adapters+=($device)
  _ip=$(ip -o -f inet addr show $device 2>/dev/null | awk '{print $4}' | cut -d/ -f 1 | head -n 1)
  if valid-ip $_ip; then
    ips+=("$_ip")
    ifups+=("up")
  else
    ips+=("${red}disconnected${dfl}")
    ifups+=("down")
  fi
  if [ -f /sys/class/net/${device}/address ]; then
    macs=()
    macs+=("$(cat /sys/class/net/${device}/address)")
  else
    macs+=("unknown")
  fi
done

# Get public IP address using multiple fallbacks
get_wan_ip() {
  wan_ip="Unavailable"
  
  # Try multiple services with a timeout to avoid hanging
  if command -v curl >/dev/null 2>&1; then
    wan_ip=$(timeout 2 curl -s ifconfig.me 2>/dev/null || \
             timeout 2 curl -s icanhazip.com 2>/dev/null || \
             timeout 2 curl -s ipecho.net/plain 2>/dev/null || \
             timeout 2 curl -s api.ipify.org 2>/dev/null || \
             echo "Unavailable")
  elif command -v wget >/dev/null 2>&1; then
    wan_ip=$(timeout 2 wget -qO- ifconfig.me 2>/dev/null || \
             timeout 2 wget -qO- icanhazip.com 2>/dev/null || \
             timeout 2 wget -qO- ipecho.net/plain 2>/dev/null || \
             timeout 2 wget -qO- api.ipify.org 2>/dev/null || \
             echo "Unavailable")
  elif command -v fetch >/dev/null 2>&1; then
    wan_ip=$(timeout 2 fetch -qo- ifconfig.me 2>/dev/null || \
             timeout 2 fetch -qo- icanhazip.com 2>/dev/null || \
             timeout 2 fetch -qo- ipecho.net/plain 2>/dev/null || \
             timeout 2 fetch -qo- api.ipify.org 2>/dev/null || \
             echo "Unavailable")
  fi
  
  echo "$wan_ip"
}

# Run as a background process to avoid hanging the login
wan_ip=$(get_wan_ip &)

# Disk array setup
declare -a logicals=()
declare -a mounts=()
declare -a usages=()
declare -a freespaces=()
diskinfo=$(/bin/df -h | grep -E "$allowed_disk_prefixes_string" | grep -v -E "$disallowed_disk_prefixes_string")
logicals=($(echo "$diskinfo" | awk '{print $1}'))
mounts=($(echo "$diskinfo" | awk '{print $6}'))
usages=($(echo "$diskinfo" | awk '{print $5}'))
freespaces=($(echo "$diskinfo" | awk '{print $4}'))

# Add color to disk usage if more than 90%
for i in "${!usages[@]}"; do
  usage="${usages[$i]}"
  percentage="${usage%\%}"
  if [[ "$percentage" -gt "90" ]]; then
    usages[$i]="${lrd}${usage}${dfl}"
  elif [[ "$percentage" -gt "75" ]]; then
    usages[$i]="${ong}${usage}${dfl}"
  fi
done

###############################################
# Display the formatted information
###############################################

boxtop
boxline ""
boxline "${bld}${unl}System Information:${dfl}  ${grn}${unl}$location${dfl}"
boxline "	${bld}OS:${dfl} ${ong}${software_version}${dfl} | ${bld}Kernel:${dfl} ${pur}${image_version}${dfl}"
boxline "	${bld}Uptime:${dfl} ${s_uptime}"

# Container information
if [ "$show_container_info" = true ] && [[ "$in_container" = true || "$have_containers" = true ]]; then
  boxline ""
  boxline "${bld}${unl}Container/VM Information:${dfl}"
  if [ "$in_container" = true ]; then
    boxline "	${bld}Running in:${dfl} ${ylw}${container_type}${dfl}"
  fi
  if [ "$have_containers" = true ]; then
    boxline "	${bld}Container Status:${dfl} ${container_stats}"
  fi
fi

# Network information
boxline ""
boxline "${bld}${unl}Network Information:${dfl}"
# Echo out network arrays
for ((i=0; i<"${#adapters[@]}"; i++ )); do
  if [[ $show_disconnected != true ]]; then
    if [[ ${ifups[$i]} == up ]]; then
      boxline "	${adapters[$i]}: ${cyn}${ips[$i]}${dfl} |  ${blu}${macs[$i]}${dfl}"
    fi
  else
    boxline "	${adapters[$i]}: ${cyn}${ips[$i]}${dfl} |  ${blu}${macs[$i]}${dfl}"
  fi
done
boxline "	${bld}WAN IP:${dfl}	${ylw}${wan_ip}${dfl}"

# System status
boxline ""
boxline "${bld}${unl}System Resources:${dfl}"
boxline "	${bld}CPU Load:${dfl} ${load_averages}"
boxline "	${bld}CPU Temp:${dfl} ${lbl}${cputemp}${dfl} | ${bld}Utilization:${dfl} ${lrd}${cpu_util}%${dfl}"

# GPU information if available
if [ "$show_gpu_info" = true ] && [ "$have_gpu" = true ]; then
  boxline "	${bld}GPU:${dfl} ${ylw}${gpu_info}${dfl}"
  if [ "$gpu_temp" != "N/A" ]; then
    boxline "	${bld}GPU Temp:${dfl} ${lbl}${gpu_temp}${dfl} | ${bld}Utilization:${dfl} ${lrd}${gpu_util}%${dfl}"
  fi
fi

# Memory usage
boxline "	${bld}Memory:${dfl} ${mem_usage} | ${bld}Swap:${dfl} ${swap_usage}"

# Storage info
boxline "	${bld}${unl}Disk Info:${dfl}"
boxline "${unl}$(printf '\t|%-4s\t%-4s\t%-4s\t%-4s\n' Usage Free Mount Volumes)${dfl}"
for ((i=0; i<"${#logicals[@]}" ; i++ )); do
  boxline "       $(printf '|%-4s\t%-4s\t%-4s\t%-4s\n' "${usages[$i]}" "${freespaces[$i]}" "${mounts[$i]}" "${logicals[$i]}")"
done

# SMART status if enabled and issues detected
if [ "$show_smart_status" = true ] && [ "$have_smart_issues" = true ]; then
  boxline ""
  boxline "${bld}${unl}Disk Health:${dfl}"
  boxline "	${smart_status}"
fi

# Service status if enabled and issues detected
if [ "$show_service_status" = true ] && [ "$have_service_issues" = true ]; then
  boxline ""
  boxline "${bld}${unl}Service Status:${dfl}"
  boxline "	${service_status}"
fi

# Security information if enabled
if [ "$show_security_info" = true ]; then
  boxline ""
  boxline "${bld}${unl}Security Information:${dfl}"
  boxline "	${bld}Failed logins (24h):${dfl} ${failed_logins}"
  boxline "	${bld}Active SSH sessions:${dfl} ${ssh_sessions}"
  if [ "$last_login" != "N/A" ]; then
    boxline "	${bld}Last login:${dfl} ${last_login}"
  fi
  boxline "	${bld}Firewall:${dfl} ${firewall_status}"
fi

# Top processes if enabled
if [ "$show_top_processes" = true ]; then
  boxline ""
  boxline "${bld}${unl}Top CPU Processes:${dfl}"
  echo "$top_cpu" | while IFS= read -r line; do
    boxline "	$line"
  done
  
  boxline ""
  boxline "${bld}${unl}Top Memory Processes:${dfl}"
  echo "$top_mem" | while IFS= read -r line; do
    boxline "	$line"
  done
fi

# Update information if needed
if [[ "$need_updates" == "true" ]]; then
  boxline ""
  boxline "${bld}${unl}Updates:${dfl}"
  boxline "	${packages}"
  if [ ! -z "$supdates" ]; then
    boxline "	${supdates}"
  fi
  if [ ! -z "$release_upgrade" ]; then
    boxline "	${release_upgrade}"
  fi
fi

# System maintenance notifications
if [ ! -z "${fsck_needed}" ] || [ ! -z "${reboot_required}" ]; then
  boxline ""
  boxline "${bld}${unl}System Maintenance:${dfl}"
  boxline "	${fsck_needed} ${reboot_required}"
fi

boxline ""
boxbottom