#!/bin/bash
#===============================================================================
# 脚本名称: mount_disk.sh
# 描述: Linux 磁盘自动挂载脚本_By豆芽
#       支持标准分区模式(单盘)和 LVM 模式(多盘合并)
# 用法: sudo bash mount_disk.sh
#===============================================================================

set -euo pipefail

#===============================================================================
# 颜色定义
#===============================================================================
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[0;31m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
NC='\033[0m' # No Color

#===============================================================================
# 日志函数
#===============================================================================
log_info()    { echo -e "${GREEN}[INFO]${NC} $*"; }
log_warn()    { echo -e "${YELLOW}[WARN]${NC} $*"; }
log_error()   { echo -e "${RED}[ERROR]${NC} $*"; }
log_step()    { echo -e "${BLUE}[STEP]${NC} $*"; }
log_detail()  { echo -e "${CYAN}  -->  ${NC} $*"; }

#===============================================================================
# 安全检查
#===============================================================================
check_root() {
    if [[ $EUID -ne 0 ]]; then
        log_error "此脚本需要 root 权限运行，请使用 sudo 执行"
        exit 1
    fi
}

check_os() {
    if [[ ! -f /etc/os-release ]]; then
        log_error "无法识别操作系统，仅支持 Linux 系统"
        exit 1
    fi
}

check_commands() {
    local missing=()
    for cmd in lsblk blkid parted mkfs.ext4 mount; do
        if ! command -v "$cmd" &>/dev/null; then
            missing+=("$cmd")
        fi
    done
    if [[ ${#missing[@]} -gt 0 ]]; then
        log_error "缺少必要的命令: ${missing[*]}"
        log_error "请先安装相关工具包"
        exit 1
    fi
}

#===============================================================================
# 获取系统盘列表（包含系统分区、引导分区、swap 等所有相关磁盘）
#===============================================================================
get_system_disks() {
    local sys_disks=()

    # 方法1: 通过挂载点识别 (/, /boot, /boot/efi 等关键挂载点)
    while IFS= read -r line; do
        local disk
        disk=$(echo "$line" | awk '{print $1}')
        # 跳过 LVM mapper 设备（交给方法 2 处理，避免误追踪多 PV）
        [[ "$disk" == /dev/mapper/* || "$disk" == /dev/dm-* ]] && continue
        # 获取磁盘的父设备（即物理磁盘）
        local parent
        parent=$(lsblk -ndo PKNAME "$disk" 2>/dev/null || true)
        if [[ -n "$parent" ]]; then
            sys_disks+=("/dev/$parent")
        fi
    done < <(findmnt -n -o SOURCE,TARGET / /boot /boot/efi 2>/dev/null || true)

    # 方法2: 通过 root 设备识别
    local root_dev
    root_dev=$(findmnt -n -o SOURCE / 2>/dev/null || true)
    if [[ -n "$root_dev" ]]; then
        # 处理 LVM 的情况
        if [[ "$root_dev" == /dev/mapper/* ]]; then
            # 根目录是 LVM：仅将 /boot 所在磁盘认定为系统盘
            # 而不是追踪 VG 内所有 PV（VG 可能跨多盘，其他盘不一定是"系统盘"）
            local boot_dev
            boot_dev=$(findmnt -n -o SOURCE /boot 2>/dev/null || true)
            if [[ -n "$boot_dev" ]]; then
                local boot_parent
                boot_parent=$(lsblk -ndo PKNAME "$boot_dev" 2>/dev/null || true)
                if [[ -n "$boot_parent" ]]; then
                    sys_disks+=("/dev/$boot_parent")
                fi
            fi
            # 如果没有单独的 /boot 分区，通过 PV 反查：
            # 只取第一个 PV 所在的物理磁盘作为系统盘（通常是安装时的原始系统盘）
            if [[ ${#sys_disks[@]} -eq 0 ]]; then
                local vg_name
                vg_name=$(lvs --noheadings -o vg_name "$root_dev" 2>/dev/null | tr -d ' ' || true)
                if [[ -n "$vg_name" ]]; then
                    local first_pv
                    first_pv=$(pvs --noheadings -o pv_name -S "vg_name=$vg_name" 2>/dev/null | head -1 | tr -d ' ')
                    if [[ -n "$first_pv" ]]; then
                        local pv_parent
                        pv_parent=$(lsblk -ndo PKNAME "$first_pv" 2>/dev/null || true)
                        if [[ -n "$pv_parent" ]]; then
                            sys_disks+=("/dev/$pv_parent")
                        else
                            # PV 是整盘（无分区），取 PV 设备名去掉尾部数字
                            local pv_disk
                            pv_disk=$(echo "$first_pv" | sed 's/[0-9]*$//')
                            sys_disks+=("$pv_disk")
                        fi
                    fi
                fi
            fi
        else
            local parent
            parent=$(lsblk -ndo PKNAME "$root_dev" 2>/dev/null || true)
            if [[ -n "$parent" ]]; then
                sys_disks+=("/dev/$parent")
            fi
        fi
    fi

    # 方法3: 通过 swap 分区识别
    while IFS= read -r swap_dev; do
        if [[ -n "$swap_dev" && "$swap_dev" != "NAME" ]]; then
            local parent
            parent=$(lsblk -ndo PKNAME "/dev/$swap_dev" 2>/dev/null || true)
            if [[ -n "$parent" ]]; then
                sys_disks+=("/dev/$parent")
            fi
        fi
    done < <(swapon --show=NAME --noheadings 2>/dev/null | xargs -I{} basename {} || true)

    # 方法4: 通过 /etc/fstab 中的条目识别
    while IFS= read -r fstab_dev; do
        # 跳过 LVM mapper 条目（避免追踪 VG 所有 PV 导致误判）
        [[ "$fstab_dev" == /dev/mapper/* ]] && continue
        if [[ "$fstab_dev" == UUID=* ]]; then
            local uuid="${fstab_dev#UUID=}"
            local dev
            dev=$(blkid -U "$uuid" 2>/dev/null || true)
            if [[ -n "$dev" ]]; then
                # 跳过 LVM 设备
                [[ "$dev" == /dev/mapper/* || "$dev" == /dev/dm-* ]] && continue
                local parent
                parent=$(lsblk -ndo PKNAME "$dev" 2>/dev/null || true)
                if [[ -n "$parent" ]]; then
                    sys_disks+=("/dev/$parent")
                fi
            fi
        elif [[ "$fstab_dev" == /dev/* ]]; then
            local parent
            parent=$(lsblk -ndo PKNAME "$fstab_dev" 2>/dev/null || true)
            if [[ -n "$parent" ]]; then
                sys_disks+=("/dev/$parent")
            fi
        fi
    done < <(awk '!/^#/ && NF>=2 {print $1}' /etc/fstab 2>/dev/null || true)

    # 去重并输出
    printf '%s\n' "${sys_disks[@]}" | sort -u
}

#===============================================================================
# 获取空闲磁盘（排除系统盘、已挂载盘、CD-ROM 等）
#===============================================================================
get_free_disks() {
    local -a sys_disks_arr
    mapfile -t sys_disks_arr < <(get_system_disks)

    local -a free_disks=()

    while IFS= read -r disk; do
        local disk_path="/dev/$disk"
        local is_system=false

        # 检查是否是系统盘
        for sd in "${sys_disks_arr[@]}"; do
            if [[ "$disk_path" == "$sd" ]]; then
                is_system=true
                break
            fi
        done
        [[ "$is_system" == true ]] && continue

        # 排除 CD-ROM / loop 设备 / 只读设备
        local disk_type
        disk_type=$(lsblk -ndo TYPE "$disk_path" 2>/dev/null || true)
        [[ "$disk_type" == "rom" || "$disk_type" == "loop" ]] && continue

        local ro
        ro=$(lsblk -ndo RO "$disk_path" 2>/dev/null || true)
        [[ "$ro" == "1" ]] && continue

        # 排除大小为 0 的磁盘
        local size
        size=$(lsblk -ndo SIZE -b "$disk_path" 2>/dev/null || true)
        [[ -z "$size" || "$size" == "0" ]] && continue

        # 检查磁盘上是否有直接挂载的物理分区
        # 注意：只检查 disk/part 类型的挂载点，忽略 lvm 类型的设备
        # 因为一块磁盘可能作为 LVM PV 被加入了某个 VG，lsblk 会在其下
        # 显示 lvm 类型设备及其挂载点，不应据此判断磁盘"被占用"
        local has_direct_mount=false
        while IFS= read -r child_line; do
            local child_type child_mount
            child_type=$(echo "$child_line" | awk '{print $1}')
            child_mount=$(echo "$child_line" | awk '{$1=""; print}' | sed 's/^[[:space:]]*//')
            # 只有 disk 或 part 类型有直接挂载点才算被占用
            if [[ ("$child_type" == "disk" || "$child_type" == "part") && -n "$child_mount" ]]; then
                has_direct_mount=true
                break
            fi
        done < <(lsblk -nlo TYPE,MOUNTPOINT "$disk_path" 2>/dev/null || true)
        if [[ "$has_direct_mount" == true ]]; then
            continue
        fi

        free_disks+=("$disk_path")
    done < <(lsblk -ndo NAME,TYPE 2>/dev/null | awk '$2=="disk" {print $1}')

    printf '%s\n' "${free_disks[@]}"
}

#===============================================================================
# 显示磁盘信息
#===============================================================================
show_disk_info() {
    local disk="$1"
    local size
    size=$(lsblk -ndo SIZE "$disk" 2>/dev/null || echo "未知")
    local model
    model=$(lsblk -ndo MODEL "$disk" 2>/dev/null | sed 's/^[[:space:]]*//;s/[[:space:]]*$//' || echo "未知")
    local serial
    serial=$(lsblk -ndo SERIAL "$disk" 2>/dev/null | sed 's/^[[:space:]]*//;s/[[:space:]]*$//' || echo "未知")

    echo -e "    磁盘: ${CYAN}${disk}${NC}  大小: ${GREEN}${size}${NC}  型号: ${model}  序列号: ${serial}"
}

#===============================================================================
# 确认操作（安全二次确认）
#===============================================================================
confirm_action() {
    local msg="$1"
    local confirm_word="${2:-yes}"

    echo ""
    log_warn "$msg"
    log_warn "此操作将 ${RED}清除${NC} 磁盘上的所有数据！"
    echo -e "${YELLOW}请输入 '${confirm_word}' 确认操作（输入其他内容取消）:${NC} "
    read -r input
    if [[ "$input" != "$confirm_word" ]]; then
        log_info "操作已取消"
        exit 0
    fi
}

#===============================================================================
# 检查磁盘是否有数据（额外安全检查）
#===============================================================================
check_disk_has_data() {
    local disk="$1"

    # 检查是否有分区表
    local has_parts
    has_parts=$(lsblk -nlo NAME "$disk" 2>/dev/null | wc -l)
    if [[ "$has_parts" -gt 1 ]]; then
        return 0  # 有分区，说明可能有数据
    fi

    # 检查是否有文件系统签名
    local fs_type
    fs_type=$(blkid -o value -s TYPE "$disk" 2>/dev/null || true)
    if [[ -n "$fs_type" ]]; then
        return 0  # 有文件系统，说明可能有数据
    fi

    return 1  # 无数据
}

#===============================================================================
# 清除磁盘上的所有已有分区和残留（LVM PV/VG、MD RAID、文件系统签名等）
#===============================================================================
clean_existing_partitions() {
    local disk="$1"

    log_detail "检查磁盘 ${disk} 上的已有分区..."

    # 获取磁盘上的所有分区设备路径
    local -a parts=()
    while IFS= read -r pname; do
        [[ -z "$pname" ]] && continue
        parts+=("/dev/$pname")
    done < <(lsblk -nlo NAME,TYPE "$disk" 2>/dev/null | awk '$2=="part" {print $1}')

    if [[ ${#parts[@]} -gt 0 ]]; then
        log_detail "发现 ${#parts[@]} 个已有分区，正在清除..."

        for part in "${parts[@]}"; do
            # 如果分区已被挂载，先卸载
            if findmnt -n "$part" &>/dev/null; then
                log_detail "  卸载分区: ${part}"
                umount -f "$part" 2>/dev/null || true
            fi

            # 如果分区是 swap，先关闭
            if swapon --show=NAME --noheadings 2>/dev/null | grep -qF "$part"; then
                log_detail "  关闭 swap: ${part}"
                swapoff "$part" 2>/dev/null || true
            fi

            # 检查是否是 LVM PV，若是则清理 VG/PV
            if command -v pvs &>/dev/null && pvs "$part" &>/dev/null 2>&1; then
                local vg
                vg=$(pvs --noheadings -o vg_name "$part" 2>/dev/null | tr -d ' ')
                if [[ -n "$vg" ]]; then
                    # 安全守护：检查该 VG 是否包含正在使用的 LV（如根分区）
                    local vg_has_active_mount=false
                    while IFS= read -r lv_path; do
                        [[ -z "$lv_path" ]] && continue
                        if findmnt -n "$lv_path" &>/dev/null; then
                            vg_has_active_mount=true
                            break
                        fi
                    done < <(lvs --noheadings -o lv_path -S "vg_name=$vg" 2>/dev/null | tr -d ' ')

                    if [[ "$vg_has_active_mount" == true ]]; then
                        log_warn "  VG '${vg}' 包含正在使用的活动 LV（可能是根分区），跳过 VG 操作"
                        log_warn "  仅从 VG 中移除 PV: ${part}"
                        vgreduce --force "$vg" "$part" 2>/dev/null || true
                    else
                        log_detail "  停用并移除 LVM VG: ${vg} (来自 ${part})"
                        lvchange -an "$vg" 2>/dev/null || true
                        # 检查该 VG 的所有 PV 是否都在当前磁盘上，避免误删其他磁盘的 VG
                        local vg_pv_count
                        vg_pv_count=$(pvs --noheadings -o pv_name -S "vg_name=$vg" 2>/dev/null | wc -l)
                        local vg_pv_on_disk
                        vg_pv_on_disk=$(pvs --noheadings -o pv_name -S "vg_name=$vg" 2>/dev/null | grep -c "$disk" || true)
                        if [[ "$vg_pv_count" -eq "$vg_pv_on_disk" ]]; then
                            vgremove -f "$vg" 2>/dev/null || true
                        else
                            log_warn "  VG '${vg}' 包含其他磁盘的 PV，仅从中移除 ${part}"
                            vgreduce "$vg" "$part" 2>/dev/null || true
                        fi
                    fi
                fi
                pvremove -f "$part" 2>/dev/null || true
            fi

            # 检查是否是 MD RAID 成员
            if command -v mdadm &>/dev/null && mdadm --examine "$part" &>/dev/null 2>&1; then
                log_detail "  清除 MD RAID 超级块: ${part}"
                # 尝试停止关联的 RAID 阵列
                local md_dev
                md_dev=$(mdadm --examine "$part" 2>/dev/null | awk '/Array UUID/ || /MD_DEVNAME/ {print $NF}' | head -1)
                if [[ -n "$md_dev" ]]; then
                    mdadm --stop "/dev/md/$md_dev" 2>/dev/null || true
                fi
                mdadm --zero-superblock "$part" 2>/dev/null || true
            fi

            # 清除分区上的文件系统签名
            wipefs -a "$part" 2>/dev/null || true
        done
    else
        log_detail "磁盘 ${disk} 无已有分区"
    fi

    # 检查整个磁盘级别的 LVM PV（无分区直接使用整盘做 PV 的情况）
    if command -v pvs &>/dev/null && pvs "$disk" &>/dev/null 2>&1; then
        local vg
        vg=$(pvs --noheadings -o vg_name "$disk" 2>/dev/null | tr -d ' ')
        if [[ -n "$vg" ]]; then
            # 安全守护：检查该 VG 是否包含正在使用的活动 LV
            local vg_has_active_mount=false
            while IFS= read -r lv_path; do
                [[ -z "$lv_path" ]] && continue
                if findmnt -n "$lv_path" &>/dev/null; then
                    vg_has_active_mount=true
                    break
                fi
            done < <(lvs --noheadings -o lv_path -S "vg_name=$vg" 2>/dev/null | tr -d ' ')

            if [[ "$vg_has_active_mount" == true ]]; then
                log_warn "  VG '${vg}' 包含正在使用的活动 LV（可能是根分区），跳过 VG 操作"
                log_warn "  仅从 VG 中移除整盘 PV: ${disk}"
                vgreduce --force "$vg" "$disk" 2>/dev/null || true
            else
                log_detail "  整盘作为 LVM PV，清理 VG: ${vg}"
                lvchange -an "$vg" 2>/dev/null || true
                vgremove -f "$vg" 2>/dev/null || true
            fi
        fi
        pvremove -f "$disk" 2>/dev/null || true
    fi

    # 删除所有分区 - 优先使用 sgdisk，回退到 parted
    if command -v sgdisk &>/dev/null; then
        log_detail "使用 sgdisk 清除分区表..."
        sgdisk --zap-all "$disk" 2>/dev/null || true
    else
        log_detail "使用 parted 清除分区表..."
        local part_nums
        part_nums=$(parted -s "$disk" print 2>/dev/null | awk '/^ *[0-9]/ {print $1}' | sort -rn || true)
        for num in $part_nums; do
            parted -s "$disk" rm "$num" 2>/dev/null || true
        done
    fi

    # 清除整个磁盘的签名和前后区域
    wipefs -a "$disk" 2>/dev/null || true
    dd if=/dev/zero of="$disk" bs=1M count=10 status=none 2>/dev/null || true

    # 通知内核重新读取分区表
    partprobe "$disk" 2>/dev/null || true
    sleep 1

    log_detail "磁盘 ${disk} 清理完成"
}

#===============================================================================
# 标准分区模式 - 挂载单个磁盘
#===============================================================================
standard_partition_mount() {
    local disk="$1"
    local mount_point="$2"
    local fs_type="${3:-ext4}"

    log_step "开始标准分区模式挂载: ${disk} -> ${mount_point}"

    # 安全检查：确保不是系统盘
    local -a sys_disks_arr
    mapfile -t sys_disks_arr < <(get_system_disks)
    for sd in "${sys_disks_arr[@]}"; do
        if [[ "$disk" == "$sd" ]]; then
            log_error "安全阻止: ${disk} 是系统盘，禁止操作！"
            exit 1
        fi
    done

    # 检查磁盘是否有数据并提醒
    if check_disk_has_data "$disk"; then
        log_warn "磁盘 ${disk} 上检测到已有分区或数据"
        confirm_action "确认要格式化磁盘 ${disk} 吗？" "yes"
    fi

    # 1. 清除已有分区、LVM、RAID 残留和文件系统签名
    clean_existing_partitions "$disk"

    # 2. 创建分区表和分区
    log_detail "创建 GPT 分区表..."
    parted -s "$disk" mklabel gpt

    log_detail "创建分区..."
    parted -s "$disk" mkpart primary "$fs_type" 0% 100%

    # 等待内核识别新分区
    partprobe "$disk" 2>/dev/null || true
    sleep 2

    # 获取新创建的分区名
    local partition
    partition=$(lsblk -nlo NAME "$disk" | tail -1)
    partition="/dev/$partition"

    if [[ "$partition" == "$disk" ]]; then
        # 某些命名方式可能不同 (nvme 等)
        if [[ "$disk" == *nvme* || "$disk" == *loop* ]]; then
            partition="${disk}p1"
        else
            partition="${disk}1"
        fi
    fi

    # 3. 格式化分区
    log_detail "格式化分区为 ${fs_type}..."
    case "$fs_type" in
        ext4)
            mkfs.ext4 -F "$partition"
            ;;
        xfs)
            mkfs.xfs -f "$partition"
            ;;
        *)
            log_error "不支持的文件系统类型: ${fs_type}"
            exit 1
            ;;
    esac

    # 4. 创建挂载点
    log_detail "创建挂载点: ${mount_point}"
    mkdir -p "$mount_point"

    # 5. 挂载分区
    log_detail "挂载分区..."
    mount "$partition" "$mount_point"

    # 6. 获取 UUID 并写入 fstab
    local uuid
    uuid=$(blkid -o value -s UUID "$partition")
    if [[ -n "$uuid" ]]; then
        # 备份 fstab
        cp /etc/fstab /etc/fstab.bak.$(date +%Y%m%d%H%M%S)
        log_detail "已备份 /etc/fstab"

        # 检查是否已存在相同 UUID 的条目
        if ! grep -q "UUID=${uuid}" /etc/fstab; then
            echo "UUID=${uuid}  ${mount_point}  ${fs_type}  defaults,noatime  0  2" >> /etc/fstab
            log_detail "已写入 /etc/fstab，开机自动挂载"
        else
            log_warn "fstab 中已存在 UUID=${uuid} 的条目，跳过写入"
        fi
    fi

    log_info "标准分区挂载完成!"
    log_info "  磁盘: ${disk}"
    log_info "  分区: ${partition}"
    log_info "  挂载点: ${mount_point}"
    log_info "  文件系统: ${fs_type}"
    log_info "  UUID: ${uuid:-未知}"
    echo ""
    df -h "$mount_point"
}

#===============================================================================
# LVM 模式 - 多磁盘合并挂载
#===============================================================================
lvm_mount() {
    local mount_point="$1"
    shift
    local -a disks=("$@")
    local fs_type="ext4"
    local vg_name="vg_data"
    local lv_name="lv_data"

    log_step "开始 LVM 模式挂载: ${#disks[@]} 个磁盘 -> ${mount_point}"

    # 检查 LVM 工具是否安装
    for cmd in pvcreate vgcreate lvcreate; do
        if ! command -v "$cmd" &>/dev/null; then
            log_error "未安装 LVM 工具，请先安装: yum install lvm2 或 apt install lvm2"
            exit 1
        fi
    done

    # 安全检查：确保所有磁盘都不是系统盘
    local -a sys_disks_arr
    mapfile -t sys_disks_arr < <(get_system_disks)
    for disk in "${disks[@]}"; do
        for sd in "${sys_disks_arr[@]}"; do
            if [[ "$disk" == "$sd" ]]; then
                log_error "安全阻止: ${disk} 是系统盘，禁止操作！"
                exit 1
            fi
        done
    done

    # 检查磁盘是否有数据
    local has_data_disks=()
    for disk in "${disks[@]}"; do
        if check_disk_has_data "$disk"; then
            has_data_disks+=("$disk")
        fi
    done
    if [[ ${#has_data_disks[@]} -gt 0 ]]; then
        log_warn "以下磁盘检测到已有分区或数据:"
        for d in "${has_data_disks[@]}"; do
            show_disk_info "$d"
        done
        confirm_action "确认要格式化以上所有磁盘吗？" "yes"
    fi

    # 检查 VG 名称是否已存在，如果存在则自动添加后缀
    local orig_vg_name="$vg_name"
    local suffix=1
    while vgs "$vg_name" &>/dev/null; do
        vg_name="${orig_vg_name}_${suffix}"
        ((suffix++))
    done
    if [[ "$vg_name" != "$orig_vg_name" ]]; then
        log_warn "VG 名称 '${orig_vg_name}' 已存在，使用 '${vg_name}'"
        lv_name="lv_data_${suffix}"
    fi

    # 1. 清除已有分区并创建 PV
    log_detail "准备物理卷 (PV)..."
    for disk in "${disks[@]}"; do
        clean_existing_partitions "$disk"

        log_detail "  创建 PV: ${disk}"
        pvcreate -f "$disk"
    done

    # 2. 创建 VG
    log_detail "创建卷组 (VG): ${vg_name}"
    vgcreate "$vg_name" "${disks[@]}"

    # 3. 创建 LV（使用 VG 100% 空间）
    log_detail "创建逻辑卷 (LV): ${lv_name}"
    lvcreate -l 100%FREE -n "$lv_name" "$vg_name"

    local lv_path="/dev/${vg_name}/${lv_name}"

    # 4. 格式化 LV
    log_detail "格式化逻辑卷为 ${fs_type}..."
    mkfs.ext4 -F "$lv_path"

    # 5. 创建挂载点并挂载
    log_detail "创建挂载点: ${mount_point}"
    mkdir -p "$mount_point"

    log_detail "挂载逻辑卷..."
    mount "$lv_path" "$mount_point"

    # 6. 写入 fstab
    local uuid
    uuid=$(blkid -o value -s UUID "$lv_path")
    if [[ -n "$uuid" ]]; then
        cp /etc/fstab /etc/fstab.bak.$(date +%Y%m%d%H%M%S)
        log_detail "已备份 /etc/fstab"

        if ! grep -q "UUID=${uuid}" /etc/fstab; then
            echo "UUID=${uuid}  ${mount_point}  ${fs_type}  defaults,noatime  0  2" >> /etc/fstab
            log_detail "已写入 /etc/fstab，开机自动挂载"
        fi
    fi

    # 计算总大小
    local total_size
    total_size=$(vgs --noheadings --nosuffix --units g -o vg_size "$vg_name" 2>/dev/null | tr -d ' ')

    log_info "LVM 挂载完成!"
    log_info "  卷组: ${vg_name}"
    log_info "  逻辑卷: ${lv_path}"
    log_info "  磁盘数量: ${#disks[@]}"
    log_info "  总容量: ${total_size}G"
    log_info "  挂载点: ${mount_point}"
    log_info "  文件系统: ${fs_type}"
    log_info "  UUID: ${uuid:-未知}"
    echo ""
    log_info "包含的磁盘:"
    for disk in "${disks[@]}"; do
        show_disk_info "$disk"
    done
    echo ""
    df -h "$mount_point"
    echo ""
    log_info "提示: 后续可使用以下命令扩展 LVM:"
    log_info "  添加新磁盘: pvcreate /dev/sdX && vgextend ${vg_name} /dev/sdX && lvextend -l +100%FREE ${lv_path} && resize2fs ${lv_path}"
}

#===============================================================================
# 根目录 LVM 扩容 - 将空闲磁盘加入根目录所在的 VG/LV
#===============================================================================
expand_root_lvm() {
    local -a disks=("$@")

    log_step "开始根目录 LVM 扩容..."

    # 1. 检查 LVM 工具
    for cmd in pvs vgs lvs pvcreate vgextend lvextend; do
        if ! command -v "$cmd" &>/dev/null; then
            log_error "未安装 LVM 工具，请先安装: yum install lvm2 或 apt install lvm2"
            exit 1
        fi
    done

    # 2. 获取根目录设备信息
    local root_dev
    root_dev=$(findmnt -n -o SOURCE / 2>/dev/null || true)
    if [[ -z "$root_dev" ]]; then
        log_error "无法获取根目录挂载设备"
        exit 1
    fi
    log_detail "根目录设备: ${root_dev}"

    # 3. 判断根目录是否为 LVM
    if [[ "$root_dev" != /dev/mapper/* && "$root_dev" != /dev/dm-* ]]; then
        log_error "当前系统根目录 (${root_dev}) 不是 LVM 分区，无法使用 LVM 扩容"
        log_error "请使用标准分区模式或 LVM 新建模式挂载磁盘"
        exit 1
    fi

    # 解析根目录的 LV 和 VG 信息
    local root_lv_name root_vg_name root_lv_path
    root_lv_name=$(lvs --noheadings -o lv_name "$root_dev" 2>/dev/null | tr -d ' ')
    root_vg_name=$(lvs --noheadings -o vg_name "$root_dev" 2>/dev/null | tr -d ' ')
    root_lv_path=$(lvs --noheadings -o lv_path "$root_dev" 2>/dev/null | tr -d ' ')

    if [[ -z "$root_vg_name" || -z "$root_lv_name" ]]; then
        log_error "无法解析根目录的 LVM 信息 (VG/LV)"
        exit 1
    fi

    log_detail "根目录 VG: ${root_vg_name}"
    log_detail "根目录 LV: ${root_lv_path}"

    # 4. 获取根目录文件系统类型
    local root_fs_type
    root_fs_type=$(findmnt -n -o FSTYPE / 2>/dev/null || true)
    log_detail "根目录文件系统: ${root_fs_type}"

    if [[ "$root_fs_type" != "ext4" && "$root_fs_type" != "xfs" ]]; then
        log_error "不支持的根目录文件系统类型: ${root_fs_type}，仅支持 ext4/xfs"
        exit 1
    fi

    # 5. 安全检查：确保所有目标空闲磁盘都不是系统盘
    local -a sys_disks_arr
    mapfile -t sys_disks_arr < <(get_system_disks)
    for disk in "${disks[@]}"; do
        for sd in "${sys_disks_arr[@]}"; do
            if [[ "$disk" == "$sd" ]]; then
                log_error "安全阻止: ${disk} 是系统盘，禁止操作！"
                exit 1
            fi
        done
    done

    # 6. 检测系统磁盘上是否有未分配的空闲空间
    local use_sys_disk_free=false
    local sys_disk_free_part=""  # 系统盘上新建的分区路径

    # 获取系统盘（根分区所在的物理磁盘）
    local root_pv root_sys_disk=""
    # 获取根 VG 的第一个 PV
    root_pv=$(pvs --noheadings -o pv_name -S "vg_name=$root_vg_name" 2>/dev/null | head -1 | tr -d ' ')
    if [[ -n "$root_pv" ]]; then
        # 获取 PV 所在的物理磁盘
        local pv_basename
        pv_basename=$(basename "$root_pv")
        root_sys_disk=$(lsblk -ndo PKNAME "/dev/$pv_basename" 2>/dev/null || true)
        if [[ -n "$root_sys_disk" ]]; then
            root_sys_disk="/dev/$root_sys_disk"
        else
            # PV 可能直接就是整盘（无分区）
            root_sys_disk="$root_pv"
        fi
    fi

    if [[ -n "$root_sys_disk" ]]; then
        log_detail "系统磁盘: ${root_sys_disk}"

        # 使用多种方法检测系统盘空闲空间
        local free_space_mb=0
        local free_start_mb="" free_end_mb=""

        # 方法1: 使用 parted print free
        # 输出格式（Free Space 行）:  "32.2GB  107GB  75.2GB  Free Space"
        # 字段: $1=Start $2=End $3=Size, 后面是 "Free Space"
        local free_info
        free_info=$(parted -s "$root_sys_disk" unit MB print free 2>/dev/null | grep "Free Space" | tail -1 || true)
        if [[ -n "$free_info" ]]; then
            # 提取 Start, End, Size（前三个字段）
            local f_start f_end f_size
            f_start=$(echo "$free_info" | awk '{print $1}' | sed 's/MB//')
            f_end=$(echo "$free_info" | awk '{print $2}' | sed 's/MB//')
            f_size=$(echo "$free_info" | awk '{print $3}' | sed 's/MB//')
            if [[ "$f_size" =~ ^[0-9]+(\.[0-9]+)?$ ]]; then
                free_space_mb=$(printf '%.0f' "$f_size")
                free_start_mb="${f_start}MB"
                free_end_mb="${f_end}MB"
            fi
        fi

        # 方法2: 如果 parted 方法失败，通过扇区计算
        if [[ "$free_space_mb" -eq 0 ]]; then
            # 获取磁盘总扇区数和扇区大小
            local total_sectors sector_size last_part_end
            total_sectors=$(lsblk -ndb -o SIZE "$root_sys_disk" 2>/dev/null || echo 0)
            sector_size=$(blockdev --getss "$root_sys_disk" 2>/dev/null || echo 512)
            # 获取最后一个分区的结束扇区
            last_part_end=$(fdisk -l "$root_sys_disk" 2>/dev/null | awk '/^\/dev/ {end=$3} END {print end+0}')
            if [[ -n "$last_part_end" && "$last_part_end" -gt 0 && -n "$total_sectors" && "$total_sectors" -gt 0 ]]; then
                local total_sectors_count=$((total_sectors / sector_size))
                local free_sectors=$((total_sectors_count - last_part_end - 1))
                if [[ "$free_sectors" -gt 0 ]]; then
                    free_space_mb=$((free_sectors * sector_size / 1024 / 1024))
                    # 计算起止位置用于后续创建分区
                    local start_bytes=$(( (last_part_end + 1) * sector_size ))
                    free_start_mb="$((start_bytes / 1024 / 1024))MB"
                    free_end_mb="100%"
                fi
            fi
        fi

        log_detail "系统盘可用空闲空间: ${free_space_mb}MB"

        # 大于 1GB 才认为有意义的空闲空间
        if [[ "$free_space_mb" -gt 1024 ]]; then
            local free_space_gb=$((free_space_mb / 1024))
            echo ""
            log_info "检测到系统磁盘 ${root_sys_disk} 上有约 ${free_space_gb}GB (${free_space_mb}MB) 未分配空间"
            echo -n "是否将系统盘的未分配空间也扩容到根目录? [y/N]: "
            read -r use_sys_free_choice
            if [[ "$use_sys_free_choice" == "y" || "$use_sys_free_choice" == "Y" ]]; then
                use_sys_disk_free=true
                log_info "将包含系统盘空闲空间一起扩容"
            else
                log_info "跳过系统盘空闲空间，仅使用其他空闲磁盘"
            fi
        else
            log_detail "系统磁盘无可用空闲空间 (< 1GB)，跳过"
        fi
    fi

    # 7. 过滤掉已经属于根 VG 的磁盘（它们已在为根目录服务，无需重复处理）
    local -a already_in_vg=()
    local -a new_disks=()
    for disk in "${disks[@]}"; do
        # 检查整盘或其分区是否已经是根 VG 的 PV
        local disk_in_root_vg=false
        if command -v pvs &>/dev/null; then
            # 检查整盘
            local disk_vg
            disk_vg=$(pvs --noheadings -o vg_name "$disk" 2>/dev/null | tr -d ' ' || true)
            if [[ "$disk_vg" == "$root_vg_name" ]]; then
                disk_in_root_vg=true
            fi
            # 检查磁盘上的所有分区
            if [[ "$disk_in_root_vg" == false ]]; then
                while IFS= read -r pname; do
                    [[ -z "$pname" ]] && continue
                    local part_vg
                    part_vg=$(pvs --noheadings -o vg_name "/dev/$pname" 2>/dev/null | tr -d ' ' || true)
                    if [[ "$part_vg" == "$root_vg_name" ]]; then
                        disk_in_root_vg=true
                        break
                    fi
                done < <(lsblk -nlo NAME,TYPE "$disk" 2>/dev/null | awk '$2=="part" {print $1}')
            fi
        fi
        if [[ "$disk_in_root_vg" == true ]]; then
            already_in_vg+=("$disk")
        else
            new_disks+=("$disk")
        fi
    done

    if [[ ${#already_in_vg[@]} -gt 0 ]]; then
        log_info "以下磁盘已属于根目录 VG (${root_vg_name})，无需重复添加，已跳过:"
        for d in "${already_in_vg[@]}"; do
            show_disk_info "$d"
        done
    fi

    # 更新磁盘列表为真正需要处理的新磁盘
    disks=("${new_disks[@]}")

    # 8. 检查新磁盘是否有已有分区，提示用户选择处理方式
    if [[ ${#disks[@]} -gt 0 ]]; then
        local -a has_data_disks=()
        local -a clean_disks=()
        for disk in "${disks[@]}"; do
            if check_disk_has_data "$disk"; then
                has_data_disks+=("$disk")
            else
                clean_disks+=("$disk")
            fi
        done

        if [[ ${#has_data_disks[@]} -gt 0 ]]; then
            echo ""
            log_warn "以下空闲磁盘检测到已有分区或数据:"
            for d in "${has_data_disks[@]}"; do
                show_disk_info "$d"
                # 显示分区详情
                echo -e "      ${CYAN}分区详情:${NC}"
                lsblk -o NAME,SIZE,FSTYPE,LABEL "$d" 2>/dev/null | tail -n +2 | while IFS= read -r line; do
                    echo "        $line"
                done
            done
            echo ""
            log_step "请选择处理方式:"
            echo -e "  ${GREEN}1)${NC} 清除这些磁盘上的所有分区并继续扩容"
            echo -e "  ${GREEN}2)${NC} 跳过有分区的磁盘，仅使用无分区的磁盘"
            echo -e "  ${GREEN}3)${NC} 退出操作"
            echo ""
            echo -n "请输入选择 [1-3]: "
            read -r data_choice

            case "$data_choice" in
                1)
                    log_warn "将清除以上磁盘的所有分区和数据"
                    confirm_action "确认要清除以上磁盘的所有数据吗？" "yes"
                    ;;
                2)
                    if [[ ${#clean_disks[@]} -eq 0 && "$use_sys_disk_free" == false ]]; then
                        log_error "没有可用磁盘（无分区的空闲磁盘为 0 且未选择系统盘空闲空间），操作取消"
                        exit 1
                    fi
                    log_info "跳过有分区的磁盘，仅使用无分区的磁盘"
                    disks=("${clean_disks[@]}")
                    if [[ ${#disks[@]} -gt 0 ]]; then
                        for d in "${disks[@]}"; do
                            show_disk_info "$d"
                        done
                    fi
                    ;;
                3|*)
                    log_info "操作已取消"
                    exit 0
                    ;;
            esac
        fi
    fi

    # 检查是否有任何可操作的磁盘
    if [[ ${#disks[@]} -eq 0 && "$use_sys_disk_free" == false ]]; then
        log_error "没有可用的磁盘进行扩容，操作取消"
        exit 1
    fi

    # 8. 显示操作摘要
    local total=0
    for disk in "${disks[@]}"; do
        local s
        s=$(lsblk -ndo SIZE -b "$disk" 2>/dev/null || echo 0)
        total=$((total + s))
    done
    local total_gb=$((total / 1024 / 1024 / 1024))

    local current_root_size
    current_root_size=$(df -h / 2>/dev/null | awk 'NR==2 {print $2}')

    echo ""
    echo "============================================================"
    log_info "根目录扩容操作摘要:"
    log_info "  根目录 VG: ${root_vg_name}"
    log_info "  根目录 LV: ${root_lv_path}"
    log_info "  根目录当前大小: ${current_root_size}"
    log_info "  文件系统: ${root_fs_type}"
    if [[ "$use_sys_disk_free" == true ]]; then
        log_info "  系统盘空闲空间: ${root_sys_disk} (约 ${free_space_mb}MB)"
    fi
    if [[ ${#disks[@]} -gt 0 ]]; then
        log_info "  待添加空闲磁盘: ${#disks[@]} 个 (约 ${total_gb}GB)"
        for d in "${disks[@]}"; do
            show_disk_info "$d"
        done
    fi
    echo "============================================================"

    confirm_action "确认将以上空间扩容到根目录？" "yes"

    # 9. 处理系统盘空闲空间
    if [[ "$use_sys_disk_free" == true ]]; then
        log_step "正在扩容系统盘空闲空间..."

        # 在系统盘末尾创建新分区（使用检测阶段保存的 free_start_mb / free_end_mb）
        log_detail "在系统盘 ${root_sys_disk} 上创建新分区..."

        if [[ -z "$free_start_mb" || -z "$free_end_mb" ]]; then
            log_error "无法获取系统盘空闲区域信息"
            log_warn "跳过系统盘空闲空间扩容，继续处理其他磁盘..."
            use_sys_disk_free=false
        else
            log_detail "  空闲区域: ${free_start_mb} - ${free_end_mb}"

            # 在空闲区域创建新分区
            parted -s "$root_sys_disk" mkpart primary "$free_start_mb" "$free_end_mb"

            # 通知内核
            partprobe "$root_sys_disk" 2>/dev/null || true
            sleep 2

            # 获取新创建的分区路径（取最大分区号）
            local actual_new_num
            actual_new_num=$(parted -s "$root_sys_disk" print 2>/dev/null | awk '/^ *[0-9]/ {n=$1} END {print n+0}')

            if [[ "$root_sys_disk" == *nvme* || "$root_sys_disk" == *loop* ]]; then
                sys_disk_free_part="${root_sys_disk}p${actual_new_num}"
            else
                sys_disk_free_part="${root_sys_disk}${actual_new_num}"
            fi

            if [[ ! -b "$sys_disk_free_part" ]]; then
                log_error "创建系统盘新分区失败，分区设备 ${sys_disk_free_part} 不存在"
                log_warn "跳过系统盘空闲空间扩容，继续处理其他磁盘..."
                use_sys_disk_free=false
            else
                log_detail "  新分区: ${sys_disk_free_part}"

                # 设置 LVM 标记
                parted -s "$root_sys_disk" set "$actual_new_num" lvm on 2>/dev/null || true

                # 创建 PV
                log_detail "  创建 PV: ${sys_disk_free_part}"
                pvcreate -f "$sys_disk_free_part"

                # 扩展 VG
                log_detail "  将 ${sys_disk_free_part} 加入 VG: ${root_vg_name}"
                vgextend "$root_vg_name" "$sys_disk_free_part"

                log_info "系统盘空闲空间已加入 VG"
            fi
        fi
    fi

    # 10. 逐个空闲磁盘: 清理 -> 创建 PV -> 加入 VG
    if [[ ${#disks[@]} -gt 0 ]]; then
        log_step "正在处理空闲磁盘..."
        for disk in "${disks[@]}"; do
            log_detail "处理磁盘: ${disk}"

            # 清除已有分区
            if check_disk_has_data "$disk"; then
                clean_existing_partitions "$disk"
            fi

            # 创建 PV
            log_detail "  创建 PV: ${disk}"
            pvcreate -f "$disk"

            # 扩展 VG
            log_detail "  将 ${disk} 加入 VG: ${root_vg_name}"
            vgextend "$root_vg_name" "$disk"
        done
    fi

    # 11. 扩展 LV 使用所有新增空闲空间
    log_detail "扩展 LV: ${root_lv_path}"
    lvextend -l +100%FREE "$root_lv_path"

    # 12. 扩展文件系统
    log_detail "扩展文件系统 (${root_fs_type})..."
    case "$root_fs_type" in
        ext4)
            resize2fs "$root_lv_path"
            ;;
        xfs)
            xfs_growfs /
            ;;
    esac

    # 13. 显示结果
    local new_root_size
    new_root_size=$(df -h / 2>/dev/null | awk 'NR==2 {print $2}')
    local vg_total
    vg_total=$(vgs --noheadings --nosuffix --units g -o vg_size "$root_vg_name" 2>/dev/null | tr -d ' ')

    echo ""
    log_info "根目录扩容完成!"
    log_info "  VG: ${root_vg_name} (总容量: ${vg_total}G)"
    log_info "  LV: ${root_lv_path}"
    log_info "  扩容前根目录大小: ${current_root_size}"
    log_info "  扩容后根目录大小: ${new_root_size}"
    if [[ "$use_sys_disk_free" == true && -n "$sys_disk_free_part" ]]; then
        log_info "  系统盘新分区: ${sys_disk_free_part}"
    fi
    if [[ ${#disks[@]} -gt 0 ]]; then
        log_info "  新增空闲磁盘: ${#disks[@]} 个"
    fi
    echo ""
    log_info "根目录磁盘使用情况:"
    df -h /
    echo ""
    log_info "VG 详情:"
    vgs "$root_vg_name"
    echo ""
    log_info "PV 详情:"
    pvs -S "vg_name=$root_vg_name"
}

#===============================================================================
# 交互式选择磁盘（用于标准模式选择单个磁盘）
#===============================================================================
select_single_disk() {
    local -a disks=("$@")

    if [[ ${#disks[@]} -eq 1 ]]; then
        log_info "仅检测到 1 个空闲磁盘，自动选择:" >&2
        show_disk_info "${disks[0]}" >&2
        echo "${disks[0]}"
        return
    fi

    echo "" >&2
    log_info "检测到 ${#disks[@]} 个空闲磁盘，请选择要挂载的磁盘:" >&2
    local i=1
    for disk in "${disks[@]}"; do
        echo -e "  ${GREEN}${i})${NC}" >&2
        show_disk_info "$disk" >&2
        ((i++))
    done
    echo "" >&2
    echo -n "请输入磁盘编号 [1-${#disks[@]}]: " >&2
    read -r choice

    if [[ ! "$choice" =~ ^[0-9]+$ ]] || [[ "$choice" -lt 1 ]] || [[ "$choice" -gt ${#disks[@]} ]]; then
        log_error "无效的选择" >&2
        exit 1
    fi

    echo "${disks[$((choice-1))]}"
}

#===============================================================================
# 选择文件系统类型
#===============================================================================
select_filesystem() {
    echo "" >&2
    log_info "请选择文件系统类型:" >&2
    echo -e "  ${GREEN}1)${NC} ext4 (推荐，通用性强)" >&2
    echo -e "  ${GREEN}2)${NC} xfs  (适合大文件和大容量磁盘)" >&2
    echo "" >&2
    echo -n "请输入选择 [1-2] (默认 1): " >&2
    read -r choice

    case "$choice" in
        2)  echo "xfs" ;;
        *)  echo "ext4" ;;
    esac
}

#===============================================================================
# 主函数
#===============================================================================
main() {
    echo ""
    echo "============================================================"
    echo -e "  ${CYAN}Linux 磁盘自动挂载工具_By豆芽${NC}"
    echo -e "  支持标准分区 / LVM 多盘合并 / 根目录扩容"
    echo "============================================================"
    echo ""

    # 前置检查
    check_root
    check_os
    check_commands

    # 获取系统盘
    log_step "正在检测系统磁盘..."
    local -a sys_disks
    mapfile -t sys_disks < <(get_system_disks)
    if [[ ${#sys_disks[@]} -eq 0 ]]; then
        log_warn "未能识别系统磁盘，为安全起见，请手动确认"
    else
        log_info "检测到系统磁盘 (将被保护，不会操作):"
        for sd in "${sys_disks[@]}"; do
            show_disk_info "$sd"
        done
    fi
    echo ""

    # 获取空闲磁盘
    log_step "正在检测空闲磁盘..."
    local -a free_disks
    mapfile -t free_disks < <(get_free_disks)

    if [[ ${#free_disks[@]} -eq 0 ]]; then
        log_error "未检测到空闲磁盘，无法继续操作"
        echo ""
        log_info "当前所有磁盘状态:"
        lsblk -o NAME,SIZE,TYPE,FSTYPE,MOUNTPOINT,MODEL
        exit 1
    fi

    log_info "检测到 ${#free_disks[@]} 个空闲磁盘:"
    for disk in "${free_disks[@]}"; do
        show_disk_info "$disk"
    done
    echo ""

    # 选择挂载模式
    log_step "请选择挂载模式:"
    echo -e "  ${GREEN}1)${NC} 标准分区模式   - 挂载单个磁盘到指定目录"
    echo -e "  ${GREEN}2)${NC} LVM 模式       - 将所有空闲磁盘合并为一个逻辑卷"
    echo -e "  ${GREEN}3)${NC} 根目录扩容模式 - 将空闲磁盘扩容到系统根目录 (需要 LVM 根分区)"
    echo ""
    echo -n "请输入选择 [1-3]: "
    read -r mode_choice

    # 根目录扩容模式不需要挂载点输入，单独处理
    if [[ "$mode_choice" == "3" ]]; then
        echo ""
        expand_root_lvm "${free_disks[@]}"

        echo ""
        log_info "========================================="
        log_info "  操作全部完成！"
        log_info "========================================="
        echo ""
        exit 0
    fi

    # 输入挂载点（模式 1 和 2 需要）
    echo ""
    echo -n "请输入挂载目录 (默认 /data): "
    read -r mount_point
    mount_point="${mount_point:-/data}"

    # 验证挂载点
    if [[ "$mount_point" == "/" || "$mount_point" == "/boot" || "$mount_point" == "/home" || \
          "$mount_point" == "/usr" || "$mount_point" == "/var" || "$mount_point" == "/tmp" || \
          "$mount_point" == "/etc" || "$mount_point" == "/bin" || "$mount_point" == "/sbin" || \
          "$mount_point" == "/lib" || "$mount_point" == "/lib64" || "$mount_point" == "/proc" || \
          "$mount_point" == "/sys" || "$mount_point" == "/dev" || "$mount_point" == "/run" ]]; then
        log_error "挂载点 '${mount_point}' 是系统关键目录，禁止使用！"
        exit 1
    fi

    # 检查挂载点是否已被使用
    if mountpoint -q "$mount_point" 2>/dev/null; then
        log_error "挂载点 '${mount_point}' 已被其他设备挂载，请选择其他目录"
        exit 1
    fi

    # 如果目录已存在且不为空，发出警告
    if [[ -d "$mount_point" ]] && [[ -n "$(ls -A "$mount_point" 2>/dev/null)" ]]; then
        log_warn "目录 '${mount_point}' 已存在且不为空！"
        log_warn "挂载后原有内容将被隐藏（不会被删除，卸载后可恢复）"
        echo -n "是否继续? [y/N]: "
        read -r cont
        if [[ "$cont" != "y" && "$cont" != "Y" ]]; then
            log_info "操作已取消"
            exit 0
        fi
    fi

    echo ""

    case "$mode_choice" in
        1)
            # 标准分区模式
            local selected_disk
            selected_disk=$(select_single_disk "${free_disks[@]}")
            local fs_type
            fs_type=$(select_filesystem)

            echo ""
            echo "============================================================"
            log_info "操作摘要:"
            log_info "  模式: 标准分区"
            log_info "  磁盘: ${selected_disk}"
            log_info "  挂载点: ${mount_point}"
            log_info "  文件系统: ${fs_type}"
            echo "============================================================"

            confirm_action "确认执行以上操作？"

            standard_partition_mount "$selected_disk" "$mount_point" "$fs_type"
            ;;
        2)
            # LVM 模式
            if [[ ${#free_disks[@]} -lt 1 ]]; then
                log_error "LVM 模式至少需要 1 个空闲磁盘"
                exit 1
            fi

            # 计算总大小
            local total=0
            for disk in "${free_disks[@]}"; do
                local s
                s=$(lsblk -ndo SIZE -b "$disk" 2>/dev/null || echo 0)
                total=$((total + s))
            done
            local total_gb=$((total / 1024 / 1024 / 1024))

            echo ""
            echo "============================================================"
            log_info "操作摘要:"
            log_info "  模式: LVM (多盘合并)"
            log_info "  磁盘数量: ${#free_disks[@]}"
            log_info "  总容量: 约 ${total_gb}GB"
            log_info "  挂载点: ${mount_point}"
            log_info "  文件系统: ext4"
            log_info "  包含的磁盘:"
            for d in "${free_disks[@]}"; do
                show_disk_info "$d"
            done
            echo "============================================================"

            confirm_action "确认执行以上操作？"

            lvm_mount "$mount_point" "${free_disks[@]}"
            ;;
        *)
            log_error "无效的选择，请输入 1、2 或 3"
            exit 1
            ;;
    esac

    echo ""
    log_info "========================================="
    log_info "  操作全部完成！"
    log_info "========================================="
    echo ""
}

# 执行主函数
main "$@"