# system_info.py
import subprocess
import json
import logging
import re
import os

logger = logging.getLogger(__name__)

class SystemInfoManager:
    def __init__(self):
        pass

    def _run_command(self, command_list, root_privilege=False, check_output=True, input_data=None):
        """
        通用地运行一个 shell 命令。
        :param command_list: 命令及其参数的列表。
        :param root_privilege: 如果为 True，则使用 sudo 执行命令。
        :param check_output: 如果为 True，则捕获 stdout 和 stderr。如果为 False，则不捕获，用于需要交互或不关心输出的命令。
        :param input_data: 传递给命令stdin的数据 (str)。
        :return: (stdout_str, stderr_str)
        :raises subprocess.CalledProcessError: 如果命令返回非零退出码。
        """
        if root_privilege:
            command_list = ["sudo"] + command_list

        logger.debug(f"运行命令: {' '.join(command_list)}")
        try:
            result = subprocess.run(
                command_list,
                capture_output=check_output,
                text=True,
                check=True,
                encoding='utf-8',
                input=input_data
            )
            return result.stdout if check_output else "", result.stderr if check_output else ""
        except subprocess.CalledProcessError as e:
            logger.error(f"命令执行失败: {' '.join(command_list)}")
            logger.error(f"退出码: {e.returncode}")
            logger.error(f"标准输出: {e.stdout.strip()}")
            logger.error(f"标准错误: {e.stderr.strip()}")
            raise
        except FileNotFoundError:
            logger.error(f"命令 '{command_list[0]}' 未找到。请确保已安装相关工具。")
            raise
        except Exception as e:
            logger.error(f"运行命令 {' '.join(command_list)} 时发生未知错误: {e}")
            raise

    def get_block_devices(self):
        """
        使用 lsblk 获取块设备信息。
        返回一个字典列表，每个字典代表一个设备。
        """
        cmd = [
            "lsblk", "-J", "-o",
            "NAME,FSTYPE,SIZE,MOUNTPOINT,RO,TYPE,UUID,PARTUUID,VENDOR,MODEL,SERIAL,MAJ:MIN,PKNAME,PATH"
        ]
        try:
            stdout, _ = self._run_command(cmd)
            data = json.loads(stdout)
            devices = data.get('blockdevices', [])

            def add_path_recursive(dev_list):
                for dev in dev_list:
                    if 'PATH' not in dev and 'NAME' in dev:
                        dev['PATH'] = f"/dev/{dev['NAME']}"
                    # Rename PATH to path (lowercase) for consistency
                    if 'PATH' in dev:
                        dev['path'] = dev.pop('PATH')
                    if 'children' in dev:
                        add_path_recursive(dev['children'])
            add_path_recursive(devices)
            return devices
        except subprocess.CalledProcessError as e:
            logger.error(f"获取块设备信息失败: {e.stderr.strip()}")
            return []
        except json.JSONDecodeError as e:
            logger.error(f"解析 lsblk JSON 输出失败: {e}")
            return []
        except Exception as e:
            logger.error(f"获取块设备信息失败 (未知错误): {e}")
            return []

    def _find_device_by_path_recursive(self, dev_list, target_path):
        """
        Helper to find device data by its path recursively.
        Added type check for target_path.
        """
        if not isinstance(target_path, str):
            logger.warning(f"传入 _find_device_by_path_recursive 的 target_path 不是字符串: {target_path} (类型: {type(target_path)})")
            return None
        for dev in dev_list:
            if dev.get('path') == target_path:
                return dev
            if 'children' in dev:
                found = self._find_device_by_path_recursive(dev['children'], target_path)
                if found:
                    return found
        return None

    def _find_device_by_maj_min_recursive(self, dev_list, target_maj_min):
        """
        Helper to find device data by its major:minor number recursively.
        """
        if not isinstance(target_maj_min, str):
            logger.warning(f"传入 _find_device_by_maj_min_recursive 的 target_maj_min 不是字符串: {target_maj_min} (类型: {type(target_maj_min)})")
            return None
        for dev in dev_list:
            if dev.get('maj:min') == target_maj_min:
                return dev
            if 'children' in dev:
                found = self._find_device_by_maj_min_recursive(dev['children'], target_maj_min)
                if found:
                    return found
        return None

    def get_mountpoint_for_device(self, device_path):
        """
        根据设备路径获取其挂载点。
        此方法现在可以正确处理 /dev/md/new_raid 这样的 RAID 阵列别名，以及 LVM 逻辑卷的符号链接。
        """
        if not isinstance(device_path, str):
            logger.warning(f"传入 get_mountpoint_for_device 的 device_path 不是字符串: {device_path} (类型: {type(device_path)})")
            return None

        original_device_path = device_path
        logger.debug(f"get_mountpoint_for_device: 正在处理原始设备路径: {original_device_path}")

        devices = self.get_block_devices()
        logger.debug(f"get_mountpoint_for_device: 从 lsblk 获取到 {len(devices)} 个块设备信息。")

        target_maj_min = None
        current_search_path = original_device_path

        # 1. 解析符号链接以获取实际路径，并尝试获取 maj:min
        if original_device_path.startswith('/dev/') and os.path.exists(original_device_path):
            try:
                # 先尝试解析真实路径，因为 stat 可能对符号链接返回链接本身的 maj:min
                resolved_path = os.path.realpath(original_device_path)
                logger.debug(f"get_mountpoint_for_device: 原始设备路径 {original_device_path} 解析为 {resolved_path}")
                current_search_path = resolved_path # 使用解析后的路径进行 stat 和后续查找

                # 获取解析后路径的 maj:min
                stat_output, _ = self._run_command(["stat", "-c", "%t:%T", resolved_path], check_output=True)
                raw_maj_min = stat_output.strip() # e.g., "fc:0"

                # MODIFIED: Convert hex major to decimal
                if ':' in raw_maj_min:
                    major_hex, minor_dec = raw_maj_min.split(':')
                    try:
                        major_dec = str(int(major_hex, 16)) # Convert hex to decimal string
                        target_maj_min = f"{major_dec}:{minor_dec}" # e.g., "252:0"
                        logger.debug(f"get_mountpoint_for_device: 解析后设备 {resolved_path} 的 maj:min (hex) 为 {raw_maj_min}，转换为 decimal 为 {target_maj_min}")
                    except ValueError:
                        logger.warning(f"get_mountpoint_for_device: 无法将 maj:min 的主要部分 '{major_hex}' 从十六进制转换为十进制。")
                        target_maj_min = None # Fallback if conversion fails
                else:
                    logger.warning(f"get_mountpoint_for_device: stat 输出 '{raw_maj_min}' 格式不符合预期。")
                    target_maj_min = None

            except subprocess.CalledProcessError as e:
                logger.debug(f"get_mountpoint_for_device: 无法获取 {resolved_path} 的 maj:min (命令失败): {e.stderr.strip()}")
            except Exception as e:
                logger.debug(f"get_mountpoint_for_device: 无法获取 {resolved_path} 的 maj:min (未知错误): {e}")
        elif original_device_path.startswith('/dev/') and not os.path.exists(original_device_path):
            logger.warning(f"get_mountpoint_for_device: 设备路径 {original_device_path} 不存在，无法获取挂载点。")
            return None

        # 2. 尝试使用 (可能已解析的) current_search_path 在 lsblk 输出中查找
        dev_info = self._find_device_by_path_recursive(devices, current_search_path)
        logger.debug(f"get_mountpoint_for_device: _find_device_by_path_recursive 查找结果 (使用 {current_search_path}): {dev_info}")

        if dev_info:
            mountpoint = dev_info.get('mountpoint')
            logger.debug(f"get_mountpoint_for_device: 直接从 lsblk 获取到 {original_device_path} (解析为 {current_search_path}) 的挂载点: {mountpoint}")
            return mountpoint

        # 3. 如果直接路径查找失败，并且我们有 maj:min，尝试通过 maj:min 查找
        if target_maj_min:
            logger.debug(f"get_mountpoint_for_device: 直接路径查找失败，尝试通过 maj:min ({target_maj_min}) 查找。")
            dev_info_by_maj_min = self._find_device_by_maj_min_recursive(devices, target_maj_min)
            logger.debug(f"get_mountpoint_for_device: 通过 maj:min 查找结果: {dev_info_by_maj_min}")
            if dev_info_by_maj_min:
                mountpoint = dev_info_by_maj_min.get('mountpoint')
                logger.debug(f"get_mountpoint_for_device: 通过 maj:min 找到 {original_device_path} 的挂载点: {mountpoint}")
                return mountpoint

        # 4. 如果仍然查找失败，并且是 RAID 阵列（例如 /dev/md/new_raid）
        if original_device_path.startswith('/dev/md'):
            logger.debug(f"get_mountpoint_for_device: 正在处理 RAID 阵列 {original_device_path} 以获取挂载点...")
            actual_md_device_path = self._get_actual_md_device_path(original_device_path)
            logger.debug(f"get_mountpoint_for_device: RAID 阵列 {original_device_path} 的实际设备路径: {actual_md_device_path}")

            if actual_md_device_path:
                actual_dev_info = self._find_device_by_path_recursive(devices, actual_md_device_path)
                logger.debug(f"get_mountpoint_for_device: 实际设备路径 {actual_md_device_path} 的 lsblk 详情: {actual_dev_info}")

                if actual_dev_info:
                    mountpoint = actual_dev_info.get('mountpoint')
                    logger.debug(f"get_mountpoint_for_device: 在实际设备 {actual_md_device_path} 上找到了挂载点: {mountpoint}")
                    return mountpoint

        logger.debug(f"get_mountpoint_for_device: 未能获取到 {original_device_path} 的挂载点。")
        return None

    def _parse_mdadm_detail_output(self, output, device_path):
        """
        解析 mdadm --detail 命令的输出。
        """
        array_info = {
            'device': device_path, # Default to input path, will be updated by canonical_device_path
            'level': 'N/A',
            'state': 'N/A',
            'array_size': 'N/A',
            'active_devices': 'N/A',
            'failed_devices': 'N/A',
            'spare_devices': 'N/A',
            'total_devices': 'N/A',
            'uuid': 'N/A',
            'name': os.path.basename(device_path), # Default name, will be overridden
            'chunk_size': 'N/A',
            'member_devices': []
        }

        # 首先，尝试从 mdadm --detail 输出的第一行获取规范的设备路径
        device_path_header_match = re.match(r'^(?P<canonical_path>/dev/md\d+):', output)
        if device_path_header_match:
            array_info['device'] = device_path_header_match.group('canonical_path')
            array_info['name'] = os.path.basename(array_info['device']) # 根据规范路径更新默认名称

        # 逐行解析键值对
        for line in output.splitlines():
            line = line.strip()
            if not line:
                continue

            # 尝试匹配 "Key : Value" 格式
            kv_match = re.match(r'^(?P<key>[A-Za-z ]+)\s*:\s*(?P<value>.+)', line)
            if kv_match:
                key = kv_match.group('key').strip().lower().replace(' ', '_')
                value = kv_match.group('value').strip()

                if key == 'raid_level':
                    array_info['level'] = value
                elif key == 'state':
                    array_info['state'] = value
                elif key == 'array_size':
                    array_info['array_size'] = value
                elif key == 'uuid':
                    array_info['uuid'] = value
                elif key == 'raid_devices':
                    array_info['total_devices'] = value
                elif key == 'active_devices':
                    array_info['active_devices'] = value
                elif key == 'failed_devices':
                    array_info['failed_devices'] = value
                elif key == 'spare_devices':
                    array_info['spare_devices'] = value
                elif key == 'name':
                    # 只取名字的第一部分，忽略括号内的额外信息
                    array_info['name'] = value.split(' ')[0]
                elif key == 'chunk_size':
                    array_info['chunk_size'] = value

            # 成员设备解析 (独立于键值对，因为它有固定格式)
            member_pattern = re.match(r'^\s*(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+([^\s]+(?:\s+[^\s]+)*)\s+(/dev/\S+)$', line)
            if member_pattern:
                array_info['member_devices'].append({
                    'number': member_pattern.group(1),
                    'major': member_pattern.group(2),
                    'minor': member_pattern.group(3),
                    'raid_device': member_pattern.group(4),
                    'state': member_pattern.group(5).strip(),
                    'device_path': member_pattern.group(6)
                })

        # 最终状态标准化
        if array_info['state'] and 'active' in array_info['state'].lower():
            array_info['state'] = array_info['state'].replace('active', 'Active')
        elif array_info['state'] == 'clean':
             array_info['state'] = 'Active, Clean'
        elif array_info['state'] == 'N/A': # 如果未明确找到状态，则回退到推断
            if "clean" in output.lower() and "active" in output.lower():
                array_info['state'] = "Active, Clean"
            elif "degraded" in output.lower():
                array_info['state'] = "Degraded"
            elif "inactive" in output.lower() or "stopped" in output.lower():
                array_info['state'] = "Stopped"

        return array_info

    def get_mdadm_arrays(self):
        """
        获取所有 RAID 阵列的信息，包括活动的和已停止的。
        """
        all_arrays_info = {} # 使用 UUID 作为键，存储阵列的详细信息

        # 1. 获取活动的 RAID 阵列信息 (通过 mdadm --detail --scan 和 /proc/mdstat)
        active_md_devices = []

        # 从 mdadm --detail --scan 获取
        try:
            stdout_scan, stderr_scan = self._run_command(["mdadm", "--detail", "--scan"], check_output=True)
            for line in stdout_scan.splitlines():
                if line.startswith("ARRAY"):
                    match = re.match(r'ARRAY\s+(\S+)(?:\s+\S+=\S+)*\s+UUID=([0-9a-f:]+)', line)
                    if match:
                        dev_path = match.group(1)
                        if dev_path not in active_md_devices:
                            active_md_devices.append(dev_path)
        except subprocess.CalledProcessError as e:
            if "No arrays found" not in e.stderr and "No arrays found" not in e.stdout:
                logger.warning(f"执行 mdadm --detail --scan 失败: {e.stderr.strip()}")
        except Exception as e:
            logger.warning(f"处理 mdadm --detail --scan 输出时发生错误: {e}")


        # 从 /proc/mdstat 获取 (补充可能未被 --scan 报告的活动阵列)
        try:
            with open("/proc/mdstat", "r") as f:
                mdstat_content = f.read()
                for line in mdstat_content.splitlines():
                    if line.startswith("md") and "active" in line:
                        device_name_match = re.match(r'^(md\d+)\s+:', line)
                        if device_name_match:
                            dev_path = f"/dev/{device_name_match.group(1)}"
                            if dev_path not in active_md_devices:
                                active_md_devices.append(dev_path)
        except FileNotFoundError:
            logger.debug("/proc/mdstat not found. Cannot check active arrays from /proc/mdstat.")
        except Exception as e:
            logger.error(f"Error reading /proc/mdstat: {e}")

        # 现在，对每个找到的活动 MD 设备获取其详细信息
        for device_path in active_md_devices:
            try:
                # 解析符号链接以获取规范路径，例如 /dev/md/0 -> /dev/md0
                canonical_device_path = self._get_actual_md_device_path(device_path)
                if not canonical_device_path:
                    canonical_device_path = device_path # 如果解析失败，使用原始路径作为回退

                detail_stdout, detail_stderr = self._run_command(["mdadm", "--detail", canonical_device_path], check_output=True)
                array_info = self._parse_mdadm_detail_output(detail_stdout, canonical_device_path)
                if array_info and array_info.get('uuid') and array_info.get('device'):
                    # _parse_mdadm_detail_output 现在会更新 array_info['device'] 为规范路径
                    # 使用 UUID 作为键，如果同一个阵列有多个表示，只保留一个（通常是活动的）
                    all_arrays_info[array_info['uuid']] = array_info
                else:
                    logger.warning(f"无法从 mdadm --detail {canonical_device_path} 输出中解析 RAID 阵列信息: {detail_stdout[:100]}...")
            except subprocess.CalledProcessError as e:
                logger.warning(f"获取 RAID 阵列 {device_path} 详细信息失败: {e.stderr.strip()}")
            except Exception as e:
                logger.warning(f"处理 RAID 阵列 {device_path} 详细信息时发生错误: {e}")


        # 2. 从 /etc/mdadm.conf 获取配置的 RAID 阵列信息 (可能包含已停止的)
        mdadm_conf_paths = ["/etc/mdadm/mdadm.conf", "/etc/mdadm.conf"]
        found_conf = False
        for mdadm_conf_path in mdadm_conf_paths:
            if os.path.exists(mdadm_conf_path):
                found_conf = True
                try:
                    with open(mdadm_conf_path, 'r') as f:
                        for line in f:
                            line = line.strip()
                            if line.startswith("ARRAY"):
                                match_base = re.match(r'ARRAY\s+(\S+)\s*(.*)', line)
                                if match_base:
                                    device_path = match_base.group(1)
                                    rest_of_line = match_base.group(2)

                                    uuid = 'N/A'
                                    name = os.path.basename(device_path) # Default name

                                    uuid_match_conf = re.search(r'UUID=([0-9a-f:]+)', rest_of_line)
                                    if uuid_match_conf:
                                        uuid = uuid_match_conf.group(1)

                                    name_match_conf = re.search(r'NAME=(\S+)', rest_of_line)
                                    if name_match_conf:
                                        name = name_match_conf.group(1)

                                    if uuid != 'N/A': # 只有成功提取到 UUID 才添加
                                        # 只有当此 UUID 对应的阵列尚未被识别为活动状态时，才添加为停止状态
                                        if uuid not in all_arrays_info:
                                            all_arrays_info[uuid] = {
                                                'device': device_path,
                                                'uuid': uuid,
                                                'name': name,
                                                'level': 'Unknown',
                                                'state': 'Stopped (Configured)',
                                                'array_size': 'N/A',
                                                'active_devices': 'N/A',
                                                'failed_devices': 'N/A',
                                                'spare_devices': 'N/A',
                                                'total_devices': 'N/A',
                                                'chunk_size': 'N/A',
                                                'member_devices': []
                                            }
                                    else:
                                        logger.warning(f"无法从 mdadm.conf 行 '{line}' 中提取 UUID。")
                                else:
                                    logger.warning(f"无法解析 mdadm.conf 中的 ARRAY 行: '{line}'")
                except Exception as e:
                    logger.warning(f"读取或解析 {mdadm_conf_path} 失败: {e}")
                break # 找到并处理了一个配置文件就退出循环

        if not found_conf:
            logger.info(f"未找到 mdadm 配置文件。")


        # 返回所有阵列的列表
        # 排序：活动阵列在前，然后是停止的
        sorted_arrays = sorted(all_arrays_info.values(), key=lambda x: (x.get('state') != 'Active', x.get('device')))
        return sorted_arrays

    def get_lvm_info(self):
        """
        获取 LVM 物理卷 (PVs)、卷组 (VGs) 和逻辑卷 (LVs) 的信息。
        """
        lvm_info = {'pvs': [], 'vgs': [], 'lvs': []}

        # Get PVs
        try:
            stdout, stderr = self._run_command(["pvs", "--reportformat", "json"])
            data = json.loads(stdout)
            if 'report' in data and data['report']:
                for pv_data in data['report'][0].get('pv', []):
                    lvm_info['pvs'].append({
                        'pv_name': pv_data.get('pv_name'),
                        'vg_name': pv_data.get('vg_name'),
                        'pv_uuid': pv_data.get('pv_uuid'),
                        'pv_size': pv_data.get('pv_size'),
                        'pv_free': pv_data.get('pv_free'),
                        'pv_attr': pv_data.get('pv_attr'),
                        'pv_fmt': pv_data.get('pv_fmt')
                    })
        except subprocess.CalledProcessError as e:
            if "No physical volume found" in e.stderr or "No physical volumes found" in e.stdout:
                logger.info("未找到任何LVM物理卷。")
            else:
                logger.error(f"获取LVM物理卷信息失败: {e.stderr.strip()}")
        except json.JSONDecodeError as e:
            logger.error(f"解析LVM物理卷JSON输出失败: {e}")
        except Exception as e:
            logger.error(f"获取LVM物理卷信息失败 (未知错误): {e}")

        # Get VGs
        try:
            stdout, stderr = self._run_command(["vgs", "--reportformat", "json"])
            data = json.loads(stdout)
            if 'report' in data and data['report']:
                for vg_data in data['report'][0].get('vg', []):
                    lvm_info['vgs'].append({
                        'vg_name': vg_data.get('vg_name'),
                        'vg_uuid': vg_data.get('vg_uuid'),
                        'vg_size': vg_data.get('vg_size'),
                        'vg_free': vg_data.get('vg_free'),
                        'vg_attr': vg_data.get('vg_attr'),
                        'pv_count': vg_data.get('pv_count'),
                        'lv_count': vg_data.get('lv_count'),
                        'vg_alloc_percent': vg_data.get('vg_alloc_percent'),
                        'vg_fmt': vg_data.get('vg_fmt')
                    })
        except subprocess.CalledProcessError as e:
            if "No volume group found" in e.stderr or "No volume groups found" in e.stdout:
                logger.info("未找到任何LVM卷组。")
            else:
                logger.error(f"获取LVM卷组信息失败: {e.stderr.strip()}")
        except json.JSONDecodeError as e:
            logger.error(f"解析LVM卷组JSON输出失败: {e}")
        except Exception as e:
            logger.error(f"获取LVM卷组信息失败 (未知错误): {e}")

        # Get LVs (MODIFIED: added -o lv_path)
        try:
            # 明确请求 lv_path，因为默认的 --reportformat json 不包含它
            stdout, stderr = self._run_command(["lvs", "-o", "lv_name,vg_name,lv_uuid,lv_size,lv_attr,origin,snap_percent,lv_path", "--reportformat", "json"])
            data = json.loads(stdout)
            if 'report' in data and data['report']:
                for lv_data in data['report'][0].get('lv', []):
                    lvm_info['lvs'].append({
                        'lv_name': lv_data.get('lv_name'),
                        'vg_name': lv_data.get('vg_name'),
                        'lv_uuid': lv_data.get('lv_uuid'),
                        'lv_size': lv_data.get('lv_size'),
                        'lv_attr': lv_data.get('lv_attr'),
                        'origin': lv_data.get('origin'),
                        'snap_percent': lv_data.get('snap_percent'),
                        'lv_path': lv_data.get('lv_path') # 现在应该能正确获取到路径了
                    })
        except subprocess.CalledProcessError as e:
            if "No logical volume found" in e.stderr or "No logical volumes found" in e.stdout:
                logger.info("未找到任何LVM逻辑卷。")
            else:
                logger.error(f"获取LVM逻辑卷信息失败: {e.stderr.strip()}")
        except json.JSONDecodeError as e:
            logger.error(f"解析LVM逻辑卷JSON输出失败: {e}")
        except Exception as e:
            logger.error(f"获取LVM逻辑卷信息失败 (未知错误): {e}")

        return lvm_info

    def get_unallocated_partitions(self):
        """
        获取所有可用于创建RAID阵列或LVM物理卷的设备。
        这些设备包括：
        1. 没有分区表的整个磁盘。
        2. 未挂载的分区（包括有文件系统但未挂载的，如ext4/xfs等）。
        3. 未被LVM或RAID使用的分区或磁盘。
        返回一个设备路径列表，例如 ['/dev/sdb1', '/dev/sdc']。
        """
        block_devices = self.get_block_devices()
        candidates = []

        def process_device(dev):
            dev_path = dev.get('path')
            dev_type = dev.get('type')
            mountpoint = dev.get('mountpoint')
            fstype = dev.get('fstype')

            # 1. 检查是否已挂载 (排除SWAP，因为SWAP可以被覆盖，但如果活跃则不应动)
            # 如果是活跃挂载点（非SWAP），则不是候选
            if mountpoint and mountpoint != '[SWAP]':
                # 如果设备已挂载，则它不是候选。
                # 但仍需处理其子设备，因为父设备挂载不代表子设备不能用（虽然不常见）
                # 或者子设备挂载不代表父设备不能用（例如使用整个磁盘）
                if 'children' in dev:
                    for child in dev['children']:
                        process_device(child)
                return

            # 2. 检查是否是LVM物理卷或RAID成员
            # 如果是LVM PV或RAID成员，则它不是新RAID/PV的候选
            if fstype in ['LVM2_member', 'linux_raid_member']:
                if 'children' in dev: # 即使是LVM/RAID成员，也可能存在子设备（例如LVM上的分区，虽然不常见）
                    for child in dev['children']:
                        process_device(child)
                return

            # 3. 如果是整个磁盘且没有分区，则是一个候选
            if dev_type == 'disk' and not dev.get('children'):
                candidates.append(dev_path)
            # 4. 如果是分区，且通过了上述挂载和LVM/RAID检查，则是一个候选
            elif dev_type == 'part':
                candidates.append(dev_path)

            # 5. 递归处理子设备 (对于有分区的磁盘)
            # 这一步放在最后，确保先对当前设备进行评估
            if dev_type == 'disk' and dev.get('children'): # 只有当是磁盘且有子设备时才需要递归
                for child in dev['children']:
                    process_device(child)

        for dev in block_devices:
            process_device(dev)

        # 去重并排序
        return sorted(list(set(candidates)))

    def _get_actual_md_device_path(self, array_path):
        """
        解析 mdadm 阵列名称（例如 /dev/md/new_raid）
        对应的实际内核设备路径（例如 /dev/md127）。
        通过检查 /dev/md/ 目录下的符号链接来获取。
        Added type check for array_path.
        """
        if not isinstance(array_path, str):
            logger.warning(f"传入 _get_actual_md_device_path 的 array_path 不是字符串: {array_path} (类型: {type(array_path)})")
            return None

        # 如果已经是规范的 /dev/mdX 路径，直接返回
        if re.match(r'^/dev/md\d+$', array_path):
            return array_path

        if os.path.exists(array_path):
            try:
                # os.path.realpath 会解析符号链接，例如 /dev/md/new_raid -> /dev/md127
                actual_path = os.path.realpath(array_path)
                # 确保解析后仍然是 md 设备（以 /dev/md 开头）
                if actual_path.startswith('/dev/md'):
                    logger.debug(f"已将 RAID 阵列 {array_path} 解析为实际设备路径: {actual_path}")
                    return actual_path
            except Exception as e:
                logger.warning(f"无法通过 os.path.realpath 获取 RAID 阵列 {array_path} 的实际设备路径: {e}")
        logger.warning(f"RAID 阵列 {array_path} 不存在或无法解析其真实路径。")
        return None

    def get_device_details_by_path(self, device_path):
        """
        根据设备路径获取设备的 UUID 和文件系统类型 (fstype)。
        此方法现在可以正确处理 /dev/md/new_raid 这样的 RAID 阵列别名，以及 LVM 逻辑卷的符号链接。
        Added type check for device_path.
        :param device_path: 设备的路径，例如 '/dev/sdb1' 或 '/dev/md0' 或 '/dev/md/new_raid'
        :return: 包含 'uuid' 和 'fstype' 的字典，如果未找到则返回 None。
        """
        if not isinstance(device_path, str):
            logger.warning(f"传入 get_device_details_by_path 的 device_path 不是字符串: {device_path} (类型: {type(device_path)})")
            return None

        original_device_path = device_path
        logger.debug(f"get_device_details_by_path: 正在处理原始设备路径: {original_device_path}")

        devices = self.get_block_devices() # 获取所有块设备信息
        logger.debug(f"get_device_details_by_path: 从 lsblk 获取到 {len(devices)} 个块设备信息。")

        target_maj_min = None
        current_search_path = original_device_path

        # 1. 解析符号链接以获取实际路径，并尝试获取 maj:min
        if original_device_path.startswith('/dev/') and os.path.exists(original_device_path):
            try:
                resolved_path = os.path.realpath(original_device_path)
                logger.debug(f"get_device_details_by_path: 原始设备路径 {original_device_path} 解析为 {resolved_path}")
                current_search_path = resolved_path

                stat_output, _ = self._run_command(["stat", "-c", "%t:%T", resolved_path], check_output=True)
                raw_maj_min = stat_output.strip() # e.g., "fc:0"

                # MODIFIED: Convert hex major to decimal
                if ':' in raw_maj_min:
                    major_hex, minor_dec = raw_maj_min.split(':')
                    try:
                        major_dec = str(int(major_hex, 16)) # Convert hex to decimal string
                        target_maj_min = f"{major_dec}:{minor_dec}" # e.g., "252:0"
                        logger.debug(f"get_device_details_by_path: 解析后设备 {resolved_path} 的 maj:min (hex) 为 {raw_maj_min}，转换为 decimal 为 {target_maj_min}")
                    except ValueError:
                        logger.warning(f"get_device_details_by_path: 无法将 maj:min 的主要部分 '{major_hex}' 从十六进制转换为十进制。")
                        target_maj_min = None
                else:
                    logger.warning(f"get_device_details_by_path: stat 输出 '{raw_maj_min}' 格式不符合预期。")
                    target_maj_min = None

            except subprocess.CalledProcessError as e:
                logger.debug(f"get_device_details_by_path: 无法获取 {resolved_path} 的 maj:min (命令失败): {e.stderr.strip()}")
            except Exception as e:
                logger.debug(f"get_device_details_by_path: 无法获取 {resolved_path} 的 maj:min (未知错误): {e}")
        elif original_device_path.startswith('/dev/') and not os.path.exists(original_device_path):
            logger.warning(f"get_device_details_by_path: 设备路径 {original_device_path} 不存在，无法获取详情。")
            return None

        # 2. 首先，尝试使用 (可能已解析的) current_search_path 在 lsblk 输出中查找
        lsblk_details = self._find_device_by_path_recursive(devices, current_search_path)
        logger.debug(f"get_device_details_by_path: _find_device_by_path_recursive 查找结果 (使用 {current_search_path}, 直接查找): {lsblk_details}")

        if lsblk_details and lsblk_details.get('fstype'):
            logger.debug(f"get_device_details_by_path: 直接从 lsblk 获取到 {original_device_path} (解析为 {current_search_path}) 的详情: {lsblk_details}")
            return {
                'uuid': lsblk_details.get('uuid'),
                'fstype': lsblk_details.get('fstype')
            }

        # 3. 如果直接路径查找失败，并且我们有 maj:min，尝试通过 maj:min 查找
        if target_maj_min:
            logger.debug(f"get_device_details_by_path: 直接路径查找失败，尝试通过 maj:min ({target_maj_min}) 查找。")
            dev_info_by_maj_min = self._find_device_by_maj_min_recursive(devices, target_maj_min)
            logger.debug(f"get_device_details_by_path: 通过 maj:min 查找结果: {dev_info_by_maj_min}")
            if dev_info_by_maj_min and dev_info_by_maj_min.get('fstype'):
                logger.debug(f"get_device_details_by_path: 通过 maj:min 找到 {original_device_path} 的文件系统详情: {dev_info_by_maj_min}")
                return {
                    'uuid': dev_info_by_maj_min.get('uuid'),
                    'fstype': dev_info_by_maj_min.get('fstype')
                }

        # 4. 如果仍然没有找到，并且是 RAID 阵列（例如 /dev/md/new_raid）
        if original_device_path.startswith('/dev/md'):
            logger.debug(f"get_device_details_by_path: 正在处理 RAID 阵列 {original_device_path}...")

            actual_md_device_path = self._get_actual_md_device_path(original_device_path)
            logger.debug(f"get_device_details_by_path: RAID 阵列 {original_device_path} 的实际设备路径: {actual_md_device_path}")

            if actual_md_device_path:
                actual_device_lsblk_details = self._find_device_by_path_recursive(devices, actual_md_device_path)
                logger.debug(f"get_device_details_by_path: 实际设备路径 {actual_md_device_path} 的 lsblk 详情: {actual_device_lsblk_details}")

                if actual_device_lsblk_details and actual_device_lsblk_details.get('fstype'):
                    logger.debug(f"get_device_details_by_path: 在实际设备 {actual_md_device_path} 上找到了文件系统详情: {actual_device_lsblk_details}")
                    return {
                        'uuid': actual_device_lsblk_details.get('uuid'),
                        'fstype': actual_device_lsblk_details.get('fstype')
                    }
                else:
                    logger.warning(f"get_device_details_by_path: RAID 阵列 {original_device_path} (实际设备 {actual_md_device_path}) 未找到文件系统类型。")
                    return None
            else:
                logger.warning(f"get_device_details_by_path: 无法确定 RAID 阵列 {original_device_path} 的实际内核设备路径。")
                return None

        # 5. 如果仍然没有找到，返回 None
        logger.debug(f"get_device_details_by_path: 未能获取到 {original_device_path} 的任何详情。")
        return None

    def delete_raid_array_config(self, uuid):
        """
        从 mdadm.conf 文件中删除指定 UUID 的 RAID 阵列配置条目。
        :param uuid: 要删除的 RAID 阵列的 UUID。
        :return: True 如果成功删除或未找到条目，False 如果发生错误。
        :raises Exception: 如果删除失败。
        """
        logger.info(f"尝试从 mdadm.conf 中删除 UUID 为 {uuid} 的 RAID 阵列配置。")
        mdadm_conf_paths = ["/etc/mdadm/mdadm.conf", "/etc/mdadm.conf"]
        target_conf_path = None

        # 找到存在的 mdadm.conf 文件
        for path in mdadm_conf_paths:
            if os.path.exists(path):
                target_conf_path = path
                break

        if not target_conf_path:
            logger.warning("未找到 mdadm 配置文件，无法删除配置条目。")
            raise FileNotFoundError("mdadm 配置文件未找到。")

        original_lines = []
        try:
            with open(target_conf_path, 'r') as f:
                original_lines = f.readlines()
        except Exception as e:
            logger.error(f"读取 mdadm 配置文件 {target_conf_path} 失败: {e}")
            raise Exception(f"读取 mdadm 配置文件失败: {e}")

        new_lines = []
        entry_found = False
        for line in original_lines:
            stripped_line = line.strip()
            if stripped_line.startswith("ARRAY"):
                # 尝试匹配 UUID
                uuid_match = re.search(r'UUID=([0-9a-f:]+)', stripped_line)
                if uuid_match and uuid_match.group(1) == uuid:
                    logger.debug(f"找到并跳过 UUID 为 {uuid} 的配置行: {stripped_line}")
                    entry_found = True
                    continue # 跳过此行，即删除
            new_lines.append(line)

        if not entry_found:
            logger.warning(f"在 mdadm.conf 中未找到 UUID 为 {uuid} 的 RAID 阵列配置条目。")
            # 即使未找到，也不视为错误，因为可能已经被手动删除或从未写入
            return True

        # 将修改后的内容写回文件 (需要 root 权限)
        try:
            # 使用临时文件进行原子写入，防止数据损坏
            temp_file_path = f"{target_conf_path}.tmp"
            with open(temp_file_path, 'w') as f:
                f.writelines(new_lines)

            # 替换原文件
            self._run_command(["mv", temp_file_path, target_conf_path], root_privilege=True)
            logger.info(f"成功从 {target_conf_path} 中删除 UUID 为 {uuid} 的 RAID 阵列配置。")
            return True
        except subprocess.CalledProcessError as e:
            logger.error(f"删除 mdadm 配置条目失败 (mv 命令错误): {e.stderr.strip()}")
            raise Exception(f"删除 mdadm 配置条目失败: {e.stderr.strip()}")
        except Exception as e:
            logger.error(f"写入 mdadm 配置文件 {target_conf_path} 失败: {e}")
            raise Exception(f"写入 mdadm 配置文件失败: {e}")