#!/bin/bash
# 颜色定义
RED='\033[31m'
GREEN='\033[32m'
YELLOW='\033[33m'
BLUE='\033[34m'
MAGENTA='\033[35m'
CYAN='\033[36m'
WHITE='\033[1;37m'
WARN_BG='\033[1;37;41m'
RESET='\033[0m'

# 交互终端使用 Readline，兼容常见终端发送的退格键和 Delete 键序列。
read_input() {
    local variable_name="$1"
    if [[ -t 0 ]]; then
        bind '"\C-h": backward-delete-char' 2>/dev/null || true
        bind '"\C-?": backward-delete-char' 2>/dev/null || true
        bind '"\e[3~": delete-char' 2>/dev/null || true
        IFS= read -e -r "$variable_name"
    else
        IFS= read -r "$variable_name"
    fi
}

run_root() {
    if (( EUID == 0 )); then
        "$@"
    elif command -v sudo >/dev/null 2>&1; then
        sudo "$@"
    else
        echo -e "${RED}错误：当前操作需要 root 权限，但系统未安装 sudo${RESET}"
        return 1
    fi
}

# 检测系统类型和包管理器
detect_system() {
    if [ -f /etc/os-release ]; then
        . /etc/os-release
        OS=$ID
        OS_NAME=$NAME
        OS_VERSION=$VERSION_ID
    elif type lsb_release >/dev/null 2>&1; then
        OS=$(lsb_release -si | tr '[:upper:]' '[:lower:]')
        OS_NAME=$(lsb_release -si)
        OS_VERSION=$(lsb_release -sr)
    elif [ -f /etc/lsb-release ]; then
        . /etc/lsb-release
        OS=$(echo "$DISTRIB_ID" | tr '[:upper:]' '[:lower:]')
        OS_NAME=$DISTRIB_ID
        OS_VERSION=$DISTRIB_RELEASE
    else
        OS=$(uname -s)
        OS_VERSION=$(uname -r)
    fi

    # 检测包管理器
    if command -v apt-get &> /dev/null; then
        PKG_MANAGER="apt"
    elif command -v dnf &> /dev/null; then
        PKG_MANAGER="dnf"
    elif command -v yum &> /dev/null; then
        PKG_MANAGER="yum"
    elif command -v pacman &> /dev/null; then
        PKG_MANAGER="pacman"
    elif command -v apk &> /dev/null; then
        PKG_MANAGER="apk"
    elif command -v zypper &> /dev/null; then
        PKG_MANAGER="zypper"
    else
        echo -e "${RED}错误：无法检测到支持的包管理器！${RESET}"
        exit 1
    fi

    # 检测系统家族
    case "$OS" in
        debian|ubuntu|linuxmint|pop|elementary|zorin|kali|parrot|deepin)
            OS_FAMILY="debian"
            ;;
        centos|rhel|fedora|rocky|almalinux|oracle|ol|scientific|amazon|amzn)
            OS_FAMILY="rhel"
            ;;
        arch|manjaro|endeavouros|garuda)
            OS_FAMILY="arch"
            ;;
        alpine)
            OS_FAMILY="alpine"
            ;;
        opensuse*|sles|sled)
            OS_FAMILY="suse"
            ;;
        *)
            echo -e "${YELLOW}警告：未识别的系统 $OS，将尝试使用通用方法${RESET}"
            OS_FAMILY="unknown"
            ;;
    esac
}

# 检查基础工具（只检查不安装，避免启动时触发包管理器下载）
check_base_deps() {
    local deps=("awk" "sed" "sysctl" "modprobe" "modinfo" "depmod" "lsmod")
    local missing_deps=()
    for cmd in "${deps[@]}"; do
        if ! command -v "$cmd" &> /dev/null; then
            missing_deps+=("$cmd")
        fi
    done

    if [ ${#missing_deps[@]} -gt 0 ]; then
        echo -e "${RED}错误：缺少基础依赖：${missing_deps[*]}，请先安装后重试${RESET}"
        exit 1
    fi
}

# 按需安装 wget（仅在选择下载内核时触发，避免启动即下载）
ensure_wget() {
    if command -v wget &> /dev/null; then
        return 0
    fi
    echo -e "${YELLOW}缺少依赖：wget，正在安装...${RESET}"
    case "$PKG_MANAGER" in
        apt)
            run_root apt-get update && run_root apt-get install -y wget ca-certificates
            ;;
        pacman)
            run_root pacman -Syu --needed --noconfirm wget ca-certificates
            ;;
        apk)
            run_root apk add wget ca-certificates
            ;;
        zypper)
            run_root zypper --non-interactive install wget ca-certificates
            ;;
    esac || exit 1
    command -v wget >/dev/null 2>&1 || {
        echo -e "${RED}错误：wget 安装失败${RESET}"
        exit 1
    }
}

# 检测系统架构
detect_arch() {
    ARCH=$(uname -m)
    if [[ "$ARCH" != "aarch64" && "$ARCH" != "x86_64" ]]; then
        echo -e "${RED}错误：此脚本只支持 ARM 和 x86_64 架构，当前架构：$ARCH${RESET}"
        exit 1
    fi
}

# 获取当前 BBR 状态
get_current_status() {
    CURRENT_ALGO=$(sysctl net.ipv4.tcp_congestion_control 2>/dev/null | awk '{print $3}')
    CURRENT_QDISC=$(sysctl net.core.default_qdisc 2>/dev/null | awk '{print $3}')
    CURRENT_ECN=$(sysctl -n net.ipv4.tcp_ecn 2>/dev/null)

    if [ -z "$CURRENT_ALGO" ]; then
        CURRENT_ALGO="unknown"
    fi
    if [ -z "$CURRENT_QDISC" ]; then
        CURRENT_QDISC="unknown"
    fi
    if [ -z "$CURRENT_ECN" ]; then
        CURRENT_ECN="unknown"
    fi
}

# 配置文件路径
get_config_paths() {
    SYSCTL_CONF="/etc/sysctl.d/99-bbr3.conf"
    MODULES_CONF="/etc/modules-load.d/bbr3-qdisc.conf"
}

# 当前内核是否支持 BBRv3 (主线 >=6.14，或 XanMod/ylx 带 version:3 的模块)
has_bbr3_kernel() {
    local kv kmaj kmin ver
    kv=$(uname -r)
    [[ "$kv" == *bbrv3* || "$kv" == *bbr-v3* ]] && return 0
    kmaj="${kv%%.*}"; kmin=$(echo "$kv" | cut -d. -f2)
    kmaj="${kmaj//[^0-9]/}"; kmin="${kmin//[^0-9]/}"
    if [[ -n "$kmaj" ]]; then
        { [[ "$kmaj" -gt 6 ]] || { [[ "$kmaj" -eq 6 ]] && [[ "$kmin" -ge 14 ]]; }; } && return 0
    fi
    if modinfo tcp_bbr 2>/dev/null | awk '/^version:/ {print $2}' | grep -qx "3"; then
        return 0
    fi
    modinfo tcp_bbr3 &>/dev/null && return 0
    return 1
}

# 测试算法名是否可被内核接受（XanMod 的 BBRv3 算法名是 bbr，而非 bbr3）
# 注意：本内核 proc 写失败时 sysctl 退出码仍为 0，必须读回比对，不能靠退出码
algo_available() {
    local orig want now
    want="$1"
    orig=$(sysctl -n net.ipv4.tcp_congestion_control 2>/dev/null)
    sysctl -w net.ipv4.tcp_congestion_control="$want" >/dev/null 2>&1
    now=$(sysctl -n net.ipv4.tcp_congestion_control 2>/dev/null)
    if [[ -n "$orig" ]]; then
        sysctl -w net.ipv4.tcp_congestion_control="$orig" >/dev/null 2>&1
    fi
    [[ "$now" == "$want" ]]
}

# 解析实际可用的算法名：优先 bbr3，XanMod 内核回退为 bbr
resolve_algo() {
    local want="${1:-bbr3}"
    if [[ "$want" == "bbr3" ]] && ! algo_available bbr3; then
        algo_available bbr && { ALGO="bbr"; return 0; }
        return 1
    fi
    return 0
}

# 测试队列算法是否可被内核接受（写回比对，避免误判）
qdisc_available() {
    local orig now
    orig=$(sysctl -n net.core.default_qdisc 2>/dev/null)
    sysctl -w net.core.default_qdisc="$1" >/dev/null 2>&1
    now=$(sysctl -n net.core.default_qdisc 2>/dev/null)
    if [[ -n "$orig" ]]; then
        sysctl -w net.core.default_qdisc="$orig" >/dev/null 2>&1
    fi
    [[ "$now" == "$1" ]]
}

# 当前内核是否支持 fq_pie（PIE 精确延迟控制，需内核 >= 4.20 且模块可用）
kernel_supports_pie() {
    qdisc_available fq_pie
}

# 选项 1 的形态判定（KERNEL_STATE）：
#   xanmod-stable   : 全部 debian 系（含 Debian 13）→ 下载 XanMod 最新稳定版内核
#   pie-ready       : 非 debian 系且当前内核已支持 fq_pie → 醒目提示直接选 3-6 启用
#   pie-kernel      : 非 debian 系，内核过旧不支持 fq_pie → 提示用系统包管理器/官方仓库升级内核
detect_kernel_state() {
    if [[ "$OS_FAMILY" == "debian" ]]; then
        KERNEL_STATE="xanmod-stable"
    elif kernel_supports_pie; then
        KERNEL_STATE="pie-ready"
    else
        KERNEL_STATE="pie-kernel"
    fi
}

# 写入持久 BBRv3 + fq_pie 配置（并尽力立即生效）
apply_bbr3_config() {
    ALGO="${ALGO:-bbr3}"; QDISC="${QDISC:-fq_pie}"
    if [[ "$ALGO" == "bbr3" ]]; then
        if algo_available bbr3; then :; elif algo_available bbr; then ALGO="bbr"; fi
    fi
    clean_sysctl_conf
    run_root mkdir -p /etc/sysctl.d /etc/modules-load.d
    printf '# Managed by bbr3.sh\n%s = %s\n%s = %s\n%s = 1\n%s = 1\n' \
        "net.core.default_qdisc" "$QDISC" \
        "net.ipv4.tcp_congestion_control" "$ALGO" \
        "net.ipv4.tcp_ecn" "net.ipv4.tcp_ecn_fallback" \
        | run_root tee "$SYSCTL_CONF" >/dev/null

    { echo "sch_${QDISC}"; [[ "$ALGO" == "bbr3" ]] && echo "tcp_bbr3"; [[ "$ALGO" == "bbr" ]] && echo "tcp_bbr"; } \
        | run_root tee "$MODULES_CONF" >/dev/null

    if has_bbr3_kernel; then
        run_root sysctl -w "net.core.default_qdisc=$QDISC" >/dev/null 2>&1 || true
        run_root sysctl -w "net.ipv4.tcp_congestion_control=$ALGO" >/dev/null 2>&1 || true
        run_root sysctl -w "net.ipv4.tcp_ecn=1" >/dev/null 2>&1 || true
        local cc_now qnow
        cc_now=$(sysctl -n net.ipv4.tcp_congestion_control 2>/dev/null || echo "")
        qnow=$(sysctl -n net.core.default_qdisc 2>/dev/null || echo "")
        if [[ "$cc_now" == "$ALGO" && "$qnow" == "$QDISC" ]]; then
            echo -e "${GREEN}[OK] BBRv3 配置已生效：cc=$cc_now, qdisc=$qnow, ECN=on${RESET}"
        else
            echo -e "${YELLOW}[INFO] 已写入配置，Live 生效受限（cc=$cc_now），重启后完整生效${RESET}"
        fi
    else
        echo -e "${YELLOW}[INFO] 已写入 $SYSCTL_CONF：$ALGO + $QDISC；当前内核不支持 BBRv3，重启新内核后生效${RESET}"
    fi
}

# debian 系：从地域节点下载 BBRv3 内核（x86_64 用 XanMod，arm64 用 byJoey 版本）
install_xanmod_kernel() {
    ensure_wget || return 1
    echo -e "${CYAN}正在从 $KERNEL_DOWNLOAD_URL 检查内核文件...${RESET}"

    local FILE_PREFIX=""
    if [ "$ARCH" = "aarch64" ]; then
        FILE_PREFIX="debian-arm64"
    elif [ "$ARCH" = "x86_64" ]; then
        FILE_PREFIX="debian-x86_64"
    fi

    if [[ -z "$FILE_PREFIX" ]]; then
        echo -e "${RED}错误：未找到适合当前系统 ($OS_FAMILY) 和架构 ($ARCH) 的内核包${RESET}"
        return 1
    fi

    echo -e "${CYAN}检测到适合的文件前缀：${GREEN}$FILE_PREFIX${RESET}"

    INSTALLED_VERSION=$(get_installed_version)
    echo -e "${CYAN}当前已安装版本：${GREEN}${INSTALLED_VERSION:-"未安装"}${RESET}"

    download_package_set "$FILE_PREFIX" linux-headers.deb linux-image.deb linux-libc-dev.deb || return 1

    ALGO="bbr3"; QDISC="fq_pie"
    apply_bbr3_config
    install_packages_debian
}

# 清理所有 sysctl.d 中的旧拥塞/队列/ECN 配置，防止其他脚本覆盖本脚本设置（参考 tcpx.sh remove_bbr_lotserver）
clean_sysctl_conf() {
    local conf
    for conf in /etc/sysctl.d/*.conf /etc/sysctl.conf; do
        [ -f "$conf" ] && run_root sed -i '/net.core.default_qdisc/d; /net.ipv4.tcp_congestion_control/d; /net.ipv4.tcp_ecn/d' "$conf"
    done
    run_root mkdir -p "${SYSCTL_CONF%/*}"
    run_root touch "$SYSCTL_CONF"
}

# 加载队列调度模块（无屏蔽）
load_qdisc_module() {
    local qdisc_name="$1"
    local module_name="sch_$qdisc_name"
    
    if run_root sysctl -w net.core.default_qdisc="$qdisc_name"; then
        run_root sysctl -w net.core.default_qdisc="$CURRENT_QDISC"
        return 0
    fi
    
    if lsmod | grep -q "^${module_name//-/_}"; then
        return 0
    fi
    
    echo -e "${CYAN}正在加载内核模块 $module_name...${RESET}"
    if run_root modprobe "$module_name"; then
        echo -e "${GREEN}[OK] 模块 $module_name 加载成功${RESET}"
        return 0
    else
        echo -e "${YELLOW}[WARN] 模块 $module_name 加载失败，可能内核不支持${RESET}"
        return 1
    fi
}

# 询问是否永久保存更改（无屏蔽）
ask_to_save() {
    load_qdisc_module "$QDISC"
    
    echo -e "${CYAN}正在应用配置...${RESET}"
    run_root sysctl -w net.core.default_qdisc="$QDISC"
    run_root sysctl -w net.ipv4.tcp_congestion_control="$ALGO"
    
    NEW_QDISC=$(sysctl -n net.core.default_qdisc)
    NEW_ALGO=$(sysctl -n net.ipv4.tcp_congestion_control)
    
    if [[ "$NEW_QDISC" == "$QDISC" && "$NEW_ALGO" == "$ALGO" ]]; then
        echo -e "${GREEN}[OK] 配置已立即生效！${RESET}"
        echo -e "${CYAN}  当前队列算法：${GREEN}$NEW_QDISC${RESET}"
        echo -e "${CYAN}  当前拥塞控制：${GREEN}$NEW_ALGO${RESET}"
    else
        echo -e "${RED}[ERROR] 配置应用失败！${RESET}"
        echo -e "${YELLOW}  队列算法期望：$QDISC，实际：$NEW_QDISC${RESET}"
        echo -e "${YELLOW}  拥塞控制期望：$ALGO，实际：$NEW_ALGO${RESET}"
        echo -e "${YELLOW}  可能原因：当前内核不支持 $QDISC 队列算法${RESET}"
        return 1
    fi
    
    echo -n -e "${CYAN}是否将配置永久保存到 $SYSCTL_CONF？(y/n): ${RESET}"
    read_input SAVE || return 1
    if [[ "$SAVE" == "y" || "$SAVE" == "Y" ]]; then
        clean_sysctl_conf
        echo "net.core.default_qdisc=$QDISC" | run_root tee -a "$SYSCTL_CONF"
        echo "net.ipv4.tcp_congestion_control=$ALGO" | run_root tee -a "$SYSCTL_CONF"
        run_root sysctl --system || run_root sysctl -p "$SYSCTL_CONF"
        
        if [[ "$QDISC" == "fq" || "$QDISC" == "fq_codel" ]]; then
            run_root rm -f "$MODULES_CONF"
            echo -e "${GREEN}[OK] 更改已永久保存${RESET}"
        else
            run_root mkdir -p "${MODULES_CONF%/*}"
            echo "sch_$QDISC" | run_root tee "$MODULES_CONF"
            echo -e "${GREEN}[OK] 更改已永久保存，模块 sch_$QDISC 将在开机时自动加载${RESET}"
        fi
    else
        echo -e "${YELLOW}[INFO] 未永久保存，重启后会恢复默认设置${RESET}"
    fi
}

# 开启/关闭 ECN（显式拥塞通知），参考 tcpx.sh set_ecn
set_ecn() {
    local status="$1"
    clean_sysctl_conf
    run_root sysctl -w "net.ipv4.tcp_ecn=$status" >/dev/null 2>&1 || true
    echo "net.ipv4.tcp_ecn=$status" | run_root tee -a "$SYSCTL_CONF" >/dev/null
    if [[ "$status" == "1" ]]; then
        run_root sysctl -w "net.ipv4.tcp_ecn_fallback=1" >/dev/null 2>&1 || true
        echo "net.ipv4.tcp_ecn_fallback=1" | run_root tee -a "$SYSCTL_CONF" >/dev/null
    fi
    run_root sysctl --system >/dev/null 2>&1 || run_root sysctl -p "$SYSCTL_CONF" >/dev/null 2>&1 || true
    [[ "$status" == "1" ]] && echo -e "${GREEN}[OK] ECN 已开启${RESET}" || echo -e "${GREEN}[OK] ECN 已关闭${RESET}"
}

# 系统网络自适应优化（参考 tcpx.sh optimizing_system：按内存/CPU/内核版本动态调参）
optimizing_system() {
    echo -e "${CYAN}开始系统网络自适应优化（按内存/CPU/内核版本动态调优）...${RESET}"

    local total_mem_kb total_mem_mb cpu_cores kernel_major kernel_minor
    total_mem_kb=$(awk '/MemTotal/ {print $2}' /proc/meminfo)
    total_mem_mb=$((total_mem_kb / 1024))
    cpu_cores=$(nproc)
    kernel_major=$(uname -r | cut -d. -f1)
    kernel_minor=$(uname -r | cut -d. -f2)

    # 根据内存大小动态适配网络缓存与文件描述符
    local tcp_mem_max somaxconn file_max
    if [ "$total_mem_mb" -ge 8192 ]; then
        tcp_mem_max=134217728; somaxconn=1048576; file_max=2097152
    elif [ "$total_mem_mb" -ge 2048 ]; then
        tcp_mem_max=67108864; somaxconn=65535; file_max=1048576
    else
        tcp_mem_max=16777216; somaxconn=32768; file_max=524288
    fi

    # 根据 CPU 核心数动态适配网卡队列与积压
    local netdev_max_backlog=$((10000 * cpu_cores))
    [[ $netdev_max_backlog -lt 32768 ]] && netdev_max_backlog=32768
    [[ $netdev_max_backlog -gt 100000 ]] && netdev_max_backlog=100000

    local netdev_budget=$((300 + 20 * cpu_cores))
    [[ $netdev_budget -gt 50000 ]] && netdev_budget=50000

    # 生成独立的 sysctl 配置（备份后重写，避免重复行堆积）
    local sysctl_conf="/etc/sysctl.d/99-bbr3-tune.conf"
    [[ -f "$sysctl_conf" ]] && run_root cp "$sysctl_conf" "${sysctl_conf}.bak"
    run_root cp /dev/null "$sysctl_conf"

    run_root tee -a "$sysctl_conf" >/dev/null <<EOF
# --- 文件系统与内存基础 ---
fs.file-max = $file_max
fs.inotify.max_user_instances = 8192
fs.inotify.max_user_watches = $file_max
kernel.pid_max = 65535
vm.swappiness = 1
vm.overcommit_memory = 1

# --- 网络核心队列与连接数 ---
net.core.somaxconn = $somaxconn
net.core.netdev_max_backlog = $netdev_max_backlog
net.core.netdev_budget = $netdev_budget
net.core.rmem_max = $tcp_mem_max
net.core.wmem_max = $tcp_mem_max
net.core.rmem_default = $((tcp_mem_max / 2))
net.core.wmem_default = $((tcp_mem_max / 2))
net.core.optmem_max = 65536

# --- TCP 核心调优（缓冲区自适应）---
net.ipv4.tcp_rmem = 4096 87380 $tcp_mem_max
net.ipv4.tcp_wmem = 4096 65536 $tcp_mem_max
net.ipv4.udp_rmem_min = 8192
net.ipv4.udp_wmem_min = 8192
net.ipv4.tcp_mtu_probing = 1
net.ipv4.tcp_autocorking = 0
net.ipv4.tcp_slow_start_after_idle = 0
net.ipv4.tcp_max_syn_backlog = $somaxconn
net.ipv4.tcp_notsent_lowat = 16384
net.ipv4.tcp_no_metrics_save = 0
net.ipv4.tcp_ecn = 1
net.ipv4.tcp_ecn_fallback = 1

# --- TCP 超时、重传与 KeepAlive ---
net.ipv4.tcp_keepalive_time = 600
net.ipv4.tcp_keepalive_intvl = 15
net.ipv4.tcp_keepalive_probes = 2
net.ipv4.tcp_fin_timeout = 15
net.ipv4.tcp_synack_retries = 1
net.ipv4.tcp_orphan_retries = 1
net.ipv4.tcp_retries2 = 5
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_timestamps = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.ip_local_port_range = 1024 65535
net.ipv4.tcp_max_tw_buckets = 5000
net.ipv4.tcp_fastopen = 3

# --- 路由转发与 IPv6（默认开启转发，兼容 Docker/Tailscale）---
net.ipv4.ip_forward = 1
net.ipv4.conf.all.route_localnet = 1
net.ipv4.conf.all.forwarding = 1
net.ipv4.conf.default.forwarding = 1
net.ipv6.conf.all.forwarding = 1
net.ipv6.conf.default.forwarding = 1
net.ipv6.conf.lo.forwarding = 1
net.ipv6.conf.all.disable_ipv6 = 0
net.ipv6.conf.default.disable_ipv6 = 0
EOF

    # 内核版本兼容：仅在低版本写入已废弃参数
    if [[ "$kernel_major" -lt 4 || ("$kernel_major" -eq 4 && "$kernel_minor" -lt 12) ]]; then
        echo "net.ipv4.tcp_tw_recycle = 0" | run_root tee -a "$sysctl_conf" >/dev/null
    fi
    if [[ "$kernel_major" -lt 4 || ("$kernel_major" -eq 4 && "$kernel_minor" -lt 11) ]]; then
        echo "net.ipv4.tcp_fack = 1" | run_root tee -a "$sysctl_conf" >/dev/null
    fi

    # 系统资源限制（systemd + limits.conf + ulimit + pam_limits）
    echo -e "${CYAN}正在根据内存大小优化文件描述符限制（nofile=$file_max）...${RESET}"
    if [[ -d /etc/systemd ]]; then
        run_root tee /etc/systemd/system.conf >/dev/null <<EOF
[Manager]
DefaultTimeoutStopSec=30s
DefaultLimitCORE=infinity
DefaultLimitNOFILE=$file_max
DefaultLimitNPROC=infinity
DefaultTasksMax=infinity
EOF
        run_root systemctl daemon-reload >/dev/null 2>&1
    fi

    run_root tee /etc/security/limits.conf >/dev/null <<EOF
* soft   nofile    $file_max
* hard   nofile    $file_max
* soft   nproc     unlimited
* hard   nproc     unlimited
* soft   core      unlimited
* hard   core      unlimited
root  soft   nofile    $file_max
root  hard   nofile    $file_max
root  soft   nproc     unlimited
root  hard   nproc     unlimited
root  soft   core      unlimited
root  hard   core      unlimited
EOF

    run_root sed -i '/ulimit -SHn/d; /ulimit -SHu/d' /etc/profile 2>/dev/null || true
    echo "ulimit -SHn $file_max" | run_root tee -a /etc/profile >/dev/null

    if [[ -f /etc/pam.d/common-session ]] && ! grep -q "pam_limits.so" /etc/pam.d/common-session; then
        echo "session required pam_limits.so" | run_root tee -a /etc/pam.d/common-session >/dev/null
    fi

    # 应用配置
    run_root sysctl -p "$sysctl_conf" >/dev/null 2>&1
    run_root sysctl --system >/dev/null 2>&1

    # 启用透明大页（如支持）
    if [[ -f /sys/kernel/mm/transparent_hugepage/enabled ]]; then
        run_root bash -c 'echo always > /sys/kernel/mm/transparent_hugepage/enabled' 2>/dev/null || true
    fi

    echo -e "${GREEN}[OK] 系统网络自适应优化完成（建议重启后全面生效）${RESET}"
    echo -e "${CYAN}    参数文件：$sysctl_conf（备份 .bak）${RESET}"
}

# 检查内核 Headers 是否与运行内核匹配（参考 tcpx.sh check_status）
check_headers_status() {
    local running_kernel
    running_kernel=$(uname -r)
    HEADERS_STATUS="未安装"
    if [ "$OS_FAMILY" = "debian" ]; then
        installed_headers=$(dpkg -l 2>/dev/null | grep -E "(linux|proxmox|pve|raspberrypi)-(headers|image)" | awk '{print $2}' | grep -v '^$' || echo "")
        if [[ -n "$installed_headers" ]]; then
            echo "$installed_headers" | grep -q -E "(linux|proxmox|pve|raspberrypi)-headers-${running_kernel}" \
                && HEADERS_STATUS="已匹配" || HEADERS_STATUS="未匹配"
        fi
    else
        HEADERS_STATUS="未知"
    fi
}

# 获取已安装内核版本
get_installed_version_debian() {
    dpkg -l | grep "linux-image" | grep "xanmod" | awk '{print $2}' | sed 's/linux-image-//' | head -n 1
}

get_installed_version() {
    if [ "$OS_FAMILY" = "debian" ]; then
        get_installed_version_debian
    else
        echo ""
    fi
}

# 更新引导加载程序（debian 系强制刷新 initramfs + grub，防止重启 VFS 错误）
update_bootloader() {
    echo -e "${CYAN}正在强制刷新引导（initramfs + grub）...${RESET}"

    if [ "$OS_FAMILY" = "debian" ]; then
        local boot_fail=0
        # 第一步：强制重建所有内核的 initramfs（缺少此步重启会 VFS: Unable to mount root fs）
        if command -v update-initramfs &> /dev/null; then
            echo -e "${YELLOW}正在执行 update-initramfs -u -k all...${RESET}"
            if run_root update-initramfs -u -k all; then
                echo -e "${GREEN}[OK] initramfs 更新成功${RESET}"
            else
                echo -e "${RED}[ERROR] initramfs 更新失败${RESET}"
                boot_fail=1
            fi
        else
            echo -e "${YELLOW}[WARN] 未找到 update-initramfs，跳过（系统可能使用 dracut）${RESET}"
        fi

        # 第二步：刷新 grub 菜单
        if command -v update-grub &> /dev/null; then
            echo -e "${YELLOW}正在执行 update-grub...${RESET}"
            if run_root update-grub; then
                echo -e "${GREEN}[OK] GRUB 更新成功${RESET}"
            else
                echo -e "${RED}[ERROR] GRUB 更新失败${RESET}"
                boot_fail=1
            fi
        else
            echo -e "${YELLOW}[WARN] 未找到 update-grub，请手动刷新引导配置${RESET}"
            boot_fail=1
        fi

        if [[ "$boot_fail" -eq 1 ]]; then
            echo -e "${RED}[ERROR] 引导刷新未完整执行，请手动运行：update-initramfs -u -k all && update-grub${RESET}"
            return 1
        fi
        return 0
    fi

    echo -e "${YELLOW}[INFO] 非 debian 系，跳过引导刷新${RESET}"
    return 0
}

# 安装 Debian 内核（无屏蔽）
install_packages_debian() {
    if [[ ${#DOWNLOADED_PACKAGES[@]} -eq 0 ]]; then
        echo -e "${RED}错误：未找到已下载的内核文件，安装中止${RESET}"
        return 1
    fi
    
    echo -e "${CYAN}开始安装新内核...${RESET}"
    if run_root dpkg -i "${DOWNLOADED_PACKAGES[@]}" && update_bootloader; then
        echo -e "${GREEN}[OK] 内核安装并配置完成${RESET}"
        prompt_reboot
    else
        echo -e "${RED}[ERROR] 内核安装或引导更新失败！系统可能处于不稳定状态${RESET}"
        return 1
    fi
}

# 重启提示
prompt_reboot() {
    echo -n -e "${YELLOW}需要重启系统来加载新内核。是否立即重启？(y/n): ${RESET}"
    read_input REBOOT_NOW || return 1
    if [[ "$REBOOT_NOW" == "y" || "$REBOOT_NOW" == "Y" ]]; then
        echo -e "${CYAN}系统即将重启...${RESET}"
        run_root reboot
    else
        echo -e "${YELLOW}[INFO] 操作完成，请稍后手动重启来应用新内核${RESET}"
    fi
}

# 内核下载地址（按地域分流，见 setup_download_sources）
#   大陆机器：igz.mbvpn.cn（国内节点）
#   海外机器（含港澳台）：ipan.mbvpn.cn
KERNEL_DOWNLOAD_URL="http://ipan.mbvpn.cn/bbr3"
KERNEL_DOWNLOAD_URL_BACKUP="http://igz.mbvpn.cn/bbr3"
DOWNLOAD_DIR=""
DOWNLOADED_PACKAGES=()

# 检测机器所在地域：cn=大陆，overseas=海外（含港澳台）
detect_region() {
    local country baidu_ms google_ms
    country=$(curl -s --connect-timeout 3 -m 5 http://ipinfo.io/country 2>/dev/null || true)
    if [[ "$country" == "CN" ]]; then
        printf 'cn'; return 0
    fi
    if [[ -n "$country" ]]; then
        printf 'overseas'; return 0
    fi
    baidu_ms=$(ping -c 2 -W 1 baidu.com 2>/dev/null | awk -F/ '/rtt/ {print $5}' | head -1)
    google_ms=$(ping -c 2 -W 1 8.8.8.8 2>/dev/null | awk -F/ '/rtt/ {print $5}' | head -1)
    if [[ -n "$baidu_ms" && -z "$google_ms" ]]; then
        printf 'cn'; return 0
    fi
    if [[ -n "$baidu_ms" && -n "$google_ms" ]] && awk -v b="$baidu_ms" -v g="$google_ms" 'BEGIN{exit(b<g?0:1)}'; then
        printf 'cn'; return 0
    fi
    printf 'overseas'
}

# 按地域设置下载源主备顺序（主源不通自动切换备用源）
setup_download_sources() {
    REGION="$(detect_region)"
    if [[ "$REGION" == "cn" ]]; then
        KERNEL_DOWNLOAD_URL="http://igz.mbvpn.cn/bbr3"
        KERNEL_DOWNLOAD_URL_BACKUP="http://ipan.mbvpn.cn/bbr3"
    else
        KERNEL_DOWNLOAD_URL="http://ipan.mbvpn.cn/bbr3"
        KERNEL_DOWNLOAD_URL_BACKUP="http://igz.mbvpn.cn/bbr3"
    fi
    echo -e "${GREEN}[OK] 地域检测：${RESET}$( [[ "$REGION" == "cn" ]] && echo "大陆（国内节点优先）" || echo "海外/港澳台（海外节点优先）" )"
    echo -e "${CYAN}    主下载源：$KERNEL_DOWNLOAD_URL${RESET}"
    echo -e "${CYAN}    备用下载源：$KERNEL_DOWNLOAD_URL_BACKUP${RESET}"
    echo -e "${CYAN}    主源不通将自动切换备用源${RESET}"
}

cleanup_download_dir() {
    if [[ -n "$DOWNLOAD_DIR" && -d "$DOWNLOAD_DIR" ]]; then
        rm -rf "$DOWNLOAD_DIR"
    fi
    DOWNLOAD_DIR=""
    DOWNLOADED_PACKAGES=()
}

download_package_set() {
    local prefix="$1"
    shift
    local source url suffix destination package ok
    local sources=("$KERNEL_DOWNLOAD_URL" "$KERNEL_DOWNLOAD_URL_BACKUP")

    cleanup_download_dir
    DOWNLOAD_DIR=$(mktemp -d "${TMPDIR:-/tmp}/bbr3.XXXXXX") || return 1

    for source in "${sources[@]}"; do
        DOWNLOADED_PACKAGES=()
        rm -f "$DOWNLOAD_DIR"/*
        echo -e "${YELLOW}准备从 $source 下载内核...${RESET}"

        ok=true
        for suffix in "$@"; do
            destination="$DOWNLOAD_DIR/$prefix-$suffix"
            url="$source/$prefix-$suffix"
            echo -e "${CYAN}正在下载：$url${RESET}"
            if ! wget --show-progress --timeout=30 --tries=2 -O "$destination" "$url" || [[ ! -s "$destination" ]]; then
                echo -e "${YELLOW}[WARN] 当前源下载失败，正在切换下载源...${RESET}"
                ok=false
                break
            fi
            DOWNLOADED_PACKAGES+=("$destination")
        done
        [[ "$ok" == false ]] && continue

        if [[ ${#DOWNLOADED_PACKAGES[@]} -eq $# ]]; then
            local packages_valid=true
            for package in "${DOWNLOADED_PACKAGES[@]}"; do
                dpkg-deb --info "$package" >/dev/null 2>&1 || packages_valid=false
            done
            if [[ "$packages_valid" == true ]]; then
                return 0
            fi
            echo -e "${YELLOW}[WARN] 下载源 $source 返回的内核包无效，正在切换下载源...${RESET}"
        fi
    done

    echo -e "${RED}错误：主下载源和备用下载源均下载失败${RESET}"
    cleanup_download_dir
    return 1
}

trap cleanup_download_dir EXIT

# 安装内核（入口：统一从地域节点 igz/ipan 下载，见 setup_download_sources）
install_latest_version() {
    if [[ "$OS_FAMILY" == "debian" ]]; then
        echo -e "${GREEN}当前系统 ($OS_NAME $OS_VERSION)：下载 $([[ "$ARCH" == "aarch64" ]] && echo 'byJoey' || echo 'XanMod') 最新稳定版内核${RESET}"
        install_xanmod_kernel
    else
        echo -e "${RED}错误：当前系统 ($OS_NAME) 暂不支持通过脚本安装内核${RESET}"
        return 1
    fi
}

# 选项 1：按系统支持情况分流（三种形态）
#   xanmod-stable   : 全部 debian 系（含 Debian 13）→ 下载 XanMod 最新稳定版内核
#   pie-ready       : 非 debian 系且内核已支持 fq_pie → 醒目提示直接选 3-6 启用
#   pie-kernel      : 非 debian 系，内核过旧 → 提示用系统包管理器/官方仓库升级内核
install_kernel_menu() {
    case "$KERNEL_STATE" in
        xanmod-stable)
            echo -e "${GREEN}您选择了安装/更新 BBR v3 内核（XanMod 最新稳定版）${RESET}"
            install_latest_version
            ;;
        pie-ready)
            echo -e "${WARN_BG}  [提示] 当前内核已支持 fq_pie，无需安装新内核！${RESET}"
            echo -e "${GREEN}请直接选择选项 3（BBR + FQ_PIE，推荐）或 4-6 启用加速${RESET}"
            ;;
        pie-kernel)
            echo -e "${WARN_BG}  [提示] 当前内核过旧，不支持 fq_pie，请先升级系统内核！${RESET}"
            echo -e "${YELLOW}请用官方仓库升级内核（rhel: dnf --enablerepo=elrepo-kernel install kernel-ml，官方主线内核支持 L2TP + fq + fq_pie；arch: pacman -S linux；alpine: apk upgrade；suse: zypper dup），重启后回到脚本选 3-6 启用${RESET}"
            ;;
    esac
}

# 卸载内核（无屏蔽）
uninstall_kernel() {
    local running_kernel
    local package
    local packages_to_remove=()
    running_kernel=$(uname -r)

    echo -e "${YELLOW}您选择了卸载 BBR 内核${RESET}"
    
    if [ "$OS_FAMILY" = "debian" ]; then
        while IFS= read -r package; do
            [[ -z "$package" ]] && continue
            if [[ "$package" == *"$running_kernel"* ]]; then
                echo -e "${YELLOW}[WARN] 跳过当前正在运行的内核包：$package${RESET}"
                continue
            fi
            packages_to_remove+=("$package")
        done < <(dpkg-query -W -f='${binary:Package}\n' '*xanmod*' 2>/dev/null)

        if [[ ${#packages_to_remove[@]} -gt 0 ]]; then
            echo -e "${CYAN}将要卸载以下内核包：${YELLOW}${packages_to_remove[*]}${RESET}"
            if run_root apt-get remove --purge -y "${packages_to_remove[@]}" && update_bootloader; then
                echo -e "${GREEN}[OK] 内核包已卸载，请记得重启系统${RESET}"
            else
                echo -e "${RED}[ERROR] 内核卸载或引导更新失败${RESET}"
                return 1
            fi
        else
            echo -e "${YELLOW}[INFO] 未找到由本脚本安装的 xanmod 内核包${RESET}"
        fi
    else
        echo -e "${YELLOW}[INFO] 未知系统类型，请手动卸载内核${RESET}"
    fi
}

# 分隔线
print_separator() {
    echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
}

# 主菜单
print_menu() {
    get_current_status
    check_headers_status
    clear
    print_separator
    echo -e "${CYAN}          BBR3 管理脚本${RESET}"
    print_separator
    echo -e "${WHITE}系统信息${RESET}"
    echo -e "  系统：${GREEN}$OS_NAME $OS_VERSION ($OS_FAMILY系列)${RESET}"
    echo -e "  架构：${GREEN}$ARCH${RESET}"
    echo -e "  内核：${GREEN}$(uname -r)${RESET}  内核Headers：${GREEN}$HEADERS_STATUS${RESET}"
    echo -e "  地域：${GREEN}$([[ "$REGION" == "cn" ]] && echo "大陆" || echo "海外/港澳台")${RESET}  下载源：${GREEN}$KERNEL_DOWNLOAD_URL${RESET}"
    case "$KERNEL_STATE" in
        pie-ready)
            echo -e "  PIE支持：${GREEN}当前内核已支持 fq_pie${RESET}（${WARN_BG}请直接选 3-6 启用${RESET}）"
            ;;
        pie-kernel)
            echo -e "  PIE支持：${RED}当前内核过旧，不支持 fq_pie${RESET}（更新内核后即可开启，见选项 1）"
            ;;
    esac
    # 检查BBR版本和状态
    if has_bbr3_kernel && [[ "$CURRENT_ALGO" == "bbr3" ]]; then
        echo -e "  当前：${GREEN}BBR3 + $CURRENT_QDISC${RESET}"
    elif [[ "$CURRENT_ALGO" == "bbr" ]] && [[ "$(uname -r)" == *xanmod* ]]; then
        echo -e "  当前：${GREEN}BBR3 (XanMod 内置) + $CURRENT_QDISC${RESET}"
    elif modinfo tcp_bbr3 &>/dev/null; then
        echo -e "  当前：${YELLOW}BBR3（tcp_bbr3）+ $CURRENT_QDISC${RESET}"
    elif modinfo tcp_bbr &>/dev/null; then
        BBR_VERSION=$(modinfo tcp_bbr 2>/dev/null | awk '/^version:/ {print $2}')
        if [[ "$BBR_VERSION" == "3" ]]; then
            echo -e "  当前：${YELLOW}BBR3 + $CURRENT_QDISC${RESET}"
        else
            echo -e "  当前：${YELLOW}BBR + $CURRENT_QDISC${RESET}"
        fi
    else
        echo -e "  当前：${YELLOW}未安装 BBR${RESET}"
    fi
    case "$KERNEL_STATE" in
        pie-ready)
            echo ""
            echo -e "${WARN_BG}  [!] 提示：当前内核已支持 fq_pie，无需安装新内核，请直接选择 3-6 启用加速！${RESET}"
            ;;
        pie-kernel)
            echo ""
            echo -e "${WARN_BG}  [!] 提示：当前内核过旧，请先升级系统内核（重启后即可选择 3-6 开启 fq_pie）${RESET}"
            ;;
    esac
    print_separator
    echo ""
    echo -e "${CYAN}内核管理${RESET}"
    echo ""
    case "$KERNEL_STATE" in
        xanmod-stable)
            echo -e "  ${GREEN}1.${RESET} 安装/更新 BBR v3 内核（x86_64: XanMod；arm64: byJoey；安装后强制刷新引导，按地域从 igz/ipan 节点下载）"
            ;;
        pie-ready)
            echo -e "  ${YELLOW}1.${RESET} 当前内核已支持 fq_pie，无需安装新内核 → ${WARN_BG}请直接选 3-6 启用${RESET}"
            ;;
        pie-kernel)
            echo -e "  ${YELLOW}1.${RESET} 当前内核过旧：请升级系统内核（rhel: dnf --enablerepo=elrepo-kernel install kernel-ml 官方主线内核；arch: pacman -S linux 等），重启后选 3-6 开启"
            ;;
    esac
    echo -e "  ${GREEN}2.${RESET} 检查 BBR v3 状态"
    echo ""
    echo -e "${MAGENTA}加速配置${RESET}"
    echo ""
    echo -e "  ${GREEN}3.${RESET} BBR3 + FQ_PIE      ${CYAN}[推荐]  BBRv3 + 精确延迟控制（默认）${RESET}"
    echo -e "  ${GREEN}4.${RESET} BBR3 + FQ          ${CYAN}[稳定]  公平队列，低延迟${RESET}"
    echo -e "  ${GREEN}5.${RESET} BBR3 + FQ_CODEL    ${CYAN}[平衡]  结合公平和延迟控制${RESET}"
    echo -e "  ${GREEN}6.${RESET} BBR3 + CAKE        ${CYAN}[智能]  BBRv3 + 智能队列${RESET}"
    echo ""
    echo -e "${CYAN}系统优化${RESET}"
    echo ""
    echo -e "  ${GREEN}7.${RESET} 系统网络自适应优化（按内存/CPU 动态调参）"
    echo -e "  ${GREEN}8.${RESET} 开启 ECN（显式拥塞通知）"
    echo -e "  ${GREEN}9.${RESET} 关闭 ECN"
    echo ""
    echo -e "${YELLOW}其他操作${RESET}"
    echo ""
    echo -e "  ${YELLOW}10.${RESET} 卸载 BBR 内核"
    echo ""
    echo -e "  ${RED}0.${RESET} 退出"
    echo ""
    print_separator
}

# 主流程
detect_system
detect_arch
detect_kernel_state
check_base_deps
get_current_status
get_config_paths
setup_download_sources

while true; do
    print_menu
    echo -n -e "${CYAN}请选择一个操作 (0-10)：${RESET}"
    if ! read_input ACTION; then
        echo ""
        echo -e "${RED}正在退出脚本...${RESET}"
        exit 0
    fi
    ACTION=${ACTION:-3}
    case "$ACTION" in
        0)
            echo ""
            echo -e "${RED}正在退出脚本...${RESET}"
            exit 0
            ;;
        1)
            echo ""
            install_kernel_menu
            echo ""
            echo -n -e "${CYAN}按回车键返回主菜单...${RESET}"
            read -r
            ;;
        2)
            echo ""
            echo -e "${GREEN}正在检查 BBR v3 状态...${RESET}"
            BBR_MODULE_INFO=$(modinfo tcp_bbr 2>/dev/null)
            if [[ -z "$BBR_MODULE_INFO" ]]; then
                echo -e "${CYAN}正在刷新模块依赖...${RESET}"
                run_root depmod -a || true
                BBR_MODULE_INFO=$(modinfo tcp_bbr 2>/dev/null)
            fi
            IS_BBR3=0
            { has_bbr3_kernel || modinfo tcp_bbr3 &>/dev/null; } && IS_BBR3=1
            if [[ -z "$BBR_MODULE_INFO" && "$IS_BBR3" -eq 0 ]]; then
                echo -e "${RED}[ERROR] 未加载 BBR/BBRv3 模块，无法检查版本${RESET}"
                echo -e "${YELLOW}        请先安装内核并重启${RESET}"
            else
                BBR_VERSION=$(echo "$BBR_MODULE_INFO" | awk '/^version:/ {print $2}')
                if [[ "$IS_BBR3" -eq 1 ]]; then
                    echo -e "${GREEN}[OK] BBR v3 已就绪（模块版本：${BBR_VERSION:-mainline}）${RESET}"
                elif [[ -n "$BBR_VERSION" && "$BBR_VERSION" == "3" ]]; then
                    echo -e "${GREEN}[OK] BBR 模块版本：$BBR_VERSION (v3)${RESET}"
                else
                    echo -e "${YELLOW}[WARN] 检测到 BBR 模块，但不是 v3（版本：${BBR_VERSION:-unknown}）${RESET}"
                fi

                get_current_status
                if [[ "$CURRENT_ALGO" == "bbr" || "$CURRENT_ALGO" == "bbr3" ]]; then
                    echo -e "${GREEN}[OK] TCP 拥塞控制算法：$CURRENT_ALGO${RESET}"
                else
                    echo -e "${YELLOW}[WARN] 当前算法不是 bbr/bbr3，而是：$CURRENT_ALGO${RESET}"
                fi

                echo -e "${GREEN}[OK] 队列管理算法：$CURRENT_QDISC${RESET}"
                if [[ "$CURRENT_ECN" == "1" ]]; then
                    echo -e "${GREEN}[OK] ECN（显式拥塞通知）：已开启${RESET}"
                else
                    echo -e "${YELLOW}[WARN] ECN 当前状态：$CURRENT_ECN${RESET}"
                fi

                echo ""
                echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
                if [[ "$IS_BBR3" -eq 1 && "$CURRENT_ALGO" == "bbr3" ]]; then
                    echo -e "  ${BLUE}当前配置：BBR v3 + $CURRENT_QDISC${RESET}"
                    echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
                    echo ""
                    echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
                    echo -e "${GREEN}  检测完成，BBR v3 已正确安装并生效！${RESET}"
                    echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
                else
                    echo -e "  ${BLUE}当前配置：$CURRENT_ALGO + $CURRENT_QDISC${RESET}"
                    echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}"
                    echo ""
                    echo -e "${YELLOW}[INFO] BBR v3 未完全生效${RESET}"
                    echo -e "${YELLOW}      请确保已安装内核并重启，然后使用选项 3-6 启用${RESET}"
                fi
            fi
            echo ""
            echo -n -e "${CYAN}按回车键返回主菜单...${RESET}"
            read -r
            ;;
        3)
            echo ""
            echo -e "${GREEN}启用 BBR3 + FQ_PIE 加速${RESET}"
            ALGO="bbr3"
            QDISC="fq_pie"
            apply_bbr3_config
            echo ""
            echo -n -e "${CYAN}按回车键返回主菜单...${RESET}"
            read -r
            ;;
        4)
            echo ""
            echo -e "${GREEN}启用 BBR3 + FQ 加速${RESET}"
            ALGO="bbr3"
            QDISC="fq"
            apply_bbr3_config
            echo ""
            echo -n -e "${CYAN}按回车键返回主菜单...${RESET}"
            read -r
            ;;
        5)
            echo ""
            echo -e "${GREEN}启用 BBR3 + FQ_CODEL 加速${RESET}"
            ALGO="bbr3"
            QDISC="fq_codel"
            apply_bbr3_config
            echo ""
            echo -n -e "${CYAN}按回车键返回主菜单...${RESET}"
            read -r
            ;;
        6)
            echo ""
            echo -e "${GREEN}启用 BBR3 + CAKE 加速${RESET}"
            ALGO="bbr3"
            QDISC="cake"
            apply_bbr3_config
            echo ""
            echo -n -e "${CYAN}按回车键返回主菜单...${RESET}"
            read -r
            ;;
        7)
            echo ""
            optimizing_system
            echo ""
            echo -n -e "${CYAN}按回车键返回主菜单...${RESET}"
            read -r
            ;;
        8)
            echo ""
            echo -e "${GREEN}开启 ECN（显式拥塞通知）${RESET}"
            set_ecn 1
            echo ""
            echo -n -e "${CYAN}按回车键返回主菜单...${RESET}"
            read -r
            ;;
        9)
            echo ""
            echo -e "${GREEN}关闭 ECN${RESET}"
            set_ecn 0
            echo ""
            echo -n -e "${CYAN}按回车键返回主菜单...${RESET}"
            read -r
            ;;
        10)
            echo ""
            uninstall_kernel
            echo ""
            echo -n -e "${CYAN}按回车键返回主菜单...${RESET}"
            read -r
            ;;
        *)
            echo ""
            echo -e "${RED}错误：无效的选项，请输入 0-10 之间的数字${RESET}"
            echo ""
            echo -n -e "${CYAN}按回车键返回主菜单...${RESET}"
            read -r
            ;;
    esac
done