raspi-OLED/install.sh

#!/bin/bash
# OLED中文系统监控器安装脚本 - 终极修复版 v2.0（已修复）
# 说明：此脚本基于用户原始脚本全面修复：
#  - 添加 start_step（步骤计数）并自动递增 CURRENT_STEP
#  - 修复 show_progress（百分比、填充条、转轮、颜色、行尾残影）
#  - 保留原有流程、日志、I2C 检测、systemd 服务创建等逻辑
#  - 在脚本中加入中文注释，便于阅读与维护

# ---------------------------
# 颜色定义（ANSI）—— 中文注释
# ---------------------------
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
MAGENTA='\033[0;35m'
CYAN='\033[0;36m'
NC='\033[0m' # No Color

# ---------------------------
# 全局变量 - 终极修复版配置
# ---------------------------
TOTAL_STEPS=18
CURRENT_STEP=0
INSTALL_DIR="/opt/oled_monitor_final"  # 使用新目录避免冲突
SYSTEM_USER="root"
SYSTEM_GROUP="root"
MAIN_PROGRAM="oled_system_monitor_final.py"  # 新的程序文件名
SERVICE_NAME="oled-monitor-final.service"    # 新的服务名
LOG_FILE="install_final.log"

# ---------------------------
# 日志记录函数（中文注释）
# ---------------------------
log_message() {
    local level=$1
    local message=$2
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] [$level] $message" >> "$LOG_FILE"
}

# ---------------------------
# 输出样式函数（中文注释）
# ---------------------------
status_msg() { echo -e "${YELLOW}[*]${NC} $1"; }
success_msg() { echo -e "${GREEN}[✓]${NC} $1"; }
warning_msg() { echo -e "${YELLOW}[!]${NC} $1"; }
error_msg() { echo -e "${RED}[✗]${NC} $1"; }

# ---------------------------
# start_step：统一步骤开始，自动增加 CURRENT_STEP，并打印美观标题
# ---------------------------
start_step() {
    # 增加当前步骤
    CURRENT_STEP=$((CURRENT_STEP + 1))
    # 打印步骤标题，保留中文说明
    echo
    echo -e "${CYAN}────────────────────────────────────────────${NC}"
    echo -e "${MAGENTA}▶️  步骤 ${CURRENT_STEP}/${TOTAL_STEPS}：$1${NC}"
    echo -e "${CYAN}────────────────────────────────────────────${NC}"
    echo
    # 记录到日志
    log_message "INFO" "开始步骤 ${CURRENT_STEP}/${TOTAL_STEPS}：$1"
}

# ---------------------------
# 修正版进度条：show_progress
# 说明：
#  - 参数：当前值 current，总值 total，文本 text（可选）
#  - 避免 %0.s 的错误使用，使用 printf + tr 构造填充
#  - 使用 tput el 清除行尾遗留字符，防止残影
# ---------------------------
show_progress() {
    local current=$1
    local total=$2
    local text=${3:-""}

    # 避免除以0
    if [ "$total" -eq 0 ]; then
        total=1
    fi

    # 计算百分比（整数）
    local percentage=$((current * 100 / total))

    # 进度条长度（可调整）
    local bar_length=50
    local filled_length=$((bar_length * current / total))
    local empty_length=$((bar_length - filled_length))

    # 构造填充和空白部分（使用 printf + tr）
    local filled=$(printf "%${filled_length}s" | tr ' ' '#')
    local empty=$(printf "%${empty_length}s" | tr ' ' '-')

    # 旋转指示符（ASCII，避免 UTF-8 终端问题）
    local spinners='|/-\'
    # 使用 CURRENT_STEP 来驱动转轮更平滑
    local idx=$((CURRENT_STEP % 4))
    local spinner=${spinners:$idx:1}

    # 输出（带颜色），使用 printf 安全替换百分比
    printf "\r${BLUE}[${spinner}]${NC} ${GREEN}%3s%%${NC} [${GREEN}${filled}${NC}${empty}] ${text}" "$percentage"
    # 清除行尾残留字符
    # 如果 tput 不存在，也不会致命，保底
    if command -v tput >/dev/null 2>&1; then
        tput el
    fi
}

# ---------------------------
# 检查 root 权限（中文注释）
# ---------------------------
check_root() {
    if [ "$(id -u)" -ne 0 ]; then
        error_msg "此脚本需要以root用户运行"
        echo -e "${YELLOW}正确命令: sudo -i${NC}"
        echo -e "${YELLOW}然后运行: ./install_final.sh${NC}"
        exit 1
    fi

    echo -e "${YELLOW}⚠️  警告: 您正在使用root用户安装${NC}"
    echo
}

# ---------------------------
# 检查主程序文件（中文注释）
# ---------------------------
check_program_file() {
    if [ ! -f "$MAIN_PROGRAM" ]; then
        error_msg "未找到主程序文件: $MAIN_PROGRAM"
        error_msg "请确保程序文件在当前目录中"
        log_message "ERROR" "主程序文件 $MAIN_PROGRAM 不存在"
        exit 1
    fi

    # 检查文件大小
    file_size=$(stat -c%s "$MAIN_PROGRAM")
    if [ $file_size -lt 1000 ]; then
        warning_msg "程序文件过小，可能不完整: ${file_size} bytes"
        log_message "WARNING" "程序文件过小: ${file_size} bytes"
    fi

    success_msg "找到主程序文件: $MAIN_PROGRAM (${file_size} bytes)"
    log_message "INFO" "找到主程序文件: $MAIN_PROGRAM"
}

# ---------------------------
# 备份旧版本函数（中文注释）
# ---------------------------
backup_old_version() {
    start_step "备份旧版本"

    if [ -d "/opt/oled_monitor" ]; then
        backup_dir="/opt/oled_monitor_backup_$(date +%Y%m%d_%H%M%S)"
        mv /opt/oled_monitor "$backup_dir"
        success_msg "旧版本已备份到: $backup_dir"
        log_message "INFO" "旧版本备份到: $backup_dir"
    else
        status_msg "未找到旧版本，跳过备份"
    fi

    # 停止旧服务（原名）
    if systemctl list-units --full -all | grep -q "oled-monitor.service"; then
        systemctl stop oled-monitor.service > /dev/null 2>&1
        systemctl disable oled-monitor.service > /dev/null 2>&1
        success_msg "旧服务已停止并禁用"
        log_message "INFO" "旧服务已停止并禁用"
    fi

    # 显示进度（当前步骤 / 总步骤）
    show_progress $CURRENT_STEP $TOTAL_STEPS "备份完成"
    echo
}

# ---------------------------
# 主安装函数（中文注释）
# ---------------------------
main() {
    # 初始化日志
    echo "安装日志 - $(date)" > "$LOG_FILE"
    log_message "INFO" "开始安装 OLED中文监控器终极修复版 v2.0"

    clear
    echo -e "${BLUE}=============================================${NC}"
    echo -e "${MAGENTA}     OLED中文系统监控器安装脚本 v2.0${NC}"
    echo -e "${RED}         终极修复版 - Root用户专用${NC}"
    echo -e "${BLUE}=============================================${NC}"
    echo -e "${CYAN}彻底解决draw属性问题 | 完整依赖检查 | 详细日志${NC}"
    echo -e "${CYAN}全新安装目录 | 独立服务名称 | 安装后验证${NC}"
    echo

    # 检查 root
    check_root

    # 检查主程序文件
    check_program_file

    # 显示系统信息
    start_step "系统信息检测"
    status_msg "系统信息检测中..."
    SYSTEM_INFO=$(uname -a)
    echo -e "${YELLOW}  用户:${NC} $SYSTEM_USER (root)"
    echo -e "${YELLOW}  目录:${NC} $INSTALL_DIR"
    echo -e "${YELLOW}  系统:${NC} $SYSTEM_INFO"
    echo -e "${YELLOW}  时间:${NC} $(date)"
    echo -e "${YELLOW}  程序:${NC} $MAIN_PROGRAM"
    echo
    log_message "INFO" "系统信息: $SYSTEM_INFO"
    log_message "INFO" "安装目录: $INSTALL_DIR"
    show_progress $CURRENT_STEP $TOTAL_STEPS "系统信息检测完成"
    echo

    # 确认安装
    read -p "⚠️  确认安装中文监控器终极修复版? (y/n): " -n 1 -r
    echo
    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
        error_msg "安装已取消"
        log_message "INFO" "安装已取消"
        exit 0
    fi

    echo -e "\n${GREEN} 🚀 开始终极修复版安装流程...${NC}"
    echo

    #
    # 步骤 1: 备份旧版本
    #
    backup_old_version

    #
    # 步骤 2: 创建新的安装目录
    #
    start_step "创建全新安装目录"
    status_msg "正在创建目录: $INSTALL_DIR"

    # 确保目录不存在（若存在则清理）
    if [ -d "$INSTALL_DIR" ]; then
        rm -rf "$INSTALL_DIR"
        status_msg "清理旧的安装目录"
        log_message "INFO" "清理旧安装目录: $INSTALL_DIR"
    fi

    mkdir -p "$INSTALL_DIR"
    chmod 755 "$INSTALL_DIR"
    success_msg "全新安装目录创建完成: $INSTALL_DIR"
    log_message "INFO" "创建安装目录: $INSTALL_DIR"
    show_progress $CURRENT_STEP $TOTAL_STEPS "目录创建完成"
    echo

    #
    # 步骤 3: 更新系统包列表
    #
    start_step "更新系统包列表"
    status_msg "正在更新apt包索引..."

    # 使用子进程更新并显示简单进度
    apt-get update -y >> "$LOG_FILE" 2>&1 &
    pid=$!
    counter=0
    while kill -0 $pid 2>/dev/null; do
        counter=$((counter + 1))
        show_progress $CURRENT_STEP $TOTAL_STEPS "正在更新... ${counter}s"
        sleep 1
    done
    wait $pid 2>/dev/null
    if [ $? -eq 0 ]; then
        success_msg "包列表更新完成"
        log_message "INFO" "包列表更新完成"
    else
        warning_msg "包列表更新可能失败，但继续安装"
        log_message "WARNING" "包列表更新可能失败"
    fi
    show_progress $CURRENT_STEP $TOTAL_STEPS "包列表更新完成"
    echo

    #
    # 步骤 4: 安装系统依赖
    #
    start_step "安装系统依赖包"
    status_msg "正在安装必需的系统组件..."

    REQUIRED_PACKAGES="python3 python3-pip python3-pil python3-smbus i2c-tools python3-psutil python3-setuptools python3-wheel"
    apt-get install -y $REQUIRED_PACKAGES >> "$LOG_FILE" 2>&1 &
    pid=$!
    counter=0
    while kill -0 $pid 2>/dev/null; do
        counter=$((counter + 1))
        show_progress $CURRENT_STEP $TOTAL_STEPS "正在安装依赖... ${counter}s"
        sleep 1
    done
    wait $pid 2>/dev/null

    if [ $? -eq 0 ]; then
        success_msg "系统依赖安装完成"
        log_message "INFO" "系统依赖安装完成"
    else
        warning_msg "部分依赖安装可能失败，请检查错误"
        log_message "WARNING" "系统依赖安装可能失败"
    fi
    show_progress $CURRENT_STEP $TOTAL_STEPS "依赖安装完成"
    echo

    #
    # 步骤 5: 安装中文字体
    #
    start_step "安装中文字体支持"
    status_msg "正在安装文泉驿中文字体..."

    apt-get install -y fonts-wqy-zenhei >> "$LOG_FILE" 2>&1 &
    pid=$!
    counter=0
    while kill -0 $pid 2>/dev/null; do
        counter=$((counter + 1))
        show_progress $CURRENT_STEP $TOTAL_STEPS "正在安装字体... ${counter}s"
        sleep 1
    done
    wait $pid 2>/dev/null

    success_msg "中文字体安装完成"
    log_message "INFO" "中文字体安装完成"
    show_progress $CURRENT_STEP $TOTAL_STEPS "字体安装完成"
    echo

    #
    # 步骤 6: 验证中文字体
    #
    start_step "验证中文字体"
    status_msg "检查中文字体是否正确安装..."

    FONT_FILE="/usr/share/fonts/truetype/wqy/wqy-zenhei.ttc"
    if [ -f "$FONT_FILE" ]; then
        success_msg "文泉驿字体安装成功: $FONT_FILE"
        log_message "INFO" "文泉驿字体安装成功"
        ls -la "$FONT_FILE" >> "$LOG_FILE" 2>&1
    else
        warning_msg "文泉驿字体未找到，尝试其他字体..."
        log_message "WARNING" "文泉驿字体未找到"

        # 检查其他中文字体
        OTHER_FONTS=$(find /usr/share/fonts -type f -iname "*.ttc" -o -iname "*.ttf" 2>/dev/null | grep -E "(wqy|song|hei|sim|chinese)" | head -5)
        if [ -n "$OTHER_FONTS" ]; then
            echo -e "${YELLOW}找到其他中文字体:${NC}"
            echo "$OTHER_FONTS"
            log_message "INFO" "找到其他中文字体: $OTHER_FONTS"
        else
            error_msg "未找到任何中文字体，中文显示可能受影响"
            log_message "ERROR" "未找到任何中文字体"
        fi
    fi
    show_progress $CURRENT_STEP $TOTAL_STEPS "字体验证完成"
    echo

    #
    # 步骤 7: 升级 pip 和 setuptools
    #
    start_step "升级Python包管理器"
    status_msg "正在升级pip和setuptools..."

    pip3 install --break-system-packages --upgrade pip setuptools wheel >> "$LOG_FILE" 2>&1 &
    pid=$!
    counter=0
    while kill -0 $pid 2>/dev/null; do
        counter=$((counter + 1))
        show_progress $CURRENT_STEP $TOTAL_STEPS "正在升级... ${counter}s"
        sleep 1
    done
    wait $pid 2>/dev/null

    success_msg "Python包管理器升级完成"
    log_message "INFO" "Python包管理器升级完成"
    show_progress $CURRENT_STEP $TOTAL_STEPS "包管理器升级完成"
    echo

    #
    # 步骤 8: 安装 Adafruit Blinka
    #
    start_step "安装Python依赖库"
    status_msg "正在安装Adafruit Blinka..."

    pip3 install --break-system-packages Adafruit-Blinka >> "$LOG_FILE" 2>&1 &
    pid=$!
    counter=0
    while kill -0 $pid 2>/dev/null; do
        counter=$((counter + 1))
        show_progress $CURRENT_STEP $TOTAL_STEPS "正在安装Blinka... ${counter}s"
        sleep 1
    done
    wait $pid 2>/dev/null

    success_msg "Adafruit Blinka安装完成"
    log_message "INFO" "Adafruit Blinka安装完成"
    show_progress $CURRENT_STEP $TOTAL_STEPS "Blinka安装完成"
    echo

    #
    # 步骤 9: 安装 SSD1306 驱动
    #
    start_step "安装SSD1306驱动库"
    status_msg "正在安装OLED驱动..."

    pip3 install --break-system-packages adafruit-circuitpython-ssd1306 >> "$LOG_FILE" 2>&1 &
    pid=$!
    counter=0
    while kill -0 $pid 2>/dev/null; do
        counter=$((counter + 1))
        show_progress $CURRENT_STEP $TOTAL_STEPS "正在安装SSD1306... ${counter}s"
        sleep 1
    done
    wait $pid 2>/dev/null

    success_msg "SSD1306驱动安装完成"
    log_message "INFO" "SSD1306驱动安装完成"
    show_progress $CURRENT_STEP $TOTAL_STEPS "驱动安装完成"
    echo

    # #
    # # 步骤 10: 强制重新安装 Pillow（中文显示必需）
    # #
    # start_step "强制安装Pillow库"
    # status_msg "正在重新安装Pillow库（中文显示必需）..."

    # pip3 uninstall -y pillow >> "$LOG_FILE" 2>&1 || true
    # pip3 install --break-system-packages --force-reinstall pillow >> "$LOG_FILE" 2>&1 &
    # pid=$!
    # counter=0
    # while kill -0 $pid 2>/dev/null; do
    #     counter=$((counter + 1))
    #     show_progress $CURRENT_STEP $TOTAL_STEPS "正在安装Pillow... ${counter}s"
    #     sleep 1
    # done
    # wait $pid 2>/dev/null

    # success_msg "Pillow库强制安装完成"
    # log_message "INFO" "Pillow库强制安装完成"
    # show_progress $CURRENT_STEP $TOTAL_STEPS "Pillow安装完成"
    # echo
    #
    # 步骤 10: 检查并安装 Pillow（中文显示依赖）
    #
    start_step "检查 Pillow 库（中文显示依赖）"
    status_msg "正在检测系统中是否已安装 Pillow 库..."

    # 检查 Pillow 是否存在
    if python3 -c "import PIL" &>/dev/null; then
        success_msg "系统已安装 Pillow 库，跳过安装"
        log_message "INFO" "Pillow 已存在，跳过安装"
        show_progress $CURRENT_STEP $TOTAL_STEPS "Pillow 已存在，跳过"
    else
        warn_msg "未检测到 Pillow 库，开始安装..."
        log_message "INFO" "开始安装 Pillow 库"
        (
            pip3 install --break-system-packages --upgrade pillow >> "$LOG_FILE" 2>&1
        ) &
        pid=$!
        counter=0
        while kill -0 $pid 2>/dev/null; do
            counter=$((counter + 1))
            show_progress $CURRENT_STEP $TOTAL_STEPS "正在安装 Pillow... ${counter}s"
            sleep 1
        done
        wait $pid 2>/dev/null

        if python3 -c "import PIL" &>/dev/null; then
            success_msg "Pillow 库安装完成"
            log_message "INFO" "Pillow 安装成功"
            show_progress $CURRENT_STEP $TOTAL_STEPS "Pillow 安装完成"
        else
            error_msg "Pillow 安装失败，请检查日志"
            log_message "ERROR" "Pillow 安装失败"
        fi
    fi

    echo

    #
    # 步骤 11: 启用 I2C 接口
    #
    start_step "配置I2C接口"
    status_msg "正在启用并配置I2C接口..."

    # 尝试使用 raspi-config 非交互方式启用 I2C（若可用）
    if command -v raspi-config >/dev/null 2>&1; then
        raspi-config nonint do_i2c 0 >> "$LOG_FILE" 2>&1 || true
    fi

    # 加载 I2C 模块（兼容性处理）
    modprobe i2c-dev >> "$LOG_FILE" 2>&1 || true
    modprobe i2c-bcm2835 >> "$LOG_FILE" 2>&1 || true

    # 确保 /etc/modules 包含 i2c 模块（避免重复写入）
    if ! grep -q '^i2c-dev' /etc/modules 2>/dev/null; then
        echo "i2c-dev" >> /etc/modules
    fi
    if ! grep -q '^i2c-bcm2835' /etc/modules 2>/dev/null; then
        echo "i2c-bcm2835" >> /etc/modules
    fi

    # 更新 config.txt（只追加一次）
    if ! grep -q '^dtparam=i2c_arm=on' /boot/config.txt 2>/dev/null; then
        echo "dtparam=i2c_arm=on,i2c_arm_baudrate=400000" >> /boot/config.txt
    fi

    sleep 2
    success_msg "I2C接口配置完成"
    log_message "INFO" "I2C接口配置完成"
    show_progress $CURRENT_STEP $TOTAL_STEPS "I2C配置完成"
    echo

    #
    # 步骤 12: 检测 I2C 设备
    #
    start_step "检测I2C设备"
    status_msg "正在扫描I2C总线..."
    echo -e "${YELLOW}I2C设备列表:${NC}"
    i2cdetect -y 1 | tee -a "$LOG_FILE" 2>&1

    # 检查 OLED 设备地址（3c 或 3d）
    OLED_FOUND=$(i2cdetect -y 1 | grep -E "(3c|3d)" || true)
    if [ -n "$OLED_FOUND" ]; then
        success_msg "✅ 检测到OLED设备: $OLED_FOUND"
        log_message "INFO" "检测到OLED设备: $OLED_FOUND"
    else
        error_msg "❌ 未检测到OLED设备"
        error_msg "请检查OLED屏幕接线和电源"
        log_message "ERROR" "未检测到OLED设备"

        # 显示接线提示（中文）
        echo -e "${CYAN}接线提示:${NC}"
        echo -e "  VCC -> 3.3V (Pin 1)"
        echo -e "  GND -> GND (Pin 6)"
        echo -e "  SDA -> SDA (Pin 3)"
        echo -e "  SCL -> SCL (Pin 5)"
        echo

        read -p "⚠️  确认继续安装? (y/n): " -n 1 -r
        echo
        if [[ ! $REPLY =~ ^[Yy]$ ]]; then
            error_msg "安装已取消"
            log_message "INFO" "用户取消安装"
            exit 0
        fi
    fi
    show_progress $CURRENT_STEP $TOTAL_STEPS "I2C检测完成"
    echo

    #
    # 步骤 13: 复制程序文件到安装目录
    #
    start_step "部署程序文件"
    status_msg "正在复制终极修复版程序..."

    cp "$MAIN_PROGRAM" "$INSTALL_DIR/" 2>>"$LOG_FILE" || abort "复制主程序失败，请检查权限"
    chmod 755 "$INSTALL_DIR/$MAIN_PROGRAM"

    # 创建配置 & 日志目录
    mkdir -p "$INSTALL_DIR/config"
    chmod 755 "$INSTALL_DIR/config"
    mkdir -p "$INSTALL_DIR/logs"
    chmod 755 "$INSTALL_DIR/logs"

    success_msg "程序文件部署完成"
    log_message "INFO" "程序文件部署完成"

    echo -e "${YELLOW}文件列表:${NC}"
    ls -la "$INSTALL_DIR/" | tee -a "$LOG_FILE"
    show_progress $CURRENT_STEP $TOTAL_STEPS "文件部署完成"
    echo

    #
    # 步骤 14: 设置权限
    #
    start_step "设置系统权限"
    status_msg "正在配置文件权限..."

    chown -R "$SYSTEM_USER:$SYSTEM_GROUP" "$INSTALL_DIR"
    chmod -R 755 "$INSTALL_DIR"

    # 设置日志文件权限
    touch "$INSTALL_DIR/logs/monitor.log"
    chmod 644 "$INSTALL_DIR/logs/monitor.log"
    chown "$SYSTEM_USER:$SYSTEM_GROUP" "$INSTALL_DIR/logs/monitor.log"

    # 验证权限并列出
    echo -e "${YELLOW}权限验证:${NC}"
    ls -ld "$INSTALL_DIR"
    ls -la "$INSTALL_DIR/$MAIN_PROGRAM"

    success_msg "权限设置完成"
    log_message "INFO" "权限设置完成"
    show_progress $CURRENT_STEP $TOTAL_STEPS "权限配置完成"
    echo

    #
    # 步骤 15: 创建 systemd 服务（终极修复版）
    #
    start_step "创建系统服务"
    status_msg "正在配置systemd服务..."

    cat > "/etc/systemd/system/$SERVICE_NAME" << EOF
[Unit]
Description=OLED中文系统监控器（终极修复版）
After=network.target i2c-dev.service systemd-modules-load.service
Wants=i2c-dev.service

[Service]
Type=simple
User=$SYSTEM_USER
Group=$SYSTEM_GROUP
WorkingDirectory=$INSTALL_DIR
ExecStart=/usr/bin/python3 $INSTALL_DIR/$MAIN_PROGRAM >> $INSTALL_DIR/logs/monitor.log 2>&1
Restart=always
RestartSec=10
Environment="PYTHONPATH=/usr/local/lib/python3.9/dist-packages:/usr/lib/python3/dist-packages"
Environment="PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
# 终极修复版特殊配置
ExecStartPre=/bin/sleep 5
ExecStartPre=/bin/chmod 755 $INSTALL_DIR/$MAIN_PROGRAM
ExecStartPre=/bin/bash -c "modprobe i2c-dev; modprobe i2c-bcm2835"

[Install]
WantedBy=multi-user.target
EOF

    # 重新加载 systemd 单元
    systemctl daemon-reload
    success_msg "系统服务创建完成"
    log_message "INFO" "系统服务创建完成"
    show_progress $CURRENT_STEP $TOTAL_STEPS "服务创建完成"
    echo

    #
    # 步骤 16: 启动服务并测试
    #
    start_step "启动并测试服务"
    status_msg "正在启动终极修复版监控器服务..."

    # 尝试停止同名服务（以防重复）
    systemctl stop "$SERVICE_NAME" > /dev/null 2>&1 || true

    # 启用并启动服务
    systemctl enable "$SERVICE_NAME" >> "$LOG_FILE" 2>&1
    systemctl start "$SERVICE_NAME" >> "$LOG_FILE" 2>&1 || true

    # 等待一段时间观察服务是否启动
    echo -e "${YELLOW}等待服务启动...${NC}"
    for i in {1..10}; do
        show_progress $CURRENT_STEP $TOTAL_STEPS "服务启动中... ${i}s"
        sleep 1
    done
    echo

    # 检查服务状态
    if systemctl is-active --quiet "$SERVICE_NAME"; then
        success_msg "🎉 终极修复版服务启动成功！"
        log_message "INFO" "服务启动成功"

        # 显示服务信息（短）
        echo -e "${CYAN}服务信息:${NC}"
        systemctl status "$SERVICE_NAME" --no-pager -l | sed -n '1,10p'
        echo

        # 显示实时日志（前10行）
        echo -e "\n${CYAN}实时日志（前10行）:${NC}"
        tail -n 10 "$INSTALL_DIR/logs/monitor.log"
    else
        error_msg "服务启动失败"
        log_message "ERROR" "服务启动失败"

        echo -e "${YELLOW}错误日志（journalctl 末尾）:${NC}"
        journalctl -u "$SERVICE_NAME" --no-pager -n 20

        echo -e "${YELLOW}监控器日志:${NC}"
        if [ -f "$INSTALL_DIR/logs/monitor.log" ]; then
            tail -n 20 "$INSTALL_DIR/logs/monitor.log"
        fi

        warning_msg "请检查错误日志并重新安装"
    fi
    show_progress $CURRENT_STEP $TOTAL_STEPS "服务启动完成"
    echo

    #
    # 安装后验证（附加检查）
    #
    start_step "安装后验证"
    status_msg "正在验证安装结果..."

    PROCESS_COUNT=$(ps aux | grep "$MAIN_PROGRAM" | grep -v grep | wc -l)
    if [ "$PROCESS_COUNT" -gt 0 ]; then
        success_msg "✅ 程序正在运行，进程数: $PROCESS_COUNT"
        log_message "INFO" "程序正在运行，进程数: $PROCESS_COUNT"

        echo -e "${YELLOW}运行中的进程:${NC}"
        ps aux | grep "$MAIN_PROGRAM" | grep -v grep
    else
        warning_msg "⚠️ 未检测到运行中的程序进程"
        log_message "WARNING" "未检测到运行中的程序进程"
    fi

    # 检查文件完整性
    if [ -f "$INSTALL_DIR/$MAIN_PROGRAM" ]; then
        file_size=$(stat -c%s "$INSTALL_DIR/$MAIN_PROGRAM")
        success_msg "✅ 程序文件完整: ${file_size} bytes"
        log_message "INFO" "程序文件完整: ${file_size} bytes"
    else
        error_msg "❌ 程序文件缺失"
        log_message "ERROR" "程序文件缺失"
    fi

    show_progress $CURRENT_STEP $TOTAL_STEPS "安装验证完成"
    echo

    # 最终完成提示
    echo -e "\n\n${GREEN}=============================================${NC}"
    echo -e "${MAGENTA}🎉 OLED中文监控器终极修复版安装完成！${NC}"
    echo -e "${GREEN}=============================================${NC}"
    echo
    echo -e "${YELLOW}📊 安装统计:${NC}"
    echo -e "   总步骤: $TOTAL_STEPS"
    echo -e "   完成率: 100%"
    echo -e "   安装目录: $INSTALL_DIR"
    echo -e "   主程序: $MAIN_PROGRAM"
    echo -e "   服务名称: $SERVICE_NAME"
    echo -e "   日志文件: $LOG_FILE"
    echo
    echo -e "${CYAN}🔧 管理命令:${NC}"
    echo -e "   📖 查看日志: journalctl -u $SERVICE_NAME -f"
    echo -e "   📖 程序日志: tail -f $INSTALL_DIR/logs/monitor.log"
    echo -e "   🛑 停止服务: systemctl stop $SERVICE_NAME"
    echo -e "   🔁 重启服务: systemctl restart $SERVICE_NAME"
    echo -e "   📊 查看状态: systemctl status $SERVICE_NAME"
    echo -e "   📁 程序目录: cd $INSTALL_DIR && ls -la"
    echo -e "   🧪 测试运行: cd $INSTALL_DIR && python3 $MAIN_PROGRAM"
    echo
    echo -e "${YELLOW}💡 终极修复特色:${NC}"
    echo -e "   - 彻底解决draw属性初始化问题"
    echo -e "   - 多层备用机制确保稳定运行"
    echo -e "   - 详细的调试日志和错误处理"
    echo -e "   - 智能I2C地址检测"
    echo -e "   - 自动字体安装和验证"
    echo -e "   - 全新的安装目录避免冲突"
    echo
    echo -e "${RED}⚠️  重要提醒:${NC}"
    echo -e "   - 如果服务启动失败，请查看详细日志"
    echo -e "   - 安装日志已保存到: $LOG_FILE"
    echo -e "   - 程序日志已保存到: $INSTALL_DIR/logs/monitor.log"
    echo -e "   - OLED屏幕应显示中文监控信息"
    echo -e "   - 如有问题请提供完整日志文件"
    echo
    echo -e "${GREEN}=============================================${NC}"
    echo -e "${MAGENTA}终极修复版安装完成！祝您使用愉快！${NC}"
    echo -e "${GREEN}=============================================${NC}"

    log_message "INFO" "终极修复版安装完成"
}

# ---------------------------
# 帮助函数：在必要处退出并记录日志
# ---------------------------
abort() {
    echo -e "${RED}安装中遇到致命错误：$1${NC}"
    log_message "ERROR" "$1"
    exit 1
}

# 启动主函数
main