#!/usr/bin/env python3
# Copyright (c) 2026 Huawei Technologies Co., Ltd.
# openUBMC is licensed under Mulan PSL v2.
# You can use this software according to the terms and conditions of the Mulan PSL v2.
# You may obtain a copy of Mulan PSL v2 at:
#         http://license.coscl.org.cn/MulanPSL2
# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
# See the Mulan PSL v2 for more details.

import argparse
import json
import os
import re
import shutil
import zipfile
from collections import defaultdict
from io import BytesIO
import urllib3
import requests

# 取消证书校验告警
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

SCRIPT_DIR = os.path.dirname(os.path.realpath(__file__))


def parse_resource_type_from_xml_name(filename: str) -> str:
    """从 XML 文件名中提取资源类型名
    如: AccountService_v1.xml -> accountservice
    """
    base = filename[:-4]  # 移除 .xml
    base_lower = base.lower()
    return base_lower.rsplit("_v", 1)[0] if "_v" in base_lower else base_lower


def parse_resource_type_from_json_name(filename: str) -> str:
    """从 JSON 文件名中提取资源类型名
    如: AccountService.v1_0_0.json -> accountservice
    """
    base = filename[:-5]  # 移除 .json
    return base.lower().split(".")[0]


def parse_args():
    """解析命令行参数"""
    parser = argparse.ArgumentParser(
        description="更新 Redfish schema 文件\n"
                    "示例版本: DSP8010_2025.4",
        formatter_class=argparse.RawDescriptionHelpFormatter
    )
    parser.add_argument(
        "--version",
        type=str,
        default=None,
        help="指定 Redfish schema 版本（--source=remote 时必填，如: DSP8010_2025.4）"
    )
    parser.add_argument(
        "--output-dir",
        type=str,
        default=None,
        help="指定 schema 文件输出目录路径（相对于项目根目录）"
    )
    parser.add_argument(
        "--source",
        type=str,
        choices=["remote", "local"],
        default="remote",
        help="指定 zip 文件来源：remote（远程下载）或 local（本地文件），默认: remote"
    )
    parser.add_argument(
        "--zip-path",
        type=str,
        default=None,
        help="当 --source=local 时，必须指定本地 zip 文件路径"
    )
    parser.add_argument(
        "--update-odata-type",
        action="store_true",
        default=True,
        help="是否更新 mapping_config 目录中的 @odata.type 版本（默认: True）"
    )
    parser.add_argument(
        "--no-update-odata-type",
        action="store_false",
        dest="update_odata_type",
        help="不更新 mapping_config 目录中的 @odata.type 版本"
    )
    parser.add_argument(
        "--update-metadata",
        action="store_true",
        default=True,
        help="是否更新 metadata/index.xml 文件（默认: True）"
    )
    parser.add_argument(
        "--no-update-metadata",
        action="store_false",
        dest="update_metadata",
        help="不更新 metadata/index.xml 文件"
    )
    args = parser.parse_args()

    # 验证参数组合
    if args.source == "remote" and not args.version:
        parser.error("--source=remote 时必须指定 --version 参数")
    if args.source == "local" and not args.zip_path:
        parser.error("--source=local 时必须指定 --zip-path 参数")

    return args


def extract_schema_files(zip_ref, file_list, version, zip_subdir, target_dir):
    """从 zip 中提取 schema 文件到目标目录

    Args:
        zip_ref: ZipFile 对象
        file_list: 要提取的文件名列表
        version: schema 版本号（如 "DSP8010_2025.4"）
        zip_subdir: zip 中的子目录（如 "csdl" 或 "json-schema"）
        target_dir: 目标目录路径
    """
    for filename in file_list:
        zip_filepath = os.path.join(version, zip_subdir, filename)
        local_filename = filename.lower()
        target_path = os.path.join(target_dir, local_filename)
        with open(target_path, "wb") as f:
            content = zip_ref.read(zip_filepath)
            content = content.replace(b"\r\n", b"\n")
            f.write(content)


def extract_version_from_schema_file(schema_path: str) -> str | None:
    """从 JSON schema 文件中提取最新版本

    Args:
        schema_path: JSON schema 文件路径

    Returns:
        版本字符串，如 "v1_15_1"，如果提取失败返回 None
    """
    try:
        with open(schema_path, "r", encoding="utf-8") as f:
            schema = json.load(f)

        # 从 $ref 列表中提取版本
        # 格式: "http://redfish.dmtf.org/schemas/v1/AccountService.v1_15_1.json"
        if "definitions" in schema:
            for def_value in schema["definitions"].values():
                if "anyOf" in def_value:
                    versions = []
                    for ref in def_value["anyOf"]:
                        if "$ref" in ref:
                            ref_url = ref["$ref"]
                            # 提取版本号，如 AccountService.v1_15_1.json -> v1_15_1
                            match = re.search(r"\.v(\d+_\d+_\d+)\.json", ref_url)
                            if match:
                                versions.append(match.group(1))

                    if versions:
                        # 返回最新版本（版本号排序）
                        versions.sort(
                            key=lambda v: [int(x) for x in v.split("_")],
                            reverse=True
                        )
                        # 返回带 v 前缀的版本号
                        return "v" + versions[0]
        return None
    except (json.JSONDecodeError, IOError, KeyError):
        return None


def get_latest_versions(json_schema_path: str) -> dict[str, str]:
    """获取所有 JSON schema 的最新版本映射

    Args:
        json_schema_path: JSON schema 目录路径

    Returns:
        类型名到版本号的映射，如 {"accountservice": "v1_15_1"}
    """
    type_to_version = {}

    if not os.path.exists(json_schema_path):
        return type_to_version

    for filename in os.listdir(json_schema_path):
        if filename.endswith(".json"):
            # 只处理无版本的 schema 文件（如 accountservice.json）
            base = filename[:-5]
            if "." not in base:
                type_name = base.lower()
                schema_path = os.path.join(json_schema_path, filename)
                version = extract_version_from_schema_file(schema_path)
                if version:
                    type_to_version[type_name] = version

    return type_to_version


def update_odata_type_in_file(file_path: str, type_to_version: dict[str, str]) -> bool:
    """更新 JSON 文件中的 @odata.type 版本

    Args:
        file_path: JSON 文件路径
        type_to_version: 类型名到版本号的映射

    Returns:
        是否进行了更新
    """
    try:
        with open(file_path, "r", encoding="utf-8") as f:
            content = f.read()

        # 解析 JSON 以保持格式
        data = json.loads(content)

        updated = False
        modified_content = content

        # 正则匹配 @odata.type 字段并更新版本
        # 格式: "@odata.type": "#AccountService.v1_15_1.AccountService"
        pattern = r'("@odata.type"\s*:\s*")(#\w+)\.v\d+_\d+_\d+(\.\w+")'

        def replace_version(match):
            nonlocal updated
            prefix = match.group(1)  # "@odata.type": "
            type_name = match.group(2)  # #AccountService
            suffix = match.group(3)  # .AccountService"

            # 提取纯类型名（去除 # 前缀）
            pure_type_name = type_name.lstrip("#").lower()

            if pure_type_name in type_to_version:
                new_version = type_to_version[pure_type_name]
                new_value = f'{prefix}{type_name}.{new_version}{suffix}'
                updated = True
                return new_value
            return match.group(0)

        modified_content = re.sub(pattern, replace_version, modified_content)

        if updated:
            with open(file_path, "w", encoding="utf-8") as f:
                f.write(modified_content)
            return True

        return False
    except (json.JSONDecodeError, IOError):
        return False


def update_mapping_config(mapping_config_dir: str, type_to_version: dict[str, str]):
    """更新 mapping_config 目录下所有 JSON 文件中的 @odata.type 版本

    Args:
        mapping_config_dir: mapping_config 目录路径
        type_to_version: 类型名到版本号的映射
    """
    if not os.path.exists(mapping_config_dir):
        print(f"mapping_config 目录不存在: {mapping_config_dir}")
        return

    print(f"\n开始更新 mapping_config 目录: {mapping_config_dir}")
    print(f"版本映射: {len(type_to_version)} 个类型")

    updated_count = 0
    total_count = 0

    for root, _, files in os.walk(mapping_config_dir):
        for filename in files:
            if filename.endswith(".json"):
                total_count += 1
                file_path = os.path.join(root, filename)
                if update_odata_type_in_file(file_path, type_to_version):
                    updated_count += 1
                    rel_path = os.path.relpath(file_path, mapping_config_dir)
                    print(f"  已更新: {rel_path}")

    print(f"\n更新完成: 共检查 {total_count} 个文件，更新了 {updated_count} 个文件")


def extract_namespaces_from_json_schema(json_schema_dir: str, type_name: str) -> list[str]:
    """从 JSON schema 目录中提取实际存在的版本化文件对应的 Namespace 列表

    Args:
        json_schema_dir: JSON schema 目录路径
        type_name: 资源类型名（如 "accountservice"）

    Returns:
        Namespace 列表，如 ["AccountService", "AccountService.v1_0_2", "AccountService.v1_1_0"]
    """
    namespaces = []

    if not os.path.exists(json_schema_dir):
        return namespaces

    # 首先从无版本的 JSON schema 文件中提取正确的驼峰类型名
    # 如: accountservice.json -> AccountService
    proper_type_name = None  # 正确的驼峰类型名
    no_version_file = f"{type_name}.json"
    no_version_path = os.path.join(json_schema_dir, no_version_file)

    if os.path.exists(no_version_path):
        try:
            with open(no_version_path, "r", encoding="utf-8") as f:
                schema = json.load(f)

            # 尝试从 title 中提取，格式如 "#AccountService.AccountService"
            if "title" in schema:
                title = schema["title"]
                if title.startswith("#"):
                    title = title[1:]
                    # 提取第一个点之前的部分，如 "AccountService.AccountService" -> "AccountService"
                    proper_type_name = title.split(".")[0]

            # 如果 title 中没有，尝试从 definitions 的 key 中提取
            if not proper_type_name and "definitions" in schema:
                for def_key in schema["definitions"].keys():
                    # 第一个 definitions key 通常是正确的类型名
                    proper_type_name = def_key
                    break
        except (json.JSONDecodeError, IOError, KeyError):
            pass

    # 如果没有找到正确的驼峰类型名，使用首字母大写的格式
    if not proper_type_name:
        proper_type_name = type_name.capitalize()

    # 遍历 JSON schema 目录，查找所有版本化的 schema 文件
    for filename in os.listdir(json_schema_dir):
        if filename.endswith(".json"):
            base = filename[:-5]  # 移除 .json

            # 匹配版本化文件，如 Name.v1_2_3
            match = re.match(r"(.+)\.v(\d+_\d+_\d+)$", base, re.IGNORECASE)
            if match:
                file_type_name = match.group(1).lower()
                # 只处理与目标类型匹配的文件
                if file_type_name == type_name:
                    version = match.group(2)
                    namespace = f"{proper_type_name}.v{version}"
                    namespaces.append(namespace)

    if not namespaces:
        return []

    # 添加基础 Namespace（不带版本号）
    has_base = any("." not in ns for ns in namespaces)
    if not has_base:
        namespaces.insert(0, proper_type_name)

    return sorted(set(namespaces))


def get_xml_to_namespaces_mapping(
    csdl_dir: str, json_schema_dir: str
) -> dict[str, list[str]]:
    """获取 XML 文件到 Namespace 列表的映射

    Args:
        csdl_dir: CSDL (XML) 文件目录
        json_schema_dir: JSON schema 文件目录

    Returns:
        XML 文件名到 Namespace 列表的映射
        如 {"accountservice_v1.xml": ["AccountService", "AccountService.v1_0_2", ...]}
    """
    mapping = {}

    if not os.path.exists(csdl_dir) or not os.path.exists(json_schema_dir):
        return mapping

    # 首先获取 CSDL 目录中所有已存在的 XML 文件集合
    existing_xml_files = set()
    for xml_filename in os.listdir(csdl_dir):
        if xml_filename.endswith(".xml"):
            type_name = parse_resource_type_from_xml_name(xml_filename)
            existing_xml_files.add((type_name, xml_filename))

    # 遍历 JSON schema 目录，只为存在 JSON schema 的类型生成映射
    for json_filename in os.listdir(json_schema_dir):
        if json_filename.endswith(".json"):
            # 从 JSON 文件名提取类型名（如 accountservice.json -> accountservice）
            type_name = parse_resource_type_from_json_name(json_filename)

            # 查找对应的 XML 文件
            matching_xml = None
            for xml_type_name, xml_filename in existing_xml_files:
                if xml_type_name == type_name:
                    matching_xml = xml_filename
                    break

            if matching_xml:
                # 只处理无版本的 JSON schema 文件（如 accountservice.json）
                base = json_filename[:-5]
                if "." not in base:
                    # 从 json_schema_dir 中提取实际存在的版本化文件对应的 namespace
                    namespaces = extract_namespaces_from_json_schema(json_schema_dir, type_name)
                    if namespaces:
                        mapping[matching_xml] = namespaces

    return mapping


def generate_reference_block(xml_filename: str, namespaces: list[str]) -> str:
    """生成 Reference 块的字符串

    Args:
        xml_filename: XML 文件名
        namespaces: Namespace 列表

    Returns:
        格式化的 Reference 块字符串
    """
    lines = []
    lines.append(f'  <edmx:Reference Uri="/redfish/v1/Schemas/{xml_filename}">')
    for namespace in sorted(namespaces):
        lines.append(f'    <edmx:Include Namespace="{namespace}"/>')
    lines.append('  </edmx:Reference>')
    return '\n'.join(lines)


def update_metadata_index_xml(metadata_index_path: str, xml_to_namespaces: dict[str, list[str]]):
    """更新 metadata/index.xml 文件

    为每个 XML 文件添加或更新 <edmx:Reference> 元素及其 <edmx:Include> 子元素

    Args:
        metadata_index_path: metadata/index.xml 文件路径
        xml_to_namespaces: XML 文件名到 Namespace 列表的映射
    """
    if not os.path.exists(metadata_index_path):
        print(f"metadata/index.xml 文件不存在: {metadata_index_path}")
        return

    if not xml_to_namespaces:
        print("没有需要更新的 XML 文件")
        return

    print(f"\n开始更新 metadata/index.xml: {metadata_index_path}")
    print(f"需要处理的 XML 文件: {len(xml_to_namespaces)} 个")

    # 读取原始文件内容
    with open(metadata_index_path, "r", encoding="utf-8") as f:
        content = f.read()

    # 统计
    added_count = 0
    updated_count = 0

    # 用于收集需要添加的新 Reference（按字母顺序）
    new_refs = {}

    # 收集所有需要更新的替换操作（从后往前替换，避免位置偏移）
    replacements = []  # (start, end, replacement)

    # 正则表达式匹配 Reference 块及其前导空格
    # 匹配从行首开始（包括前导空格）到 </edmx:Reference> 结束的完整块
    ref_pattern = re.compile(
        r'([ \t]*)<edmx:Reference\s+Uri="/redfish/v1/Schemas/([^"]+)">(.*?)</edmx:Reference>',
        re.DOTALL
    )

    # 查找所有已存在的 Reference
    for match in ref_pattern.finditer(content):
        leading_spaces = match.group(1)  # 前导空格
        original_filename = match.group(2)  # 原始文件名

        # 检查是否需要更新
        if original_filename.lower() in [k.lower() for k in xml_to_namespaces.keys()]:
            # 找到对应的 key（处理大小写）
            key = next(k for k in xml_to_namespaces.keys() if k.lower() == original_filename.lower())
            namespaces = xml_to_namespaces[key]

            # 生成新的 Reference 块（已包含正确的 2 空格缩进）
            new_block = generate_reference_block(original_filename, namespaces)

            # 比较内部内容是否一致
            old_inner = match.group(3).strip()
            new_inner = '\n'.join(new_block.split('\n')[1:-1]).strip()  # 提取新块的内部内容

            if old_inner != new_inner:
                # 记录替换操作（替换前导空格 + 旧块，只保留 new_block）
                # new_block 已包含正确的 2 空格缩进，不需要额外添加前导空格
                replacements.append((match.start(), match.end(), new_block))
                updated_count += 1
                print(f"  已更新: {original_filename} ({len(namespaces)} namespaces)")

            # 标记为已处理
            xml_to_namespaces.pop(key, None)

    # 执行替换（从后往前，避免位置偏移）
    for start, end, replacement in reversed(replacements):
        content = content[:start] + replacement + content[end:]

    # 处理剩余的需要添加的 Reference
    if xml_to_namespaces:
        # 找到 DataServices 的位置，在它之前插入新 Reference
        data_services_pattern = re.compile(r'(\s*)<edmx:DataServices>', re.MULTILINE)
        match = data_services_pattern.search(content)

        if match:
            indent = match.group(1)  # 获取缩进

            # 生成所有新 Reference 块
            new_blocks = []
            for xml_filename, namespaces in sorted(xml_to_namespaces.items()):
                new_block = generate_reference_block(xml_filename, namespaces)
                new_blocks.append(new_block)
                added_count += 1
                print(f"  已添加: {xml_filename} ({len(namespaces)} namespaces)")

            # 在 DataServices 之前插入
            if new_blocks:
                insert_text = "\n\n".join(new_blocks) + "\n\n"
                content = content[:match.start()] + insert_text + content[match.start():]

    # 写回文件
    with open(metadata_index_path, "w", encoding="utf-8") as f:
        f.write(content)

    print(f"\n更新完成: 添加 {added_count} 个，更新 {updated_count} 个")


def main():
    """主函数"""
    args = parse_args()

    # 获取项目根目录（tools 的父目录）
    project_root = os.path.dirname(os.path.dirname(SCRIPT_DIR))

    # 根据来源获取 zip 文件内容
    if args.source == "remote":
        proxies = {"https": os.environ.get("https_proxy", None)}
        url = f"https://www.dmtf.org/sites/default/files/standards/documents/{args.version}.zip"
        print(f"从远程下载: {url}")
        r = requests.get(url, proxies=proxies, verify=False)
        r.raise_for_status()
        zip_content = r.content
        version = args.version
    else:  # local
        if not os.path.exists(args.zip_path):
            print(f"错误: 本地 zip 文件不存在: {args.zip_path}")
            return 1
        print(f"从本地读取: {args.zip_path}")

        # 从 zip 文件名中提取版本号
        # 如: /path/to/DSP8010_2025.4.zip -> DSP8010_2025.4
        zip_filename = os.path.basename(args.zip_path)
        if zip_filename.endswith(".zip"):
            version = zip_filename[:-4]
        else:
            print("错误: zip 文件名必须以 .zip 结尾")
            return 1
        print(f"从文件名中提取版本号: {version}")

        with open(args.zip_path, "rb") as f:
            zip_content = f.read()

    # 根据 --output-dir 参数确定目标目录
    if args.output_dir:
        if os.path.isabs(args.output_dir):
            target_dir = args.output_dir
        else:
            # 相对于项目根目录
            target_dir = os.path.join(project_root, args.output_dir)
    else:
        # 默认使用 schemastore 下的 en/dmtf 目录
        target_dir = os.path.join(
            project_root, "interface_config", "redfish", "static_resource",
            "redfish", "v1", "schemastore", "en", "dmtf"
        )

    dmtf_path = os.path.realpath(target_dir)

    # 如果目标目录不存在，创建它
    if not os.path.exists(dmtf_path):
        print(f"目标目录不存在，正在创建: {dmtf_path}")
        os.makedirs(dmtf_path, exist_ok=True)
        print(f"目录创建成功")

    target_schema_path = os.path.join(dmtf_path, "csdl")
    target_json_schema_path = os.path.join(dmtf_path, "json_schema")

    # 本地已存在的资源目录（用于过滤）
    local_csdl_dir = os.path.join(
        project_root, "interface_config", "redfish", "static_resource",
        "redfish", "v1", "schemastore", "en", "dmtf", "csdl"
    )
    local_json_schema_dir = os.path.join(
        project_root, "interface_config", "redfish", "static_resource",
        "redfish", "v1", "schemastore", "en", "dmtf", "json_schema"
    )

    # 获取本地已存在的 CSDL 资源类型
    local_csdl_types = set()
    if os.path.exists(local_csdl_dir):
        for f in os.listdir(local_csdl_dir):
            if f.endswith(".xml"):
                local_csdl_types.add(parse_resource_type_from_xml_name(f))

    # 获取本地已存在的 JSON schema 资源类型
    local_json_types = set()
    local_json_files = set()  # 记录完整的文件名
    if os.path.exists(local_json_schema_dir):
        for f in os.listdir(local_json_schema_dir):
            if f.endswith(".json"):
                local_json_types.add(parse_resource_type_from_json_name(f))
                local_json_files.add(f.lower())

    print(f"本地已存在的 CSDL 资源类型: {len(local_csdl_types)} 个")
    print(f"本地已存在的 JSON schema 资源类型: {len(local_json_types)} 个")
    print(f"本地已存在的 JSON schema 文件: {len(local_json_files)} 个")
    print(f"使用版本号: {version}")

    zip_buffer = BytesIO(zip_content)
    zip_ref = zipfile.ZipFile(zip_buffer)

    class RedfishSchemaVersion:
        """
        A Python class for sorting Redfish schema versions.  Allows sorting Redfish
        versions in the way humans expect, by comparing version strings as lists
        (ie 0_2_0 comes before 0_10_0) in the way humans expect.  It does case
        insensitive schema name comparisons
        """

        def __init__(self, key):
            key = str.casefold(key)

            split_tup = key.split(".")
            self.version_pieces = [split_tup[0]]
            if len(split_tup) < 2:
                return
            version = split_tup[1]

            if version.startswith("v"):
                version = version[1:]
            if any(char.isdigit() for char in version):
                self.version_pieces.extend([int(x) for x in version.split("_")])

        def __lt__(self, other):
            return self.version_pieces < other.version_pieces

    # 清理并创建 schema 目录
    # CSDL (XML) 文件直接覆盖，删除整个目录重建
    if os.path.exists(target_schema_path):
        shutil.rmtree(target_schema_path)
    os.makedirs(target_schema_path, exist_ok=True)

    # JSON schema 文件保留历史版本，只创建目录（如果不存在）
    os.makedirs(target_json_schema_path, exist_ok=True)

    csdl_file_list = []
    # 按类型组织 JSON 文件，用于后续选择最新版本
    json_schema_by_type = defaultdict(list)

    for zip_file in zip_ref.infolist():
        if zip_file.is_dir():
            continue
        if zip_file.filename.startswith(version + "/csdl/"):
            filename = os.path.basename(zip_file.filename)
            type_name = parse_resource_type_from_xml_name(filename)
            # 只保留本地已存在的资源
            if type_name in local_csdl_types:
                csdl_file_list.append(filename)
        elif zip_file.filename.startswith(version + "/json-schema/"):
            filename = os.path.basename(zip_file.filename)
            type_name = parse_resource_type_from_json_name(filename)
            # JSON 文件不受本地限制，获取所有匹配类型的文件
            if type_name in local_json_types:
                json_schema_by_type[type_name].append(filename)
        elif zip_file.filename.startswith(version + "/openapi/"):
            pass
        elif zip_file.filename.startswith(version + "/dictionaries/"):
            pass

    # 确定要下载的 JSON schema 文件
    json_schema_download_list = []
    for type_name, versions in json_schema_by_type.items():
        # 分离无版本文件和有版本文件
        versioned_files = [f for f in versions if "." in f[:-5]]
        no_version_file = next((f for f in versions if "." not in f[:-5]), None)

        # 对版本化文件按版本排序，只下载最新版本（保留历史版本）
        # 这样本地已有的旧版本会被保留，同时获取远程的最新版本
        if versioned_files:
            versioned_files.sort(key=RedfishSchemaVersion, reverse=True)
            json_schema_download_list.append(versioned_files[0])

        # 如果本地有无版本文件，且远程也有，添加它（直接覆盖）
        if no_version_file and any(f == type_name + ".json" for f in local_json_files):
            json_schema_download_list.append(no_version_file)

    print(f"从远程获取的 CSDL 文件: {len(csdl_file_list)} 个")
    print(f"从远程获取的 JSON schema 文件: {len(json_schema_download_list)} 个")

    # 提取 CSDL 文件
    extract_schema_files(zip_ref, csdl_file_list, version, "csdl", target_schema_path)

    # 提取 JSON schema 文件
    extract_schema_files(zip_ref, json_schema_download_list, version, "json-schema", target_json_schema_path)

    zip_ref.close()

    # 后处理：更新 mapping_config 目录中的 @odata.type 版本
    if args.update_odata_type:
        type_to_version = get_latest_versions(target_json_schema_path)
        if type_to_version:
            # mapping_config 目录相对于项目根目录
            mapping_config_dir = os.path.join(
                project_root, "interface_config", "redfish", "mapping_config"
            )
            update_mapping_config(mapping_config_dir, type_to_version)
    else:
        print("\n跳过 mapping_config 目录的 @odata.type 版本更新")
        
    # 后处理：更新 metadata/index.xml
    if args.update_metadata:
        # 获取 XML 文件到 Namespace 的映射
        xml_to_namespaces = get_xml_to_namespaces_mapping(target_schema_path, target_json_schema_path)
        if xml_to_namespaces:
            # metadata/index.xml 路径
            metadata_index_path = os.path.join(
                project_root, "interface_config", "redfish", "static_resource",
                "redfish", "v1", "metadata", "index.xml"
            )
            update_metadata_index_xml(metadata_index_path, xml_to_namespaces)
    else:
        print("\n跳过 metadata/index.xml 的更新")


if __name__ == "__main__":
    main()
