import json
from typing import Optional, Union, Dict, List
from decimal import Decimal


class DataUtil:
    """数据处理工具类"""

    @staticmethod
    def to_json(data: Union[Dict, List]) -> Optional[str]:
        """将数据转换为JSON字符串
        
        Args:
            data: 要转换的数据
            
        Returns:
            JSON字符串，如果转换失败返回None
        """
        try:
            return json.dumps(data, ensure_ascii=False)
        except Exception:
            return None

    @staticmethod
    def from_json(json_str: str) -> Optional[Union[Dict, List]]:
        """将JSON字符串转换为Python对象
        
        Args:
            json_str: JSON字符串
            
        Returns:
            Python对象，如果转换失败返回None
        """
        try:
            return json.loads(json_str)
        except Exception:
            return None

    @staticmethod
    def to_decimal(value: Union[str, int, float]) -> Optional[Decimal]:
        """将值转换为Decimal类型
        
        Args:
            value: 要转换的值
            
        Returns:
            Decimal对象，如果转换失败返回None
        """
        try:
            return Decimal(str(value))
        except Exception:
            return None

    @staticmethod
    def deep_merge(dict1: Dict, dict2: Dict) -> Dict:
        """深度合并两个字典
        
        Args:
            dict1: 第一个字典
            dict2: 第二个字典
            
        Returns:
            合并后的字典
        """
        result = dict1.copy()
        for key, value in dict2.items():
            if key in result and isinstance(result[key], dict) and isinstance(
                    value, dict):
                result[key] = DataUtil.deep_merge(result[key], value)
            else:
                result[key] = value
        return result

    @staticmethod
    def flatten_dict(d: Dict, parent_key: str = '', sep: str = '.') -> Dict:
        """将嵌套字典展平
        
        Args:
            d: 要展平的字典
            parent_key: 父级键名
            sep: 分隔符
            
        Returns:
            展平后的字典
        """
        items = []
        for k, v in d.items():
            new_key = f"{parent_key}{sep}{k}" if parent_key else k
            if isinstance(v, dict):
                items.extend(
                    DataUtil.flatten_dict(v, new_key, sep=sep).items())
            else:
                items.append((new_key, v))
        return dict(items)

    @staticmethod
    def get_nested_value(data: Dict, keys: List[str], default=None):
        """获取嵌套字典中的值
        
        Args:
            data: 要查找的字典
            keys: 键名列表
            default: 默认值
            
        Returns:
            查找到的值，如果不存在返回默认值
        """
        for key in keys:
            if isinstance(data, dict) and key in data:
                data = data[key]
            else:
                return default
        return data