#!/bin/bash

# =============================================================================
# 脚本名称: linux_toolbox.sh
# 功能描述: Linux 多功能检测工具箱 - 适用于各种 Linux 发行版
# 适用系统: CentOS/RHEL/AlmaLinux/Rocky/Ubuntu/Debian/openSUSE/Arch 等
# 使用方法: chmod +x linux_toolbox.sh && ./linux_toolbox.sh
# 扩展说明: 新增功能只需三步：
#           1. 编写 func_xxx() 函数
#           2. 在 show_menu() 中添加菜单选项
#           3. 在 main() 的 case 语句中添加对应分支
# =============================================================================

# =============================================================================
# 第一部分：颜色定义与辅助输出函数
# 说明：使用 ANSI 转义码实现彩色输出，让新手用户更容易区分信息类型
# =============================================================================

# 定义颜色变量
RED='\033[0;31m'      # 红色 - 用于错误提示
GREEN='\033[0;32m'    # 绿色 - 用于成功提示
YELLOW='\033[1;33m'   # 黄色 - 用于警告提示
BLUE='\033[0;34m'     # 蓝色 - 用于普通信息
CYAN='\033[0;36m'     # 青色 - 用于标题
PURPLE='\033[0;35m'   # 紫色 - 用于强调
NC='\033[0m'          # 无颜色 - 重置颜色

# 辅助输出函数：打印成功信息（绿色）
print_success() {
    echo -e "${GREEN}[成功] $1${NC}"
}

# 辅助输出函数：打印错误信息（红色）
print_error() {
    echo -e "${RED}[错误] $1${NC}"
}

# 辅助输出函数：打印警告信息（黄色）
print_warning() {
    echo -e "${YELLOW}[警告] $1${NC}"
}

# 辅助输出函数：打印普通信息（蓝色）
print_info() {
    echo -e "${BLUE}[信息] $1${NC}"
}

# 辅助输出函数：打印标题（青色）
print_title() {
    echo -e "${CYAN}$1${NC}"
}

# 辅助输出函数：打印强调信息（紫色）
print_highlight() {
    echo -e "${PURPLE}$1${NC}"
}

# 分隔线函数：打印视觉分隔线
print_line() {
    echo "------------------------------------------------"
}

# =============================================================================
# 第二部分：全局信息检测模块
# 说明：脚本启动时自动执行，检测系统版本、IP地址、DNS地址
# =============================================================================

# 函数：检测操作系统版本及硬件信息
# 原理：读取系统标识文件获取发行版信息，读取 /proc/cpuinfo 获取 CPU 信息，
#       读取 /proc/meminfo 或 free 获取内存信息，读取 /sys/block 获取硬盘信息
detect_os() {
    # 系统类型
    echo "系统类型：$(uname -o)"

    # 发行版信息
    local distro=""
    if [[ -f /etc/os-release ]]; then
        source /etc/os-release
        distro="$NAME $VERSION_ID $(uname -m)"
    elif [[ -f /etc/redhat-release ]]; then
        distro="$(cat /etc/redhat-release) $(uname -m)"
    elif [[ -f /etc/centos-release ]]; then
        distro="$(cat /etc/centos-release) $(uname -m)"
    elif [[ -f /etc/debian_version ]]; then
        distro="Debian $(cat /etc/debian_version) $(uname -m)"
    else
        distro="未知发行版 $(uname -m)"
    fi
    echo "发行版：$distro"

    # CPU 型号
    local cpu_model=$(grep -m1 'model name' /proc/cpuinfo 2>/dev/null | cut -d: -f2 | sed 's/^ *//')
    if [[ -n "$cpu_model" ]]; then
        echo "CPU型号：$cpu_model"
    else
        echo "CPU型号：$(uname -p)"
    fi

    # CPU 核心数
    local cpu_cores=$(nproc 2>/dev/null || grep -c ^processor /proc/cpuinfo 2>/dev/null || echo "未知")
    echo "CPU核心数：$cpu_cores"

    # 内存条数
    local mem_slots="未知"
    if command -v dmidecode &>/dev/null && [[ $EUID -eq 0 ]]; then
        mem_slots=$(dmidecode -t memory 2>/dev/null | grep -c "Memory Device" || echo "未知")
    elif [[ -d /sys/devices/system/memory ]]; then
        local mem_dirs=$(ls -d /sys/devices/system/memory/memory* 2>/dev/null | wc -l)
        if [[ "$mem_dirs" -gt 0 ]]; then
            mem_slots="$mem_dirs"
        fi
    fi
    echo "内存条数：$mem_slots"

    # 内存总数
    local mem_total="未知"
    if command -v free &>/dev/null; then
        mem_total=$(free -h | awk '/^Mem:/ {print $2}')
    elif [[ -f /proc/meminfo ]]; then
        local mem_kb=$(grep '^MemTotal:' /proc/meminfo | awk '{print $2}')
        if [[ -n "$mem_kb" ]]; then
            mem_total="${mem_kb}kB"
        fi
    fi
    echo "内存总数：$mem_total"

    # 硬盘数量和型号容量
    local disk_count=$(ls -1 /sys/block 2>/dev/null | grep -cE '^sd|^nvme|^hd|^vd' || echo "0")
    echo "硬盘数量：$disk_count"
    echo "硬盘型号和容量："
    if [[ "$disk_count" -gt 0 ]]; then
        if command -v lsblk &>/dev/null; then
            lsblk -dn -o NAME,SIZE,MODEL 2>/dev/null | while read -r name size model; do
                if [[ -n "$name" && "$name" != "NAME" && -n "$size" ]]; then
                    echo "$name ${model:-未知型号} $size"
                fi
            done
        else
            ls -1 /sys/block 2>/dev/null | grep -E '^sd|^nvme|^hd|^vd' | while read -r dev; do
                local model=$(cat /sys/block/$dev/device/model 2>/dev/null | sed 's/ *$//' | tr -s ' ')
                local size_sectors=$(cat /sys/block/$dev/size 2>/dev/null)
                if [[ -n "$size_sectors" ]]; then
                    local size_human=$(awk "BEGIN {printf \"%.1fG\", $size_sectors * 512 / 1024 / 1024 / 1024}")
                    echo "$dev ${model:-未知型号} $size_human"
                fi
            done
        fi
    else
        echo "未检测到硬盘"
    fi
    echo ""
}

# 函数：检测网络 IP 地址
# 原理：优先使用 ip 命令（现代标准），回退到 ifconfig
detect_ips() {
    local ipv4_addr=""
    local ipv6_addr=""

    if command -v ip &>/dev/null; then
        ipv4_addr=$(ip -4 addr show | grep -oE 'inet [0-9]+\.[0-9]+\.[0-9]+\.[0-9]+' | awk '{print $2}' | grep -v '^127\.' | paste -sd ',' -)
        ipv6_addr=$(ip -6 addr show | grep -oE 'inet6 [0-9a-fA-F:]+' | awk '{print $2}' | grep -v '^::1$' | grep -v '^fe80' | paste -sd ',' -)
    elif command -v ifconfig &>/dev/null; then
        ipv4_addr=$(ifconfig | grep -oE 'inet [0-9]+\.[0-9]+\.[0-9]+\.[0-9]+' | awk '{print $2}' | grep -v '^127\.' | paste -sd ',' -)
        ipv6_addr=$(ifconfig | grep -oE 'inet6 [0-9a-fA-F:]+' | awk '{print $2}' | grep -v '^::1$' | grep -v '^fe80' | paste -sd ',' -)
    fi

    echo "IPV4地址：${ipv4_addr:-未找到}"
    echo "IPV6地址：${ipv6_addr:-未找到全局 IPv6 地址}"
    echo ""
}

# 函数：检测 DNS 服务器地址
# 原理：
#   全局信息展示时只显示当前生效的 DNS（/etc/resolv.conf），简洁格式
#   详细的多源 DNS 检测逻辑保留在此，供后续扩展功能时使用
detect_dns() {
    local dns_addr=""

    # 从 /etc/resolv.conf 读取当前生效的 DNS
    if [[ -f /etc/resolv.conf ]]; then
        dns_addr=$(grep '^nameserver' /etc/resolv.conf 2>/dev/null | awk '{print $2}' | paste -sd ',' -)
    fi

    # 如果 resolv.conf 中没有 DNS，尝试从网卡配置文件中查找
    if [[ -z "$dns_addr" ]]; then
        # NetworkManager 连接配置
        local nm_conn_dir="/etc/NetworkManager/system-connections"
        if [[ -d "$nm_conn_dir" ]]; then
            for nm_file in $(find "$nm_conn_dir" -maxdepth 1 -type f 2>/dev/null); do
                local nm_dns=$(grep -i '^dns=' "$nm_file" 2>/dev/null | head -1 | cut -d= -f2)
                if [[ -n "$nm_dns" ]]; then
                    if [[ -n "$dns_addr" ]]; then
                        dns_addr="$dns_addr,$nm_dns"
                    else
                        dns_addr="$nm_dns"
                    fi
                fi
            done
        fi

        # RHEL/CentOS 传统网卡配置文件
        local ifcfg_dir="/etc/sysconfig/network-scripts"
        if [[ -d "$ifcfg_dir" ]]; then
            for ifcfg_file in $(find "$ifcfg_dir" -maxdepth 1 -name 'ifcfg-*' -type f 2>/dev/null); do
                local ifcfg_dns=$(grep -iE '^DNS1=' "$ifcfg_file" 2>/dev/null | cut -d= -f2)
                if [[ -n "$ifcfg_dns" ]]; then
                    if [[ -n "$dns_addr" ]]; then
                        dns_addr="$dns_addr,$ifcfg_dns"
                    else
                        dns_addr="$ifcfg_dns"
                    fi
                fi
            done
        fi

        # netplan 配置
        local netplan_dir="/etc/netplan"
        if [[ -d "$netplan_dir" ]]; then
            for netplan_file in $(find "$netplan_dir" -maxdepth 1 -name '*.yaml' -type f 2>/dev/null); do
                local netplan_dns=$(grep -iE 'addresses:' "$netplan_file" 2>/dev/null | head -1 | grep -oE '\[.*\]' | tr -d '[]' | tr ',' ',')
                if [[ -n "$netplan_dns" ]]; then
                    if [[ -n "$dns_addr" ]]; then
                        dns_addr="$dns_addr,$netplan_dns"
                    else
                        dns_addr="$netplan_dns"
                    fi
                fi
            done
        fi
    fi

    echo "DNS地址：${dns_addr:-未配置}"
    echo ""
}

# 函数：显示全局信息（系统版本 + IP + DNS）
# 说明：脚本启动时自动调用此函数，以简洁的 "标签：值" 格式输出系统概览
show_global_info() {
    echo ""
    print_title "================================================"
    print_title "        欢迎使用 Linux 多功能检测工具箱"
    print_title "================================================"
    echo ""

    detect_os
    detect_ips
    detect_dns

    echo ""
}

# =============================================================================
# 第三部分：功能模块 - 菜单选项对应的具体功能
# =============================================================================

# ---------------------------------------------------------------------------
# 功能1: 检测系统内存、磁盘及分区信息
# 对应菜单选项: 1
# ---------------------------------------------------------------------------

# 子函数：检测内存条物理信息
# 原理：使用 dmidecode -t memory 获取每条内存的制造商、型号、容量、频率等
#       需要 root 权限，否则回退到基本信息
check_memory() {
    print_title "========== 内存条物理信息 =========="

    if command -v dmidecode &>/dev/null && [[ $EUID -eq 0 ]]; then
        echo "  正在通过 dmidecode 读取内存条物理信息..."
        echo ""

        local mem_info=$(dmidecode -t memory 2>/dev/null)
        local installed_count=$(echo "$mem_info" | grep -c "Size: [0-9]" 2>/dev/null)
        local total_slots=$(echo "$mem_info" | grep -c "Memory Device" 2>/dev/null)

        echo "  内存插槽总数: $total_slots"
        echo "  已安装内存条: $installed_count"
        echo ""

        # 逐条解析内存信息
        local idx=0
        local in_device=false
        local size="" type="" speed="" manufacturer="" part_num="" serial="" locator=""

        echo "$mem_info" | while IFS= read -r line; do
            if [[ "$line" =~ ^[[:space:]]*Memory[[:space:]]+Device ]]; then
                # 输出上一条内存的信息
                if [[ -n "$size" && "$size" != "No"* ]]; then
                    echo "  插槽: ${locator:-未知}"
                    echo "    容量:    $size"
                    [[ -n "$type" && "$type" != "Unknown" ]] && echo "    类型:    $type"
                    [[ -n "$speed" && "$speed" != "Unknown" ]] && echo "    频率:    $speed"
                    [[ -n "$manufacturer" && "$manufacturer" != "Not"* ]] && echo "    制造商:  $manufacturer"
                    [[ -n "$part_num" && "$part_num" != "Not"* ]] && echo "    型号:    $part_num"
                    [[ -n "$serial" && "$serial" != "Not"* ]] && echo "    序列号:  $serial"
                    echo ""
                fi
                in_device=true
                size=""; type=""; speed=""; manufacturer=""; part_num=""; serial=""; locator=""
            elif [[ "$in_device" == true ]]; then
                if [[ "$line" =~ ^[[:space:]]*Size:[[:space:]]*(.+)$ ]]; then
                    size="${BASH_REMATCH[1]}"
                elif [[ "$line" =~ ^[[:space:]]*Type:[[:space:]]*(.+)$ ]]; then
                    type="${BASH_REMATCH[1]}"
                elif [[ "$line" =~ ^[[:space:]]*Speed:[[:space:]]*(.+)$ ]]; then
                    speed="${BASH_REMATCH[1]}"
                elif [[ "$line" =~ ^[[:space:]]*Manufacturer:[[:space:]]*(.+)$ ]]; then
                    manufacturer="${BASH_REMATCH[1]}"
                elif [[ "$line" =~ ^[[:space:]]*Part[[:space:]]Number:[[:space:]]*(.+)$ ]]; then
                    part_num="${BASH_REMATCH[1]}"
                elif [[ "$line" =~ ^[[:space:]]*Serial[[:space:]]Number:[[:space:]]*(.+)$ ]]; then
                    serial="${BASH_REMATCH[1]}"
                elif [[ "$line" =~ ^[[:space:]]*Locator:[[:space:]]*(.+)$ ]]; then
                    locator="${BASH_REMATCH[1]}"
                fi
            fi
        done

        # 输出最后一条
        if [[ -n "$size" && "$size" != "No"* ]]; then
            echo "  插槽: ${locator:-未知}"
            echo "    容量:    $size"
            [[ -n "$type" && "$type" != "Unknown" ]] && echo "    类型:    $type"
            [[ -n "$speed" && "$speed" != "Unknown" ]] && echo "    频率:    $speed"
            [[ -n "$manufacturer" && "$manufacturer" != "Not"* ]] && echo "    制造商:  $manufacturer"
            [[ -n "$part_num" && "$part_num" != "Not"* ]] && echo "    型号:    $part_num"
            [[ -n "$serial" && "$serial" != "Not"* ]] && echo "    序列号:  $serial"
            echo ""
        fi

    else
        print_warning "检测内存条物理信息需要 root 权限和 dmidecode 工具"
        echo "  提示: 使用 sudo 安装 dmidecode 后运行脚本可获取详细信息"
        echo "        sudo apt install dmidecode    # Debian/Ubuntu"
        echo "        sudo yum install dmidecode    # CentOS/RHEL"
        echo ""

        print_info "当前可用内存信息:"
        if command -v free &>/dev/null; then
            free -h | awk '/^Mem:/ {print "  总内存: " $2}'
        elif [[ -f /proc/meminfo ]]; then
            grep '^MemTotal:' /proc/meminfo | awk '{print "  总内存: " $2 " " $3}'
        fi
    fi

    echo ""
}

# 子函数：检测硬盘物理信息
# 原理：使用 lsblk 获取硬盘列表，结合 /sys 文件系统和 smartctl 获取详细信息
check_disk() {
    print_title "========== 硬盘物理信息 =========="

    local disk_count=$(ls -1 /sys/block 2>/dev/null | grep -cE '^sd|^nvme|^hd|^vd' || echo "0")
    echo "  硬盘数量: $disk_count"
    echo ""

    if [[ "$disk_count" -eq 0 ]]; then
        print_warning "未检测到硬盘"
        echo ""
        return
    fi

    # 优先使用 lsblk 获取硬盘列表
    if command -v lsblk &>/dev/null; then
        lsblk -dn -o NAME,SIZE,MODEL,TYPE,TRAN,ROTA 2>/dev/null | while read -r name size model type tran rota; do
            if [[ "$type" == "disk" || "$type" == "raid" ]]; then
                echo "  设备: /dev/$name"
                echo "    容量:   $size"
                echo "    型号:   ${model:-未知}"

                # 判断 HDD/SSD
                if [[ "$rota" == "0" ]]; then
                    echo "    类型:   SSD（固态硬盘）"
                elif [[ "$rota" == "1" ]]; then
                    echo "    类型:   HDD（机械硬盘）"
                else
                    echo "    类型:   未知"
                fi

                # 接口类型
                if [[ -n "$tran" ]]; then
                    echo "    接口:   $tran"
                fi

                # 尝试获取 SMART 信息
                if command -v smartctl &>/dev/null; then
                    local smart_info=$(smartctl -i /dev/$name 2>/dev/null)
                    if [[ -n "$smart_info" ]]; then
                        local serial=$(echo "$smart_info" | grep -i "Serial Number:" | cut -d: -f2 | sed 's/^ *//')
                        local fw=$(echo "$smart_info" | grep -i "Firmware Version:" | cut -d: -f2 | sed 's/^ *//')
                        local sector_size=$(echo "$smart_info" | grep -i "Sector Size:" | cut -d: -f2 | sed 's/^ *//')
                        local form_factor=$(echo "$smart_info" | grep -i "Form Factor:" | cut -d: -f2 | sed 's/^ *//')
                        local sata_ver=$(echo "$smart_info" | grep -i "SATA Version is:" | cut -d: -f2 | sed 's/^ *//')

                        [[ -n "$serial" ]] && echo "    序列号: $serial"
                        [[ -n "$fw" ]] && echo "    固件:   $fw"
                        [[ -n "$sector_size" ]] && echo "    扇区:   $sector_size"
                        [[ -n "$form_factor" ]] && echo "    规格:   $form_factor"
                        [[ -n "$sata_ver" ]] && echo "    SATA:   $sata_ver"
                    fi
                fi

                echo ""
            fi
        done
    else
        # 无 lsblk 时的回退
        ls -1 /sys/block 2>/dev/null | grep -E '^sd|^nvme|^hd|^vd' | while read -r dev; do
            local model=$(cat /sys/block/$dev/device/model 2>/dev/null | sed 's/ *$//' | tr -s ' ')
            local size_sectors=$(cat /sys/block/$dev/size 2>/dev/null)
            local size_human=$(awk "BEGIN {printf \"%.1fG\", $size_sectors * 512 / 1024 / 1024 / 1024}")
            local rotational=$(cat /sys/block/$dev/queue/rotational 2>/dev/null)
            local tran=""

            # 尝试获取接口类型
            if [[ -L /sys/block/$dev/device ]]; then
                tran=$(readlink -f /sys/block/$dev/device 2>/dev/null | grep -oE 'usb|sata|nvme|scsi|virtio' | head -1)
            fi

            echo "  设备: /dev/$dev"
            echo "    容量: $size_human"
            echo "    型号: ${model:-未知}"

            if [[ "$rotational" == "0" ]]; then
                echo "    类型: SSD（固态硬盘）"
            elif [[ "$rotational" == "1" ]]; then
                echo "    类型: HDD（机械硬盘）"
            fi

            [[ -n "$tran" ]] && echo "    接口: $tran"
            echo ""
        done
    fi

    echo ""
}

# 子函数：检测硬盘分区信息
# 保留此功能，展示各硬盘的分区布局
check_partition() {
    print_title "========== 硬盘分区信息 =========="

    if command -v lsblk &>/dev/null; then
        echo "  磁盘及分区结构:"
        echo ""
        lsblk -o NAME,SIZE,TYPE,MOUNTPOINT,FSTYPE,MODEL 2>/dev/null || lsblk
    elif command -v fdisk &>/dev/null; then
        if [[ $EUID -eq 0 ]]; then
            fdisk -l 2>/dev/null | grep -E '^/dev/' | awk '{print "  "$0}'
        else
            print_warning "fdisk 需要 root 权限才能查看分区信息"
            fdisk -l 2>/dev/null | head -20 | awk '{print "  "$0}'
        fi
    else
        print_warning "未找到 lsblk 或 fdisk 命令"
    fi

    echo ""
}

# 功能1 主函数：检测内存条及硬盘物理信息
func_memory_disk() {
    echo ""
    print_highlight ">>> 正在检测内存条及硬盘物理信息..."
    echo ""

    check_memory
    check_disk
    check_partition

    print_line
    echo ""
    read -p "按 Enter 键返回主菜单..."
}

# ---------------------------------------------------------------------------
# 功能2: 检测系统桌面环境
# 对应菜单选项: 2
# ---------------------------------------------------------------------------

func_desktop_env() {
    echo ""
    print_highlight ">>> 正在检测系统桌面环境..."
    echo ""

    local desktop_found=false
    local desktop_name=""
    local desktop_version=""

    # 步骤1: 检查桌面环境相关的环境变量
    print_title "========== 环境变量检测 =========="
    if [[ -n "$XDG_CURRENT_DESKTOP" ]]; then
        echo "  XDG_CURRENT_DESKTOP: $XDG_CURRENT_DESKTOP"
        desktop_found=true
        desktop_name="$XDG_CURRENT_DESKTOP"
    fi

    if [[ -n "$DESKTOP_SESSION" ]]; then
        echo "  DESKTOP_SESSION: $DESKTOP_SESSION"
        desktop_found=true
        desktop_name="$DESKTOP_SESSION"
    fi

    if [[ -n "$GNOME_DESKTOP_SESSION_ID" ]]; then
        echo "  GNOME_DESKTOP_SESSION_ID: $GNOME_DESKTOP_SESSION_ID"
        desktop_found=true
        desktop_name="GNOME"
    fi

    if [[ -n "$KDE_FULL_SESSION" ]]; then
        echo "  KDE_FULL_SESSION: $KDE_FULL_SESSION"
        desktop_found=true
        desktop_name="KDE"
    fi

    if [[ -n "$DISPLAY" ]]; then
        echo "  DISPLAY: $DISPLAY"
    fi

    if [[ -n "$WAYLAND_DISPLAY" ]]; then
        echo "  WAYLAND_DISPLAY: $WAYLAND_DISPLAY"
    fi

    if [[ "$desktop_found" == false ]]; then
        echo "  未检测到桌面环境相关环境变量"
    fi
    echo ""

    # 步骤2: 检查桌面环境进程
    print_title "========== 桌面环境进程检测 =========="

    # 检测 GNOME
    if pgrep -x gnome-shell &>/dev/null || pgrep -x gnome-session &>/dev/null; then
        desktop_found=true
        desktop_name="GNOME"
        desktop_version=$(gnome-shell --version 2>/dev/null || echo "未知版本")
        print_success "检测到 GNOME 桌面环境"
        echo "  版本: $desktop_version"
    fi

    # 检测 KDE Plasma
    if pgrep -x plasmashell &>/dev/null || pgrep -x plasma-desktop &>/dev/null; then
        desktop_found=true
        desktop_name="KDE Plasma"
        desktop_version=$(plasmashell --version 2>/dev/null || echo "未知版本")
        print_success "检测到 KDE Plasma 桌面环境"
        echo "  版本: $desktop_version"
    fi

    # 检测 XFCE
    if pgrep -x xfce4-session &>/dev/null || pgrep -x xfce4-panel &>/dev/null; then
        desktop_found=true
        desktop_name="XFCE"
        desktop_version=$(xfce4-session --version 2>/dev/null | head -1 || echo "未知版本")
        print_success "检测到 XFCE 桌面环境"
        echo "  版本: $desktop_version"
    fi

    # 检测 MATE
    if pgrep -x mate-session &>/dev/null || pgrep -x mate-panel &>/dev/null; then
        desktop_found=true
        desktop_name="MATE"
        desktop_version=$(mate-session --version 2>/dev/null || echo "未知版本")
        print_success "检测到 MATE 桌面环境"
        echo "  版本: $desktop_version"
    fi

    # 检测 Cinnamon
    if pgrep -x cinnamon-session &>/dev/null || pgrep -x cinnamon &>/dev/null; then
        desktop_found=true
        desktop_name="Cinnamon"
        desktop_version=$(cinnamon --version 2>/dev/null || echo "未知版本")
        print_success "检测到 Cinnamon 桌面环境"
        echo "  版本: $desktop_version"
    fi

    # 检测 LXDE
    if pgrep -x lxsession &>/dev/null || pgrep -x lxpanel &>/dev/null; then
        desktop_found=true
        desktop_name="LXDE"
        print_success "检测到 LXDE 桌面环境"
    fi

    # 检测 LXQt
    if pgrep -x lxqt-session &>/dev/null || pgrep -x lxqt-panel &>/dev/null; then
        desktop_found=true
        desktop_name="LXQt"
        desktop_version=$(lxqt-session --version 2>/dev/null || echo "未知版本")
        print_success "检测到 LXQt 桌面环境"
        echo "  版本: $desktop_version"
    fi

    # 检测 Deepin DDE
    if pgrep -x dde-session &>/dev/null || pgrep -x dde-desktop &>/dev/null; then
        desktop_found=true
        desktop_name="Deepin DDE"
        print_success "检测到 Deepin DDE 桌面环境"
    fi

    # 检测 UKUI (麒麟桌面)
    if pgrep -x ukui-session &>/dev/null; then
        desktop_found=true
        desktop_name="UKUI"
        print_success "检测到 UKUI 桌面环境"
    fi

    # 检测 Budgie
    if pgrep -x budgie-panel &>/dev/null || pgrep -x budgie-wm &>/dev/null; then
        desktop_found=true
        desktop_name="Budgie"
        print_success "检测到 Budgie 桌面环境"
    fi

    # 检测显示服务器
    echo ""
    print_title "========== 显示服务器检测 =========="
    if pgrep -x Xorg &>/dev/null; then
        print_success "检测到 Xorg 显示服务器"
    elif pgrep -x X &>/dev/null; then
        print_success "检测到 X 显示服务器"
    elif pgrep -x wayland &>/dev/null || [[ -n "$WAYLAND_DISPLAY" ]]; then
        print_success "检测到 Wayland 显示服务器"
    else
        echo "  未检测到 Xorg 或 Wayland 显示服务器"
    fi
    echo ""

    # 步骤3: 检测结果汇总
    print_title "========== 检测结果汇总 =========="
    if [[ "$desktop_found" == true ]]; then
        print_success "已检测到桌面环境: $desktop_name"
        if [[ -n "$desktop_version" && "$desktop_version" != "未知版本" ]]; then
            echo "  版本: $desktop_version"
        fi
    else
        print_warning "当前系统为最小化安装，未检测到桌面环境"
        echo ""
        print_info "说明:"
        echo "  最小化安装的系统只包含命令行界面，"
        echo "  没有安装图形化桌面环境。"
        echo ""
        print_info "如需安装桌面环境，请使用系统对应的包管理器进行安装。"
    fi

    echo ""

    # 步骤4: 检测系统默认启动模式
    print_title "========== 系统启动模式 =========="
    if command -v systemctl &>/dev/null; then
        local runlevel=$(systemctl get-default 2>/dev/null)
        echo "  当前默认目标: $runlevel"
        if [[ "$runlevel" == *"graphical"* ]]; then
            print_success "系统默认以图形模式启动"
        elif [[ "$runlevel" == *"multi-user"* ]]; then
            print_info "系统默认以命令行模式（多用户模式）启动"
        else
            echo "  系统默认运行目标: $runlevel"
        fi
    elif [[ -f /etc/inittab ]]; then
        # 旧版 SysVinit 系统
        local runlevel=$(grep '^id:' /etc/inittab 2>/dev/null | cut -d: -f2)
        echo "  当前运行级别: $runlevel"
        if [[ "$runlevel" == "5" ]]; then
            print_success "系统以图形模式启动（运行级别5）"
        else
            print_info "系统以命令行模式启动（运行级别$runlevel）"
        fi
    else
        echo "  无法确定系统默认启动模式"
    fi

    echo ""
    print_line
    echo ""
    read -p "按 Enter 键返回主菜单..."
}

# ---------------------------------------------------------------------------
# 功能3: 检测/配置 root 用户远程密码登录
# 对应菜单选项: 3
# 警告: 此功能会修改系统 SSH 配置，操作前会自动备份
# ---------------------------------------------------------------------------

func_root_ssh() {
    echo ""
    print_highlight ">>> 正在检测 root 用户远程密码登录配置..."
    echo ""

    local ssh_config="/etc/ssh/sshd_config"
    local config_d_dir="/etc/ssh/sshd_config.d"

    # 检查 SSH 配置文件是否存在
    if [[ ! -f "$ssh_config" ]]; then
        print_error "未找到 SSH 配置文件: $ssh_config"
        echo ""
        print_info "请确认系统已安装 OpenSSH 服务器:"
        echo "  CentOS/RHEL:  sudo yum install openssh-server"
        echo "  Ubuntu/Debian: sudo apt install openssh-server"
        echo "  openSUSE:     sudo zypper install openssh"
        echo "  Arch Linux:   sudo pacman -S openssh"
        echo ""
        read -p "按 Enter 键返回主菜单..."
        return
    fi

    print_info "SSH 配置文件位置: $ssh_config"
    echo ""

    # 检测 PermitRootLogin 配置
    print_title "========== 当前 SSH 配置 =========="

    # 从主配置文件读取 - 先查找生效的（未注释的）配置
    local permit_root=$(grep -iE '^\s*PermitRootLogin\s' "$ssh_config" | tail -1 | awk '{print $NF}')
    local pass_auth=$(grep -iE '^\s*PasswordAuthentication\s' "$ssh_config" | tail -1 | awk '{print $NF}')

    # 标记配置是否来自注释行
    local permit_root_commented=false
    local pass_auth_commented=false

    # 如果未找到生效配置，检查是否有被注释掉的配置（用于提示用户）
    if [[ -z "$permit_root" ]]; then
        local permit_root_comment=$(grep -iE '^\s*#\s*PermitRootLogin\s' "$ssh_config" | tail -1 | awk '{print $NF}')
        if [[ -n "$permit_root_comment" ]]; then
            permit_root="$permit_root_comment"
            permit_root_commented=true
        fi
    fi

    if [[ -z "$pass_auth" ]]; then
        local pass_auth_comment=$(grep -iE '^\s*#\s*PasswordAuthentication\s' "$ssh_config" | tail -1 | awk '{print $NF}')
        if [[ -n "$pass_auth_comment" ]]; then
            pass_auth="$pass_auth_comment"
            pass_auth_commented=true
        fi
    fi

    # 同时检查 sshd_config.d/ 目录下的配置（新版 OpenSSH 特性）
    # 这些文件中的配置通常是生效的（不会注释），直接查找未注释的即可
    if [[ -d "$config_d_dir" ]]; then
        local permit_root_d=$(grep -riE '^\s*PermitRootLogin\s' "$config_d_dir" 2>/dev/null | tail -1 | awk '{print $NF}')
        local pass_auth_d=$(grep -riE '^\s*PasswordAuthentication\s' "$config_d_dir" 2>/dev/null | tail -1 | awk '{print $NF}')

        if [[ -n "$permit_root_d" ]]; then
            permit_root="$permit_root_d"
            permit_root_commented=false
            echo "  (注意: 在 $config_d_dir 目录下发现了覆盖配置)"
        fi
        if [[ -n "$pass_auth_d" ]]; then
            pass_auth="$pass_auth_d"
            pass_auth_commented=false
        fi
    fi

    # 显示配置值，如果被注释则额外提示
    if [[ "$permit_root_commented" == true ]]; then
        echo "  PermitRootLogin:        ${permit_root}（该配置被 # 注释，未生效）"
    else
        echo "  PermitRootLogin:        ${permit_root:-未配置（默认可能为 prohibit-password）}"
    fi

    if [[ "$pass_auth_commented" == true ]]; then
        echo "  PasswordAuthentication: ${pass_auth}（该配置被 # 注释，未生效）"
    else
        echo "  PasswordAuthentication: ${pass_auth:-未配置（默认通常为 yes）}"
    fi
    echo ""

    # 判断 root 密码登录是否已开启
    # 只有当 PermitRootLogin 是生效的 yes 且 PasswordAuthentication 不是 no 时才算开启
    local is_enabled=false
    if [[ "$permit_root_commented" == false && "$permit_root" == "yes" && "$pass_auth" != "no" ]]; then
        is_enabled=true
    fi

    print_title "========== 检测结果 =========="
    if [[ "$is_enabled" == true ]]; then
        print_success "root 用户远程密码登录已开启"
        echo ""
        print_warning "安全提示:"
        echo "  root 密码登录虽然方便，但存在被暴力破解的风险。"
        echo "  生产环境中建议使用以下更安全的方案:"
        echo "    1. 使用普通用户登录，需要 root 权限时执行 sudo 或 su"
        echo "    2. 使用 SSH 密钥登录代替密码登录"
        echo "    3. 修改 SSH 默认端口（22）"
        echo "    4. 启用 fail2ban 等防暴力破解工具"
    else
        print_warning "root 用户远程密码登录未开启"
        echo ""

        if [[ "$permit_root" == "no" ]]; then
            echo "原因: 配置文件中明确设置了 PermitRootLogin no"
        elif [[ "$permit_root" == "prohibit-password" ]] || [[ -z "$permit_root" ]]; then
            echo "原因: 当前配置仅允许 root 使用密钥登录，禁止密码登录"
            echo "      或配置文件未设置（OpenSSH 默认行为）"
        elif [[ "$pass_auth" == "no" ]]; then
            echo "原因: 密码认证被禁用（PasswordAuthentication no）"
        fi

        echo ""
        print_info "当前配置的安全性较好，但如果您确实需要开启 root 密码登录，"
        print_info "本脚本可以帮您一键配置。"
        echo ""

        # 询问用户是否开启
        read -p "是否开启 root 用户远程密码登录？(y/n): " choice
        echo ""

        if [[ "$choice" == "y" || "$choice" == "Y" ]]; then
            # 安全警告和二次确认
            print_warning "========================================"
            print_warning "          安全风险提示"
            print_warning "========================================"
            echo ""
            echo "开启 root 密码登录会降低系统安全性:"
            echo "  - root 是系统的最高权限用户"
            echo "  - 攻击者可能通过暴力破解获取 root 密码"
            echo "  - 一旦 root 密码泄露，系统将完全失控"
            echo ""
            echo "建议的安全替代方案:"
            echo "  1. 创建普通用户，授予 sudo 权限"
            echo "  2. 使用 SSH 密钥认证登录"
            echo "  3. 禁用 root 登录，普通用户登录后执行 su - 切换"
            echo ""

            read -p "您确定要开启 root 密码登录吗？(y/n): " confirm
            echo ""

            if [[ "$confirm" == "y" || "$confirm" == "Y" ]]; then
                # 检查是否有 root 权限（修改 /etc/ssh/sshd_config 需要）
                if [[ $EUID -ne 0 ]]; then
                    print_error "修改 SSH 配置需要 root 权限，请使用 sudo 运行脚本"
                    echo "  命令: sudo $0"
                    echo ""
                    read -p "按 Enter 键返回主菜单..."
                    return
                fi

                # 备份原配置文件
                local backup_file="${ssh_config}.bak.$(date +%Y%m%d_%H%M%S)"
                cp "$ssh_config" "$backup_file"
                print_success "已备份原配置文件到: $backup_file"
                echo ""

                # 修改 PermitRootLogin 配置
                if grep -qE '^\s*#?\s*PermitRootLogin' "$ssh_config"; then
                    # 如果配置已存在，替换它
                    sed -i 's/^\s*#\?\s*PermitRootLogin.*/PermitRootLogin yes/' "$ssh_config"
                    print_info "已修改 PermitRootLogin 为 yes"
                else
                    # 如果不存在，追加到文件末尾
                    echo "PermitRootLogin yes" >> "$ssh_config"
                    print_info "已添加 PermitRootLogin yes 配置"
                fi

                # 修改 PasswordAuthentication 配置
                if grep -qE '^\s*#?\s*PasswordAuthentication' "$ssh_config"; then
                    sed -i 's/^\s*#\?\s*PasswordAuthentication.*/PasswordAuthentication yes/' "$ssh_config"
                    print_info "已修改 PasswordAuthentication 为 yes"
                else
                    echo "PasswordAuthentication yes" >> "$ssh_config"
                    print_info "已添加 PasswordAuthentication yes 配置"
                fi

                echo ""
                print_success "SSH 配置已修改完成"
                print_info "备份文件: $backup_file"
                echo ""

                # 询问是否重启 SSH 服务
                read -p "是否立即重启 SSH 服务使配置生效？(y/n): " restart_choice
                echo ""

                if [[ "$restart_choice" == "y" || "$restart_choice" == "Y" ]]; then
                    # 自动检测系统的服务管理方式并重启 SSH
                    if command -v systemctl &>/dev/null; then
                        # systemd 系统（大多数现代 Linux）
                        systemctl restart sshd 2>/dev/null || systemctl restart ssh 2>/dev/null
                        if [[ $? -eq 0 ]]; then
                            print_success "SSH 服务已重启，配置已生效"
                        else
                            print_error "SSH 服务重启失败"
                        fi
                    elif command -v service &>/dev/null; then
                        # SysVinit 系统
                        service sshd restart 2>/dev/null || service ssh restart 2>/dev/null
                        if [[ $? -eq 0 ]]; then
                            print_success "SSH 服务已重启，配置已生效"
                        else
                            print_error "SSH 服务重启失败"
                        fi
                    else
                        print_error "无法自动重启 SSH 服务"
                    fi
                else
                    print_info "已选择稍后手动重启"
                    echo ""
                    print_info "请稍后手动执行以下命令之一使配置生效:"
                    echo "  sudo systemctl restart sshd     (CentOS/RHEL/Ubuntu/Debian 新版)"
                    echo "  sudo systemctl restart ssh      (部分系统使用 ssh 服务名)"
                    echo "  sudo service sshd restart       (旧版 SysVinit 系统)"
                    echo "  sudo service ssh restart        (部分系统)"
                fi
            else
                print_info "已取消操作，保持当前 SSH 配置"
            fi
        else
            print_info "已保持当前配置，未做任何修改"
        fi
    fi

    echo ""
    print_line
    echo ""
    read -p "按 Enter 键返回主菜单..."
}

# =============================================================================
# 第四部分：交互式菜单系统
# =============================================================================

# 函数：显示主菜单
# 说明：新增菜单选项时，只需在这里添加一行描述文字
show_menu() {
    echo ""
    print_title "================================================"
    print_title "              主菜单 - 请选择操作"
    print_title "================================================"
    echo ""
    print_info "请输入数字选择要执行的功能:"
    echo ""
    echo "  1. 检测系统内存、磁盘及分区信息"
    echo "  2. 检测系统桌面环境"
    echo "  3. 检测/配置 root 用户远程密码登录"
    echo ""
    echo "  0. 退出脚本"
    echo ""
    print_line
}

# =============================================================================
# 第五部分：主程序入口
# =============================================================================

main() {
    # 清屏（可选，让界面更整洁）
    # clear

    # 步骤1: 显示全局系统信息
    show_global_info

    # 步骤2: 主循环，持续显示菜单直到用户选择退出
    while true; do
        show_menu

        # 读取用户输入
        read -p "请输入选项编号: " choice
        echo ""

        # 根据用户输入执行对应功能
        case "$choice" in
            1)
                # 功能1: 内存、磁盘、分区检测
                func_memory_disk
                ;;
            2)
                # 功能2: 桌面环境检测
                func_desktop_env
                ;;
            3)
                # 功能3: root 远程登录检测与配置
                func_root_ssh
                ;;
            0)
                # 退出脚本
                echo ""
                print_success "感谢使用 Linux 多功能检测工具箱，再见！"
                echo ""
                exit 0
                ;;
            *)
                # 输入无效选项
                echo ""
                print_error "无效的选项: '$choice'，请输入 1、2、3 或 0"
                echo ""
                ;;
        esac
    done
}

# =============================================================================
# 脚本执行入口
# =============================================================================
# 调用主函数，启动脚本
main
