bgi-scripts/build/validate.py

#!/usr/bin/python
# -*- coding: utf-8 -*-
import json
import os
import subprocess
import re
import chardet
from packaging.version import parse
from semver import VersionInfo

# ==================== 配置和常量 ====================

# 定义有效的 type 和 move_mode 值
VALID_TYPES = ["teleport", "path", "target", "orientation"]
VALID_MOVE_MODES = ["swim", "walk", "fly", "climb", "run", "dash", "jump"]

# 定义 action 和 action_params 的最低兼容版本
ACTION_VERSION_MAP = {
    "fight": "0.42.0",
    "mining": "0.43.0",
    "fishing": "0.43.0",
    "force_tp": "0.42.0",
    "log_output": "0.42.0",
    "anemo_collect": "0.42.0",
    "combat_script": "0.42.0",
    "hydro_collect": "0.42.0",
    "pick_around": "0.42.0",
    "pyro_collect": "0.43.0",
    "stop_flying": "0.42.0",
    "normal_attack": "0.42.0",
    "electro_collect": "0.42.0",
    "nahida_collect": "0.42.0",
    "up_down_grab_leaf": "0.42.0",
    "set_time": "0.45.0",
    "exit_and_relogin": "0.46.0",
    "use_gadget": "0.48.1"
}

# 定义 action_params 的最低兼容版本和正则表达式验证
ACTION_PARAMS_VERSION_MAP = {
    "stop_flying": {
        "params": {"version": "0.44.0", "regex": r"^\d+(\.\d+)?$"}
    },
    "pick_around": {
        "params": {"version": "0.42.0", "regex": r"^\d+$"}
    },
    "combat_script": {
        "params": {"version": "0.42.0", "regex": r"^.+$"}  # 任意非空字符串
    },
    "log_output": {
        "params": {"version": "0.42.0", "regex": r"^.+$"}  # 任意非空字符串
    }
    # 其他 action 类型没有明确的 action_params 格式要求
}

# 默认版本号
DEFAULT_BGI_VERSION = "0.42.0"
DEFAULT_VERSION = "1.0"

# ==================== 文件操作 ====================

def get_original_file(file_path):
    """从上游仓库获取原始文件内容，如果失败则尝试从本地获取"""
    # 返回值增加一个来源标识: "upstream", "pr_submitted", None

    try:
        result = subprocess.run(['git', 'show', f'upstream/main:{file_path}'],
                                capture_output=True, text=True, encoding='utf-8')
        if result.returncode == 0:
            return json.loads(result.stdout), "upstream"
    except Exception as e:
        print(f"从上游仓库获取原始文件失败: {str(e)}")

    try:
        with open(file_path, 'r', encoding='utf-8') as f:
            current_data = json.load(f)
            # 创建一个副本，避免引用相同的对象
            return json.loads(json.dumps(current_data)), "pr_submitted"
    except Exception as e:
        print(f"读取当前文件失败: {str(e)}")

    return None, None

def load_json_file(file_path):
    """加载 JSON 文件"""
    try:
        with open(file_path, encoding='utf-8') as f:
            return json.load(f), None
    except Exception as e:
        return None, f"❌ JSON 格式错误: {str(e)}"

def save_json_file(file_path, data):
    """保存 JSON 文件"""
    try:
        with open(file_path, 'w', encoding='utf-8') as f:
            json.dump(data, f, indent=2, ensure_ascii=False)
        return True
    except Exception as e:
        print(f"保存文件失败: {str(e)}")
        return False

# ==================== 版本处理 ====================

def process_version(current, original, is_new):
    """处理版本号更新逻辑"""
    if is_new:
        return DEFAULT_VERSION

    if not original:
        return DEFAULT_VERSION

    try:
        cv = parse(current)
        ov = parse(original)
        # 强制更新版本号，无论当前版本是否大于原始版本
        return f"{ov.major}.{ov.minor + 1}"
    except Exception:
        # 如果解析失败，尝试简单的数字处理
        parts = original.split('.')
        if len(parts) >= 2:
            try:
                major = int(parts[0])
                minor = int(parts[1])
                return f"{major}.{minor + 1}"
            except ValueError:
                pass
        return f"{original}.1"

def extract_required_version(compatibility_issues):
    """从兼容性问题中提取所需的最高版本号"""
    required_versions = []
    for issue in compatibility_issues:
        parts = issue.split(">=")
        if len(parts) > 1:
            version_part = parts[1].split(",")[0].strip()
            version_match = re.search(r'(\d+\.\d+\.\d+)', version_part)
            if version_match:
                required_versions.append(version_match.group(1))

    if not required_versions:
        return None

    try:
        return max(required_versions, key=lambda v: VersionInfo.parse(v))
    except ValueError:
        return None

def parse_bgi_version(version_str):
    """解析 BGI 版本号"""
    try:
        # 确保删除 v 前缀
        return VersionInfo.parse(version_str.lstrip('v'))
    except ValueError:
        return None

# ==================== 字段验证 ====================

def check_action_compatibility(action_type, action_params, bgi_version):
    """检查 action 和 action_params 与 BGI 版本的兼容性"""
    issues = []
    validation_issues = []

    # 如果 action_type 为空，则跳过检查
    if not action_type:
        return issues, validation_issues

    # 确保 bgi_version 是有效的格式
    bgi_ver = parse_bgi_version(bgi_version)
    if not bgi_ver:
        validation_issues.append(f"无效的 bgi_version 格式: {bgi_version}")
        return issues, validation_issues

    # 检查 action 兼容性
    if action_type in ACTION_VERSION_MAP:
        min_version = ACTION_VERSION_MAP[action_type]
        try:
            if bgi_ver < VersionInfo.parse(min_version):
                issues.append(f"action '{action_type}' 需要 BGI 版本 >= {min_version}，当前为 {bgi_version}")
        except ValueError:
            validation_issues.append(f"无法比较版本: {min_version} 与 {bgi_version}")
    else:
        validation_issues.append(f"未知的 action 类型: '{action_type}'，已知类型: {', '.join(sorted(ACTION_VERSION_MAP.keys()))}")

    # 检查 action_params 兼容性和格式
    if action_type in ACTION_PARAMS_VERSION_MAP and action_params:
        param_info = ACTION_PARAMS_VERSION_MAP[action_type]["params"]
        min_version = param_info["version"]
        regex_pattern = param_info["regex"]

        # 版本兼容性检查
        try:
            if bgi_ver < VersionInfo.parse(min_version):
                issues.append(f"action '{action_type}' 的参数需要 BGI 版本 >= {min_version}，当前为 {bgi_version}")
        except ValueError:
            validation_issues.append(f"无法比较版本: {min_version} 与 {bgi_version}")

        # 参数格式验证
        if not re.match(regex_pattern, str(action_params)):
            validation_issues.append(f"action '{action_type}' 的参数格式不正确: '{action_params}'，应匹配模式: {regex_pattern}")

    return issues, validation_issues

def process_coordinates(positions):
    """统一处理坐标保留两位小数逻辑"""
    coord_changed = False
    for pos in positions:
        for axis in ['x', 'y']:
            if axis in pos and isinstance(pos[axis], (int, float)):
                original = pos[axis]
                pos[axis] = round(float(pos[axis]), 4)
                if original != pos[axis]:
                    coord_changed = True
    return coord_changed

def ensure_required_fields(info, filename):
    """统一处理必要字段检查逻辑"""
    corrections = []

    if info["name"] != filename:
        info["name"] = filename
        corrections.append(f"name 自动修正为 {filename}")

    if info["type"] not in ["collect", "fight"]:
        info["type"] = "collect"
        corrections.append("type 自动修正为 collect")

    if not info["authors"]:
        author_name = os.getenv("GITHUB_ACTOR", "未知作者")
        author_link = "https://github.com/" + os.getenv("GITHUB_ACTOR", "babalae/bettergi-scripts-list")
        info["authors"] = [{"name": author_name, "links": author_link}]
        corrections.append(f"authors 自动设置为 {info['authors']}")

    return corrections

def check_position_fields(positions):
    """检查位置字段的有效性

    自动修复功能:
    1. 缺少 type 字段时，自动设置为 'path'
    2. type 字段无效时，自动修正为 'path'
    3. 当 type 为 'path' 或 'target' 且缺少 move_mode 时，自动设置为 'walk'
    4. move_mode 字段无效时，自动修正为 'walk'
    """
    validation_issues = []
    notices = []
    corrections = []  # 添加修正列表

    for idx, pos in enumerate(positions):
        # 检查必需字段
        required_fields = ["x", "y", "type"]
        missing_fields = [field for field in required_fields if field not in pos]

        if missing_fields:
            validation_issues.append(f"位置 {idx+1} 缺少必需字段: {', '.join(missing_fields)}")
            # 自动添加缺失的 type 字段
            if "type" in missing_fields:
                pos["type"] = "path"  # 自动修复：缺少 type 字段时设置为 path
                corrections.append(f"位置 {idx+1} 缺少 type 字段，已设置为默认值 'path'")
                # 如果添加了 path 类型，也需要添加 move_mode
                if "move_mode" not in pos:
                    pos["move_mode"] = "walk"  # 自动修复：为 path 类型添加默认 move_mode
                    corrections.append(f"位置 {idx+1} 缺少 move_mode 字段，已设置为默认值 'walk'")
            # 移除 continue，确保后续检查能够执行
            # continue

        # 验证 type 字段
        if "type" in pos:
            pos_type = pos["type"]
            if pos_type not in VALID_TYPES:
                validation_issues.append(f"位置 {idx+1}: type '{pos_type}' 无效，有效值为: {', '.join(VALID_TYPES)}")
                # 自动修正无效的 type 字段
                pos["type"] = "path"  # 自动修复：无效 type 修正为 path
                corrections.append(f"位置 {idx+1} 的 type '{pos_type}' 无效，已修正为 'path'")
                pos_type = "path"  # 更新 pos_type 以便后续检查

            # 当 type 为 path 或 target 时，验证 move_mode
            if pos_type in ["path", "target"]:
                if "move_mode" not in pos:
                    validation_issues.append(f"位置 {idx+1}: type 为 '{pos_type}' 时必须指定 move_mode")
                    # 自动添加缺失的 move_mode
                    pos["move_mode"] = "walk"  # 自动修复：缺少 move_mode 时设置为 walk
                    corrections.append(f"位置 {idx+1} 缺少 move_mode 字段，已设置为默认值 'walk'")
                elif pos["move_mode"] not in VALID_MOVE_MODES:
                    validation_issues.append(f"位置 {idx+1}: move_mode '{pos['move_mode']}' 无效，有效值为: {', '.join(VALID_MOVE_MODES)}")
                    # 自动修正无效的 move_mode
                    pos["move_mode"] = "walk"  # 自动修复：无效 move_mode 修正为 walk
                    corrections.append(f"位置 {idx+1} 的 move_mode '{pos['move_mode']}' 无效，已修正为 'walk'")

        # 检查第一个位置是否为 teleport
        if idx == 0 and pos.get("type") != "teleport":
            notices.append("⚠️ 第一个 position 的 type 不是 teleport")

    return validation_issues, notices, corrections

def check_bgi_version_compatibility(bgi_version, auto_fix=False):
    """检查 BGI 版本兼容性"""
    corrections = []

    # 删除可能存在的 v 前缀
    if bgi_version.startswith('v'):
        bgi_version = bgi_version.lstrip('v')
        corrections.append(f"bgi_version 前缀 'v' 已删除")

    bgi_ver = parse_bgi_version(bgi_version)

    if not bgi_ver:
        if auto_fix:
            corrections.append(f"bgi_version {bgi_version} 格式无效，自动更新为 {DEFAULT_BGI_VERSION}")
            return DEFAULT_BGI_VERSION, corrections
        return bgi_version, []

    if bgi_ver < VersionInfo.parse(DEFAULT_BGI_VERSION):
        if auto_fix:
            corrections.append(f"bgi_version {bgi_version} 自动更新为 {DEFAULT_BGI_VERSION} (原版本低于要求)")
            return DEFAULT_BGI_VERSION, corrections

    return bgi_version, corrections

def check_position_ids(positions):
    """检查并修复位置 ID 编编号的连续性
    
    自动修复功能:
    1. 缺少 id 字段时，自动按顺序添加
    2. id 编号不连续时，自动重新排序
    3. id 不是从 1 开始时，自动调整
    4. id 值无效（非数字）时，自动修正
    """
    corrections = []
    validation_issues = []
    
    if not positions:
        return validation_issues, corrections
    
    # 检查是否所有位置都有 id 字段，并收集现有 id 值
    current_ids = []
    missing_ids = []
    invalid_ids = []
    
    for idx, pos in enumerate(positions):
        if "id" not in pos:
            missing_ids.append(idx)
            current_ids.append(None)
        else:
            try:
                id_val = int(pos["id"])
                current_ids.append(id_val)
            except (ValueError, TypeError):
                # 如果 id 不是数字，记录为无效
                invalid_ids.append(idx)
                current_ids.append(None)
    
    # 如果有缺少 id 的位置，记录
    if missing_ids:
        corrections.append(f"为 {len(missing_ids)} 个位置自动添加了 id 字段")
    
    # 如果有无效 id，记录
    if invalid_ids:
        corrections.append(f"修正了 {len(invalid_ids)} 个无效的 id 值")
    
    # 生成期望的 id 序列（从 1 开始）
    expected_ids = list(range(1, len(positions) + 1))
    
    # 检查当前 id 是否符合期望
    needs_reorder = False
    
    # 过滤掉 None 值来检查现有的有效 id
    valid_current_ids = [id_val for id_val in current_ids if id_val is not None]
    
    if len(valid_current_ids) != len(positions):
        needs_reorder = True
    elif valid_current_ids != expected_ids:
        needs_reorder = True
    else:
        # 检查是否有重复的 id
        if len(set(valid_current_ids)) != len(valid_current_ids):
            needs_reorder = True
            duplicates = [id_val for id_val in set(valid_current_ids) if valid_current_ids.count(id_val) > 1]
            corrections.append(f"检测到重复的 id: {duplicates}")
      # 如果需要重新排序，自动修复
    if needs_reorder:
        id_issues = []
        
        # 分析具体问题
        if missing_ids or invalid_ids:
            if missing_ids:
                id_issues.append("存在缺少id的位置")
            if invalid_ids:
                id_issues.append("存在无效id值")
        
        if valid_current_ids:
            if min(valid_current_ids) != 1:
                id_issues.append("id不是从1开始")
            
            # 检查连续性
            sorted_valid_ids = sorted(valid_current_ids)
            expected_sorted = list(range(1, len(valid_current_ids) + 1))
            if sorted_valid_ids != expected_sorted:
                id_issues.append("id编号不连续")
        
        # 重新按顺序分配 id，并将 id 字段放在第一个位置
        for idx, pos in enumerate(positions):
            new_id = idx + 1
            # 创建新的有序字典，id 放在第一个
            new_pos = {"id": new_id}
            # 添加其他字段
            for key, value in pos.items():
                if key != "id":
                    new_pos[key] = value
            # 更新原位置
            pos.clear()
            pos.update(new_pos)
        
        if id_issues:
            corrections.append(f"id编号已重新排序并置于首位 (问题: {', '.join(id_issues)})")
        else:
            corrections.append("id编号已按顺序重新分配并置于首位")
    
    return validation_issues, corrections

# ==================== 验证修复文件编码 ====================

def detect_encoding(file_path, read_size=2048):
    try:
        with open(file_path, 'rb') as f:
            raw = f.read(read_size)
            result = chardet.detect(raw)
            return result['encoding'], result['confidence']
    except:
        return None, 0

def fix_encoding_name(enc, file_path=None):
    if not enc:
        return None
    enc = enc.lower()
    if enc in ['ascii']:
        try:
            with open(file_path, 'rb') as f:
                raw = f.read()
                raw.decode('utf-8')
            return 'utf-8'
        except:
            return 'gb18030'
    if enc in ['gb2312', 'gbk', 'windows-1252', 'iso-8859-1', 'gb18030']:
        return 'gb18030'
    return enc

def convert_to_utf8(file_path, original_encoding):
    try:
        encoding = fix_encoding_name(original_encoding, file_path)

        with open(file_path, 'r', encoding=encoding, errors='replace') as f:
            content = f.read()
        with open(file_path, 'w', encoding='utf-8') as f:
            f.write(content)

        print(f"[✔] Converted to UTF-8: {file_path} (from {original_encoding} → {encoding})")
    except Exception as e:
        print(f"[✖] Failed to convert: {file_path} | Error: {e}")

def process_file(file_path, target_extensions=None):
    if target_extensions and not any(file_path.lower().endswith(ext) for ext in target_extensions):
        return
    encoding, confidence = detect_encoding(file_path)
    if encoding is None or confidence < 0.7:
        print(f"[⚠️] Unknown encoding: {file_path} | Detected: {encoding}, Conf: {confidence:.2f}")
        return
    if encoding.lower() == 'utf-8':
        return  # Skip already UTF-8
    convert_to_utf8(file_path, encoding)

def scan_and_convert(path, target_extensions=None):
    if os.path.isfile(path):
        process_file(path, target_extensions)
    elif os.path.isdir(path):
        for dirpath, _, filenames in os.walk(path):
            for filename in filenames:
                filepath = os.path.join(dirpath, filename)
                process_file(filepath, target_extensions)
    else:
        print(f"❌ Path not found: {path}")

# ==================== 验证修复作者信息 ====================

def process_json_authors(input_path, verbose=False):
    """
    处理 JSON 文件中的作者信息（支持 author → authors 结构化迁移、作者名重命名和链接统一）
    
    参数：
        input_path (str): 要处理的文件路径或目录路径
        config_path (str): 配置文件路径（默认在脚本同级）
        verbose (bool): 是否打印详细日志信息
        
    返回：
        dict: 包含处理总数和修改数量的统计信息
    """
    result = {
        "total_files": 0,
        "modified_files": 0,
        "errors": []
    }

    # 获取配置文件路径（和脚本在同一目录）
    script_dir = os.path.dirname(os.path.abspath(__file__))
    config_path = os.path.join(script_dir, "author_config.json")

    if not os.path.exists(input_path):
        raise FileNotFoundError(f"路径不存在：{input_path}")
    if not os.path.exists(config_path):
        raise FileNotFoundError(f"配置文件不存在：{config_path}")

    # 加载配置
    try:
        with open(config_path, "r", encoding="utf-8") as f:
            config = json.load(f)
    except Exception as e:
        raise RuntimeError(f"配置文件加载失败：{e}")

    author_rename = config.get("rename", {})
    author_links = config.get("links", {})

    # 构建待处理文件列表
    file_list = []
    if os.path.isfile(input_path) and input_path.endswith(".json"):
        file_list.append(input_path)
    elif os.path.isdir(input_path):
        for root, dirs, files in os.walk(input_path):
            for filename in files:
                if filename.endswith(".json"):
                    file_list.append(os.path.join(root, filename))
    else:
        raise ValueError("输入路径必须是 .json 文件或目录")

    for file_path in file_list:
        result["total_files"] += 1
        if verbose:
            print(f"\n🔍 处理文件：{file_path}")

        try:
            with open(file_path, "r", encoding="utf-8") as f:
                data = json.load(f)
        except Exception as e:
            msg = f"❌ 解析失败：{e}"
            if verbose:
                print(msg)
            result["errors"].append((file_path, str(e)))
            continue

        info = data.get("info")
        if not isinstance(info, dict):
            if verbose:
                print("⚠️ 缺少 info 字段")
            continue

        modified = False
        author_field = info.get("author")

        if author_field is not None:
            if isinstance(author_field, str):
                names = [name.strip() for name in author_field.split("&")]
                new_authors = []
                for name in names:
                    new_name = author_rename.get(name, name)
                    author_obj = {"name": new_name}
                    if new_name in author_links:
                        author_obj["links"] = author_links[new_name]
                    new_authors.append(author_obj)
                data["info"]["authors"] = new_authors
                modified = True
                if verbose:
                    print("✅ 替换为结构化 authors")

            elif isinstance(author_field, list):
                for author_obj in author_field:
                    if not isinstance(author_obj, dict):
                        continue
                    name = author_obj.get("name")
                    if not name:
                        continue
                    new_name = author_rename.get(name, name)
                    if name != new_name:
                        author_obj["name"] = new_name
                        modified = True
                        if verbose:
                            print(f"📝 重命名：{name} → {new_name}")

                    existing_link = author_obj.pop("link", None) or author_obj.pop("url", None) or author_obj.get("links")
                    if new_name in author_links:
                        if author_obj.get("links") != author_links[new_name]:
                            author_obj["links"] = author_links[new_name]
                            modified = True
                            if verbose:
                                print(f"🔧 更新链接：{new_name} → {author_links[new_name]}")
                    elif "links" not in author_obj and existing_link:
                        author_obj["links"] = existing_link
                        modified = True
                        if verbose:
                            print(f"🔄 标准化已有链接字段为 links → {existing_link}")

        else:
            authors_field = info.get("authors")
            if isinstance(authors_field, list):
                for author_obj in authors_field:
                    if not isinstance(author_obj, dict):
                        continue
                    name = author_obj.get("name")
                    if not name:
                        continue
                    new_name = author_rename.get(name, name)
                    if name != new_name:
                        author_obj["name"] = new_name
                        modified = True
                        if verbose:
                            print(f"📝 重命名（authors）：{name} → {new_name}")

                    existing_link = author_obj.pop("link", None) or author_obj.pop("url", None) or author_obj.get("links")
                    if new_name in author_links:
                        if author_obj.get("links") != author_links[new_name]:
                            author_obj["links"] = author_links[new_name]
                            modified = True
                            if verbose:
                                print(f"🔧 更新链接（authors）：{new_name} → {author_links[new_name]}")
                    elif "links" not in author_obj and existing_link:
                        author_obj["links"] = existing_link
                        modified = True
                        if verbose:
                            print(f"🔄 标准化已有链接字段为 links → {existing_link}")
            else:
                # if verbose:
                    print("⚠️ 缺少 author 字段，且 authors 非标准格式")

        if modified:
            with open(file_path, "w", encoding="utf-8") as f:
                json.dump(data, f, ensure_ascii=False, indent=2)
            result["modified_files"] += 1
            if verbose:
                print("✅ 写入完成")
        else:
            if verbose:
                print("⏭️ 无需修改")

    if verbose:
        print(f"\n🎉 处理完成：共 {result['total_files']} 个 JSON 文件，修改了 {result['modified_files']} 个")

# ==================== 主验证逻辑 ====================

def initialize_data(data, file_path):
    """初始化数据结构，确保必要字段存在"""
    messages = []

    if "info" not in data:
        data["info"] = {}
        messages.append(f"⚠️ 文件缺少 info 字段，已添加默认值")

    info = data["info"]
    filename = os.path.splitext(os.path.basename(file_path))[0]

    # 检查并添加必要的字段
    if "name" not in info:
        info["name"] = filename
        messages.append(f"⚠️ 文件缺少 name 字段，已设置为文件名: {info['name']}")

    if "type" not in info:
        info["type"] = "collect"
        messages.append(f"⚠️ 文件缺少 type 字段，已设置为默认值: collect")

    if "authors" not in info:
        author_name = os.getenv("GITHUB_ACTOR", "未知作者")
        author_link = "https://github.com/" + os.getenv("GITHUB_ACTOR", "babalae/bettergi-scripts-list")
        info["authors"] = [{"name": author_name, "links": author_link}]
        messages.append(f"⚠️ 文件缺少 authors 字段，已设置为: {info['authors']}")

    if "version" not in info:
        info["version"] = DEFAULT_VERSION
        messages.append(f"⚠️ 文件缺少 version 字段，已设置为默认值: {DEFAULT_VERSION}")

    if "bgi_version" not in info:
        info["bgi_version"] = DEFAULT_BGI_VERSION
        messages.append(f"⚠️ 文件缺少 bgi_version 字段，已设置为默认值: {DEFAULT_BGI_VERSION}")

    if "positions" not in data:
        data["positions"] = []
        messages.append(f"⚠️ 文件缺少 positions 字段，已添加空数组")

    return data

def check_actions_compatibility(positions, bgi_version):
    """检查所有位置的 action 兼容性"""
    compatibility_issues = []
    validation_issues = []

    for idx, pos in enumerate(positions):
        action_type = pos.get("action", "")
        action_params = pos.get("params", "")

        if action_type:
            compat_issues, valid_issues = check_action_compatibility(action_type, action_params, bgi_version)

            for issue in compat_issues:
                compatibility_issues.append(f"位置 {idx+1}: {issue}")

            for issue in valid_issues:
                validation_issues.append(f"位置 {idx+1}: {issue}")

    return compatibility_issues, validation_issues

def update_bgi_version_for_compatibility(info, compatibility_issues, auto_fix):
    """根据兼容性问题更新 BGI 版本"""
    corrections = []

    if auto_fix and compatibility_issues:
        max_required = extract_required_version(compatibility_issues)

        if max_required:
            # 确保 max_required 没有 v 前缀
            max_required = max_required.lstrip('v')

            try:
                current_bgi = parse_bgi_version(info["bgi_version"])
                if current_bgi and current_bgi < VersionInfo.parse(max_required):
                    info["bgi_version"] = max_required
                    corrections.append(f"bgi_version {info['bgi_version']} 自动更新为 {max_required} 以兼容所有功能")
                    return [], corrections
            except ValueError as e:
                # print(f"警告: 版本号解析失败 - {e}")
                info["bgi_version"] = DEFAULT_BGI_VERSION
                corrections.append(f"bgi_version 自动更新为 {DEFAULT_BGI_VERSION} (版本解析失败)")
                return [], corrections

    return compatibility_issues, corrections

def validate_file(file_path, auto_fix=False):
    """验证并修复 JSON 文件"""
    # 加载文件
    data, error = load_json_file(file_path)
    if error:
        print(error)
        return []

    # 获取原始文件
    original_data, source = get_original_file(file_path) if auto_fix else (None, None)
    is_new = not original_data if auto_fix else True

    # 初始化数据结构
    data = initialize_data(data, file_path)
    info = data["info"]
    filename = os.path.splitext(os.path.basename(file_path))[0]

    # 收集所有修正 - 修复：添加了这一行来定义 all_corrections 变量
    all_corrections = []

    # 检查必要字段
    corrections = ensure_required_fields(info, filename)
    all_corrections.extend(corrections)

    # 处理坐标
    coord_changed = process_coordinates(data["positions"])
    if coord_changed:
        all_corrections.append("坐标值自动保留四位小数")

    # 检查 BGI 版本兼容性
    bgi_version, corrections = check_bgi_version_compatibility(info["bgi_version"], auto_fix)
    if corrections:
        info["bgi_version"] = bgi_version
        all_corrections.extend(corrections)    # 检查位置字段 - 修改为接收三个返回值
    position_issues, notices, pos_corrections = check_position_fields(data["positions"])
    if auto_fix and pos_corrections:
        all_corrections.extend(pos_corrections)

    # 检查位置 ID 编号
    if auto_fix:
        id_validation_issues, id_corrections = check_position_ids(data["positions"])
        if id_corrections:
            all_corrections.extend(id_corrections)
        position_issues.extend(id_validation_issues)

    # 检查 action 兼容性
    compatibility_issues, action_validation_issues = check_actions_compatibility(data["positions"], info["bgi_version"])
    position_issues.extend(action_validation_issues)

    # 根据兼容性问题更新 BGI 版本
    compatibility_issues, corrections = update_bgi_version_for_compatibility(info, compatibility_issues, auto_fix)
    all_corrections.extend(corrections)

    # 更新版本号 - 只有从上游仓库获取的文件才更新版本号
    # if auto_fix:
    if False:
        has_original_version = False
        original_version = None

        if original_data and "info" in original_data and "version" in original_data["info"]:
            original_version = original_data["info"]["version"]
            has_original_version = True
            print(f"成功获取原始版本号: {original_version}")
        else:
            print("未找到原始版本号，将视为新文件处理")

        # 只有在没有原始版本号时才视为新文件
        is_new = not has_original_version

        print(f"原始版本号: {original_version}, 当前版本号: {info['version']}, 是否新文件: {is_new}, 来源: {source}")

        # 只有当文件来源是上游仓库时才更新版本号
        if source == "upstream":
            new_version = process_version(info["version"], original_version, is_new)
            if new_version != info["version"]:
                info["version"] = new_version
                all_corrections.append(f"version 自动更新为 {new_version}")
                print(f"版本号已更新: {info['version']}")
            else:
                print(f"版本号未变化: {info['version']}")
        else:
            print(f"这是PR提交的文件，保持版本号不变: {info['version']}（合并后再更新版本）")

    # 合并所有通知
    for issue in compatibility_issues:
        notices.append(issue)

    for issue in position_issues:
        notices.append(issue)

    # 保存修正
    if auto_fix:
        if all_corrections or position_issues:
            if save_json_file(file_path, data):
                print("✅ 文件已保存")
            else:
                notices.append("❌ 保存文件失败")

    return notices

def main():
    import argparse

    parser = argparse.ArgumentParser(description='校验 BetterGI 脚本文件')
    parser.add_argument('path', help='要校验的文件或目录路径')
    parser.add_argument('--fix', action='store_true', help='自动修复问题')
    args = parser.parse_args()

    path = args.path
    auto_fix = args.fix
    all_notices = []  # 初始化 all_notices 变量

    if os.path.isfile(path) and path.endswith('.json'):
        scan_and_convert(path)
        process_json_authors(path)
        # print(f"\n🔍 校验文件: {path}")
        notices = validate_file(path, auto_fix)
        if notices:
            all_notices.extend([f"{path}: {n}" for n in notices])  # 添加到 all_notices
            print("\n校验注意事项:")
            for notice in notices:
                print(f"- {notice}")
        else:
            print("✅ 校验完成，没有发现问题")
    elif os.path.isdir(path):
        for root, _, files in os.walk(path):
            for file in files:
                if file.endswith('.json'):
                    file_path = os.path.join(root, file)
                    print(f"\n🔍 校验文件: {file_path}")
                    scan_and_convert(file_path)
                    process_json_authors(file_path)
                    notices = validate_file(file_path, auto_fix)
                    if notices:
                        all_notices.extend([f"{file_path}: {n}" for n in notices])

        if all_notices:
            print("\n所有校验注意事项:")
            for notice in all_notices:
                print(f"- {notice}")
        else:
            print("\n✅ 所有文件校验完成，没有发现问题")
    else:
        print(f"❌ 无效的路径: {path}")

if __name__ == "__main__":
    main()