'''文件读写管理模块'''
import os
import json
import shutil
from pathlib import Path
from typing import Dict, Any
from utils import (backup_existing_rules, merge_rules, 
                               get_default_rules, ensure_rule_structure)

class FileHandler:
    """文件处理器"""
    
    def __init__(self, program_dir: str):
        self.program_dir = program_dir
        self.rules_file = str(Path(program_dir) / "config_editor_rules.json")
        self.settings_file = str(Path(program_dir) / "config_editor_settings.json")
    
    def load_user_settings(self) -> Dict:
        """加载用户设置"""
        try:
            if os.path.exists(self.settings_file):
                with open(self.settings_file, 'r', encoding='utf-8') as f:
                    return json.load(f)
        except Exception as e:
            print(f"加载用户设置失败: {e}")
        
        return {}
    
    def save_user_settings(self, settings: Dict) -> bool:
        """保存用户设置"""
        try:
            with open(self.settings_file, 'w', encoding='utf-8') as f:
                json.dump(settings, f, indent=2, ensure_ascii=False)
            return True
        except Exception as e:
            print(f"保存用户设置失败: {e}")
            return False
    
    def load_rules(self) -> Dict:
        """加载规则文件"""
        try:
            # 先备份现有规则文件
            backup_existing_rules(self.rules_file, self.program_dir)
            
            # 检查是否已有规则文件
            if os.path.exists(self.rules_file):
                with open(self.rules_file, 'r', encoding='utf-8') as f:
                    existing_rules = json.load(f)
                
                # 检查规则文件是否为空或格式错误
                if not existing_rules or not isinstance(existing_rules, dict):
                    raise ValueError("规则文件为空或格式错误")
                
                # 从打包资源加载默认规则（用于合并新字段）
                default_rules = get_default_rules()
                
                # 智能合并：保留现有规则，只添加新字段
                rules = merge_rules(existing_rules, default_rules)
                
                # 确保规则结构完整
                rules = ensure_rule_structure(rules)
                
                # 保存合并后的规则（包含新字段）
                self.save_rules(rules)
                
                return rules
            else:
                # 如果没有规则文件，使用默认规则
                rules = get_default_rules()
                # 确保规则结构完整
                rules = ensure_rule_structure(rules)
                # 首次运行，创建规则文件
                try:
                    self.save_rules(rules)
                except Exception as e:
                    print(f"创建规则文件失败: {e}")
                return rules
                    
        except (json.JSONDecodeError, ValueError, KeyError) as e:
            # 如果规则文件损坏，备份后使用默认规则
            print(f"加载规则文件失败: {e}，将使用默认规则")
            self._backup_corrupted_rules()
            rules = get_default_rules()
            rules = ensure_rule_structure(rules)
            self.save_rules(rules)
            return rules
            
        except Exception as e:
            print(f"加载规则文件失败: {e}")
            rules = get_default_rules()
            rules = ensure_rule_structure(rules)
            return rules
    
    def save_rules(self, rules: Dict) -> bool:
        """保存规则文件"""
        try:
            # 确保规则结构完整
            rules = ensure_rule_structure(rules)
            
            with open(self.rules_file, 'w', encoding='utf-8') as f:
                json.dump(rules, f, indent=2, ensure_ascii=False)
            return True
        except Exception as e:
            print(f"保存规则文件失败: {e}")
            return False
    
    def _backup_corrupted_rules(self):
        """备份损坏的规则文件"""
        if os.path.exists(self.rules_file):
            import datetime
            timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
            backup_file = f"{self.rules_file}.corrupted_{timestamp}.bak"
            try:
                shutil.copy2(self.rules_file, backup_file)
                print(f"已备份损坏的规则文件到: {backup_file}")
            except Exception as e:
                print(f"备份损坏规则文件失败: {e}")