'''数据模型定义'''
import json
import datetime
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional, Tuple

@dataclass
class ConfigField:
    """配置项元数据类"""
    name: str
    value: Any
    category: str = "未分类"
    display_name: str = ""
    field_type: str = "auto"
    decimals: Optional[int] = None
    tooltip: str = ""
    hidden: bool = False
    encrypted: bool = False  # 是否加密
    line_number: Optional[int] = None
    original_lines: List[str] = field(default_factory=list)
    validation: Dict = field(default_factory=dict)
    last_saved_value: Any = None
    
    def __post_init__(self):
        if not self.display_name:
            self.display_name = self.name
    
    def get_actual_field_type(self) -> str:
        """获取实际的字段类型"""
        if self.field_type != "auto":
            return self.field_type
        
        if isinstance(self.value, bool):
            return "bool"
        elif isinstance(self.value, int):
            return "int"
        elif isinstance(self.value, float):
            return "float"
        elif isinstance(self.value, (list, dict)):
            return "json"
        else:
            return "str"

@dataclass
class EditorRules:
    """编辑器规则数据类"""
    categories: Dict[str, List[str]] = field(default_factory=lambda: {"未分类": []})
    display_names: Dict[str, str] = field(default_factory=dict)
    tooltips: Dict[str, str] = field(default_factory=dict)
    field_types: Dict[str, str] = field(default_factory=dict)
    field_decimals: Dict[str, int] = field(default_factory=dict)
    hidden: List[str] = field(default_factory=list)
    encrypted_fields: List[str] = field(default_factory=list)  # 加密字段列表
    validations: Dict[str, Dict] = field(default_factory=dict)
    field_order: Dict[str, List[str]] = field(default_factory=dict)
    last_saved_values: Dict[str, Any] = field(default_factory=dict)
    
    def to_dict(self) -> Dict:
        """转换为字典"""
        return {
            "categories": self.categories,
            "display_names": self.display_names,
            "tooltips": self.tooltips,
            "field_types": self.field_types,
            "field_decimals": self.field_decimals,
            "hidden": self.hidden,
            "encrypted_fields": self.encrypted_fields,  
            "validations": self.validations,
            "field_order": self.field_order,
            "last_saved_values": self.last_saved_values
        }
    
    @classmethod
    def from_dict(cls, data: Dict) -> 'EditorRules':
        """从字典创建实例"""
        return cls(
            categories=data.get("categories", {"未分类": []}),
            display_names=data.get("display_names", {}),
            tooltips=data.get("tooltips", {}),
            field_types=data.get("field_types", {}),
            field_decimals=data.get("field_decimals", {}),
            hidden=data.get("hidden", []),
            encrypted_fields=data.get("encrypted_fields", []),  
            validations=data.get("validations", {}),
            field_order=data.get("field_order", {}),
            last_saved_values=data.get("last_saved_values", {})
        )

@dataclass
class UserSettings:
    """用户设置数据类"""
    config_file_path: str = ""
    last_used: str = ""
    use_relative_path: bool = True
    
    def to_dict(self) -> Dict:
        return {
            "config_file_path": self.config_file_path,
            "last_used": self.last_used
        }
    
    @classmethod
    def from_dict(cls, data: Dict) -> 'UserSettings':
        return cls(
            config_file_path=data.get("config_file_path", ""),
            last_used=data.get("last_used", "")
        )

@dataclass
class ExportInfo:
    """导出信息数据类"""
    export_time: str = ""
    export_version: str = "1.0"
    note: str = "配置文件编辑器规则文件"
    
    def to_dict(self) -> Dict:
        return {
            "export_time": self.export_time or datetime.datetime.now().strftime("%Y-%m-d %H:%M:%S"),
            "export_version": self.export_version,
            "note": self.note
        }

@dataclass
class Statistics:
    """统计信息数据类"""
    total_fields: int = 0
    display_names_count: int = 0
    categories_count: int = 0
    hidden_fields_count: int = 0
    encrypted_fields_count: int = 0  # 加密字段计数
    field_types_count: int = 0
    validations_count: int = 0
    
    def to_dict(self) -> Dict:
        return {
            "total_fields": self.total_fields,
            "display_names_count": self.display_names_count,
            "categories_count": self.categories_count,
            "hidden_fields_count": self.hidden_fields_count,
            "encrypted_fields_count": self.encrypted_fields_count,  
            "field_types_count": self.field_types_count,
            "validations_count": self.validations_count
        }