json_compressor.py

"""
JSON数据压缩工具
支持多种压缩策略来减少JSON传输体积
"""

import json
import gzip
import base64
import zlib
import bz2
import lzma
from typing import Any, Dict, List, Union
from io import BytesIO


class JSONCompressor:
    """JSON压缩器，支持多种压缩方式"""
    
    @staticmethod
    def compress_with_gzip(data: Union[Dict, List, str], level: int = 9) -> str:
        """
        使用gzip压缩JSON数据
        
        Args:
            data: 要压缩的数据（字典、列表或JSON字符串）
            level: 压缩级别 (0-9)，9为最高压缩率
            
        Returns:
            base64编码的压缩数据
        """
        if isinstance(data, str):
            json_str = data
        else:
            json_str = json.dumps(data, ensure_ascii=False, separators=(',', ':'))
        
        json_bytes = json_str.encode('utf-8')
        compressed = gzip.compress(json_bytes, compresslevel=level)
        return base64.b64encode(compressed).decode('ascii')
    
    @staticmethod
    def decompress_gzip(compressed_data: str) -> Any:
        """
        解压gzip压缩的JSON数据
        
        Args:
            compressed_data: base64编码的压缩数据
            
        Returns:
            解压后的原始数据
        """
        compressed_bytes = base64.b64decode(compressed_data)
        decompressed = gzip.decompress(compressed_bytes)
        json_str = decompressed.decode('utf-8')
        return json.loads(json_str)
    
    @staticmethod
    def compress_with_zlib(data: Union[Dict, List, str], level: int = 9) -> str:
        """
        使用zlib压缩JSON数据（通常比gzip稍快）
        
        Args:
            data: 要压缩的数据
            level: 压缩级别 (0-9)
            
        Returns:
            base64编码的压缩数据
        """
        if isinstance(data, str):
            json_str = data
        else:
            json_str = json.dumps(data, ensure_ascii=False, separators=(',', ':'))
        
        json_bytes = json_str.encode('utf-8')
        compressed = zlib.compress(json_bytes, level=level)
        return base64.b64encode(compressed).decode('ascii')
    
    @staticmethod
    def decompress_zlib(compressed_data: str) -> Any:
        """
        解压zlib压缩的JSON数据
        
        Args:
            compressed_data: base64编码的压缩数据
            
        Returns:
            解压后的原始数据
        """
        compressed_bytes = base64.b64decode(compressed_data)
        decompressed = zlib.decompress(compressed_bytes)
        json_str = decompressed.decode('utf-8')
        return json.loads(json_str)
    
    @staticmethod
    def compress_with_bz2(data: Union[Dict, List, str], level: int = 9) -> str:
        """
        使用bz2压缩JSON数据（压缩率高但速度较慢）
        
        Args:
            data: 要压缩的数据
            level: 压缩级别 (1-9)
            
        Returns:
            base64编码的压缩数据
        """
        if isinstance(data, str):
            json_str = data
        else:
            json_str = json.dumps(data, ensure_ascii=False, separators=(',', ':'))
        
        json_bytes = json_str.encode('utf-8')
        compressed = bz2.compress(json_bytes, compresslevel=level)
        return base64.b64encode(compressed).decode('ascii')
    
    @staticmethod
    def decompress_bz2(compressed_data: str) -> Any:
        """
        解压bz2压缩的JSON数据
        
        Args:
            compressed_data: base64编码的压缩数据
            
        Returns:
            解压后的原始数据
        """
        compressed_bytes = base64.b64decode(compressed_data)
        decompressed = bz2.decompress(compressed_bytes)
        json_str = decompressed.decode('utf-8')
        return json.loads(json_str)
    
    @staticmethod
    def compress_with_lzma(data: Union[Dict, List, str], preset: int = 9) -> str:
        """
        使用LZMA压缩JSON数据（最高压缩率但速度最慢）
        
        Args:
            data: 要压缩的数据
            preset: 压缩预设 (0-9)，9为最高压缩率
            
        Returns:
            base64编码的压缩数据
        """
        if isinstance(data, str):
            json_str = data
        else:
            json_str = json.dumps(data, ensure_ascii=False, separators=(',', ':'))
        
        json_bytes = json_str.encode('utf-8')
        compressed = lzma.compress(json_bytes, preset=preset)
        return base64.b64encode(compressed).decode('ascii')
    
    @staticmethod
    def decompress_lzma(compressed_data: str) -> Any:
        """
        解压LZMA压缩的JSON数据
        
        Args:
            compressed_data: base64编码的压缩数据
            
        Returns:
            解压后的原始数据
        """
        compressed_bytes = base64.b64decode(compressed_data)
        decompressed = lzma.decompress(compressed_bytes)
        json_str = decompressed.decode('utf-8')
        return json.loads(json_str)
    
    @staticmethod
    def minify(data: Union[Dict, List]) -> str:
        """
        最小化JSON（去除空格和换行）
        
        Args:
            data: 要最小化的数据
            
        Returns:
            最小化的JSON字符串
        """
        return json.dumps(data, ensure_ascii=False, separators=(',', ':'))
    
    @staticmethod
    def compress_keys(data: Union[Dict, List], key_map: Dict[str, str] = None) -> tuple:
        """
        压缩JSON键名（将长键名映射为短键名）
        
        Args:
            data: 要压缩的数据
            key_map: 自定义键名映射表，如果为None则自动生成
            
        Returns:
            (压缩后的数据, 键名映射表)
        """
        if key_map is None:
            # 自动生成键名映射
            key_map = {}
            counter = [0]
            
            def generate_short_key():
                chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
                idx = counter[0]
                counter[0] += 1
                
                result = ''
                while True:
                    result = chars[idx % len(chars)] + result
                    idx //= len(chars)
                    if idx == 0:
                        break
                return result
            
            def collect_keys(obj):
                if isinstance(obj, dict):
                    for key in obj.keys():
                        if key not in key_map:
                            key_map[key] = generate_short_key()
                    for value in obj.values():
                        collect_keys(value)
                elif isinstance(obj, list):
                    for item in obj:
                        collect_keys(item)
            
            collect_keys(data)
        
        def compress_obj(obj):
            if isinstance(obj, dict):
                return {key_map.get(k, k): compress_obj(v) for k, v in obj.items()}
            elif isinstance(obj, list):
                return [compress_obj(item) for item in obj]
            else:
                return obj
        
        compressed_data = compress_obj(data)
        reverse_map = {v: k for k, v in key_map.items()}
        
        return compressed_data, reverse_map
    
    @staticmethod
    def decompress_keys(data: Union[Dict, List], reverse_map: Dict[str, str]) -> Any:
        """
        解压缩键名
        
        Args:
            data: 压缩的数据
            reverse_map: 反向映射表（短键名->原键名）
            
        Returns:
            还原后的数据
        """
        def decompress_obj(obj):
            if isinstance(obj, dict):
                return {reverse_map.get(k, k): decompress_obj(v) for k, v in obj.items()}
            elif isinstance(obj, list):
                return [decompress_obj(item) for item in obj]
            else:
                return obj
        
        return decompress_obj(data)
    
    @staticmethod
    def compress_advanced(data: Union[Dict, List], compression_type: str = 'gzip', 
                         compress_keys: bool = False) -> Dict:
        """
        高级压缩：结合多种策略
        
        Args:
            data: 要压缩的数据
            compression_type: 压缩类型 ('gzip', 'zlib', 'bz2', 'lzma')
            compress_keys: 是否压缩键名
            
        Returns:
            包含压缩数据和元信息的字典
        """
        result = {
            'type': compression_type,
            'key_compressed': compress_keys
        }
        
        working_data = data
        
        # 如果需要压缩键名
        if compress_keys:
            working_data, reverse_map = JSONCompressor.compress_keys(data)
            result['key_map'] = reverse_map
        
        # 应用压缩算法
        if compression_type == 'gzip':
            result['data'] = JSONCompressor.compress_with_gzip(working_data)
        elif compression_type == 'zlib':
            result['data'] = JSONCompressor.compress_with_zlib(working_data)
        elif compression_type == 'bz2':
            result['data'] = JSONCompressor.compress_with_bz2(working_data)
        elif compression_type == 'lzma':
            result['data'] = JSONCompressor.compress_with_lzma(working_data)
        else:
            raise ValueError(f"不支持的压缩类型: {compression_type}")
        
        return result
    
    @staticmethod
    def decompress_advanced(compressed_result: Dict) -> Any:
        """
        解压高级压缩的数据
        
        Args:
            compressed_result: compress_advanced返回的结果
            
        Returns:
            原始数据
        """
        compression_type = compressed_result['type']
        compressed_data = compressed_result['data']
        
        # 解压数据
        if compression_type == 'gzip':
            data = JSONCompressor.decompress_gzip(compressed_data)
        elif compression_type == 'zlib':
            data = JSONCompressor.decompress_zlib(compressed_data)
        elif compression_type == 'bz2':
            data = JSONCompressor.decompress_bz2(compressed_data)
        elif compression_type == 'lzma':
            data = JSONCompressor.decompress_lzma(compressed_data)
        else:
            raise ValueError(f"不支持的压缩类型: {compression_type}")
        
        # 如果键名被压缩，还原键名
        if compressed_result.get('key_compressed', False):
            reverse_map = compressed_result['key_map']
            data = JSONCompressor.decompress_keys(data, reverse_map)
        
        return data
    
    @staticmethod
    def compress_auto(data: Union[Dict, List], 
                     priority: str = 'ratio',
                     compress_keys: bool = True) -> Dict:
        """
        自动选择最佳压缩方法
        
        Args:
            data: 要压缩的数据
            priority: 优先级 ('ratio'=压缩率优先, 'speed'=速度优先, 'balanced'=平衡)
            compress_keys: 是否尝试键名压缩
            
        Returns:
            包含压缩数据和元信息的字典
        """
        # 估算数据大小
        json_str = json.dumps(data, ensure_ascii=False, separators=(',', ':'))
        data_size = len(json_str.encode('utf-8'))
        
        # 根据优先级和数据大小选择压缩方法
        if priority == 'speed':
            # 速度优先：使用Zlib
            compression_type = 'zlib'
            # 小数据不压缩键名（开销大）
            compress_keys = compress_keys and data_size > 10000
        elif priority == 'ratio':
            # 压缩率优先：大数据用LZMA，小数据用Zlib
            if data_size > 50000:
                compression_type = 'lzma'
            elif data_size > 10000:
                compression_type = 'bz2'
            else:
                compression_type = 'zlib'
        else:  # balanced
            # 平衡：根据数据大小选择
            if data_size > 100000:
                compression_type = 'bz2'  # 比LZMA快，但压缩率也不错
            else:
                compression_type = 'zlib'
            compress_keys = compress_keys and data_size > 20000
        
        result = JSONCompressor.compress_advanced(
            data, 
            compression_type=compression_type,
            compress_keys=compress_keys
        )
        result['auto_selected'] = True
        result['data_size'] = data_size
        result['priority'] = priority
        
        return result
    
    @staticmethod
    def get_compression_stats(original_data: Union[Dict, List, str], 
                             compressed_data: str) -> Dict:
        """
        获取压缩统计信息
        
        Args:
            original_data: 原始数据
            compressed_data: 压缩后的数据
            
        Returns:
            统计信息字典
        """
        if isinstance(original_data, str):
            original_size = len(original_data.encode('utf-8'))
        else:
            original_json = json.dumps(original_data, ensure_ascii=False, separators=(',', ':'))
            original_size = len(original_json.encode('utf-8'))
        
        compressed_size = len(compressed_data.encode('utf-8'))
        compression_ratio = (1 - compressed_size / original_size) * 100
        
        return {
            'original_size': original_size,
            'compressed_size': compressed_size,
            'saved_bytes': original_size - compressed_size,
            'compression_ratio': f"{compression_ratio:.2f}%"
        }


def setup_stdout():
    """设置UTF-8输出编码（Windows兼容性）"""
    import sys
    import io
    if sys.platform == 'win32':
        if hasattr(sys.stdout, 'reconfigure'):
            sys.stdout.reconfigure(encoding='utf-8')
        elif hasattr(sys.stdout, 'buffer'):
            sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')

def demo():
    """演示各种压缩方法"""
    
    setup_stdout()
    
    # 示例数据
    test_data = {
        "user_information": {
            "first_name": "张",
            "last_name": "三",
            "email_address": "zhangsan@example.com",
            "phone_number": "13800138000"
        },
        "order_details": [
            {
                "order_id": "ORD-2024-001",
                "product_name": "笔记本电脑",
                "product_price": 5999.99,
                "quantity": 1,
                "total_amount": 5999.99
            },
            {
                "order_id": "ORD-2024-002",
                "product_name": "无线鼠标",
                "product_price": 89.99,
                "quantity": 2,
                "total_amount": 179.98
            }
        ],
        "metadata": {
            "timestamp": "2024-11-06T10:30:00Z",
            "api_version": "v1.0",
            "request_id": "req_abc123def456"
        }
    }
    
    print("=" * 80)
    print("JSON压缩工具演示")
    print("=" * 80)
    
    # 原始JSON大小
    original_json = json.dumps(test_data, ensure_ascii=False, indent=2)
    print(f"\n原始JSON (带格式化):")
    print(f"大小: {len(original_json.encode('utf-8'))} 字节")
    
    minified = JSONCompressor.minify(test_data)
    print(f"\n最小化JSON (去除空格):")
    print(f"大小: {len(minified.encode('utf-8'))} 字节")
    
    # 方法1: Gzip压缩
    print("\n" + "-" * 80)
    print("方法1: Gzip压缩")
    print("-" * 80)
    gzip_compressed = JSONCompressor.compress_with_gzip(test_data)
    print(f"压缩后大小: {len(gzip_compressed.encode('utf-8'))} 字节")
    stats = JSONCompressor.get_compression_stats(test_data, gzip_compressed)
    print(f"压缩率: {stats['compression_ratio']}")
    print(f"节省: {stats['saved_bytes']} 字节")
    
    # 验证解压
    decompressed = JSONCompressor.decompress_gzip(gzip_compressed)
    print(f"解压验证: {'✓ 成功' if decompressed == test_data else '✗ 失败'}")
    
    # 方法2: Zlib压缩
    print("\n" + "-" * 80)
    print("方法2: Zlib压缩")
    print("-" * 80)
    zlib_compressed = JSONCompressor.compress_with_zlib(test_data)
    print(f"压缩后大小: {len(zlib_compressed.encode('utf-8'))} 字节")
    stats = JSONCompressor.get_compression_stats(test_data, zlib_compressed)
    print(f"压缩率: {stats['compression_ratio']}")
    print(f"节省: {stats['saved_bytes']} 字节")
    
    # 验证解压
    decompressed = JSONCompressor.decompress_zlib(zlib_compressed)
    print(f"解压验证: {'✓ 成功' if decompressed == test_data else '✗ 失败'}")
    
    # 方法3: Bz2压缩（更高压缩率）
    print("\n" + "-" * 80)
    print("方法3: Bz2压缩（高压缩率）")
    print("-" * 80)
    bz2_compressed = JSONCompressor.compress_with_bz2(test_data)
    print(f"压缩后大小: {len(bz2_compressed.encode('utf-8'))} 字节")
    stats = JSONCompressor.get_compression_stats(test_data, bz2_compressed)
    print(f"压缩率: {stats['compression_ratio']}")
    print(f"节省: {stats['saved_bytes']} 字节")
    
    # 验证解压
    decompressed = JSONCompressor.decompress_bz2(bz2_compressed)
    print(f"解压验证: {'✓ 成功' if decompressed == test_data else '✗ 失败'}")
    
    # 方法4: LZMA压缩（最高压缩率）
    print("\n" + "-" * 80)
    print("方法4: LZMA压缩（最高压缩率）")
    print("-" * 80)
    lzma_compressed = JSONCompressor.compress_with_lzma(test_data)
    print(f"压缩后大小: {len(lzma_compressed.encode('utf-8'))} 字节")
    stats = JSONCompressor.get_compression_stats(test_data, lzma_compressed)
    print(f"压缩率: {stats['compression_ratio']}")
    print(f"节省: {stats['saved_bytes']} 字节")
    
    # 验证解压
    decompressed = JSONCompressor.decompress_lzma(lzma_compressed)
    print(f"解压验证: {'✓ 成功' if decompressed == test_data else '✗ 失败'}")
    
    # 方法5: 键名压缩
    print("\n" + "-" * 80)
    print("方法5: 键名压缩")
    print("-" * 80)
    compressed_data, reverse_map = JSONCompressor.compress_keys(test_data)
    compressed_json = json.dumps(compressed_data, ensure_ascii=False, separators=(',', ':'))
    print(f"压缩后大小: {len(compressed_json.encode('utf-8'))} 字节")
    print(f"键名映射示例: {list(reverse_map.items())[:3]}")
    
    # 方法6: 高级压缩（LZMA + 键名压缩）
    print("\n" + "-" * 80)
    print("方法6: 高级压缩 (LZMA + 键名压缩)")
    print("-" * 80)
    advanced_result = JSONCompressor.compress_advanced(
        test_data, 
        compression_type='lzma',
        compress_keys=True
    )
    advanced_json = json.dumps(advanced_result, ensure_ascii=False)
    print(f"压缩后大小: {len(advanced_json.encode('utf-8'))} 字节")
    
    # 验证解压
    decompressed_advanced = JSONCompressor.decompress_advanced(advanced_result)
    print(f"解压验证: {'✓ 成功' if decompressed_advanced == test_data else '✗ 失败'}")
    
    print("\n" + "=" * 80)
    print("压缩对比总结")
    print("=" * 80)
    print(f"{'方法':<30} {'大小(字节)':<15} {'压缩率':<15} {'推荐场景':<20}")
    print("-" * 80)
    original_size = len(original_json.encode('utf-8'))
    minified_size = len(minified.encode('utf-8'))
    gzip_size = len(gzip_compressed.encode('utf-8'))
    zlib_size = len(zlib_compressed.encode('utf-8'))
    bz2_size = len(bz2_compressed.encode('utf-8'))
    lzma_size = len(lzma_compressed.encode('utf-8'))
    keys_size = len(compressed_json.encode('utf-8'))
    advanced_size = len(advanced_json.encode('utf-8'))
    
    print(f"{'原始JSON (格式化)':<30} {original_size:<15} {'-':<15} {'基准':<20}")
    print(f"{'最小化JSON':<30} {minified_size:<15} {f'-{((1-minified_size/original_size)*100):.1f}%':<15} {'快速/可读':<20}")
    print(f"{'Gzip压缩':<30} {gzip_size:<15} {f'-{((1-gzip_size/original_size)*100):.1f}%':<15} {'HTTP传输':<20}")
    print(f"{'Zlib压缩':<30} {zlib_size:<15} {f'-{((1-zlib_size/original_size)*100):.1f}%':<15} {'通用/快速':<20}")
    print(f"{'Bz2压缩':<30} {bz2_size:<15} {f'-{((1-bz2_size/original_size)*100):.1f}%':<15} {'高压缩率':<20}")
    print(f"{'LZMA压缩':<30} {lzma_size:<15} {f'-{((1-lzma_size/original_size)*100):.1f}%':<15} {'最高压缩率':<20}")
    print(f"{'键名压缩':<30} {keys_size:<15} {f'-{((1-keys_size/original_size)*100):.1f}%':<15} {'重复键名多':<20}")
    print(f"{'LZMA+键名组合':<30} {advanced_size:<15} {f'-{((1-advanced_size/original_size)*100):.1f}%':<15} {'存储/归档':<20}")
    print("=" * 80)
    
    # 性能对比说明
    print("\n性能对比：")
    print("  速度: Zlib > Gzip > Bz2 > LZMA")
    print("  压缩率: LZMA > Bz2 > Zlib ≈ Gzip")
    print("  推荐: 实时传输用Zlib，存储归档用LZMA")


def demo_large_data():
    """使用大数据集演示压缩效果（LZMA和Bz2在大数据上表现更好）"""
    
    setup_stdout()
    
    # 创建更大的数据集
    large_data = {
        "records": []
    }
    
    # 生成1000条记录
    for i in range(1000):
        large_data["records"].append({
            "id": f"USER-{i:05d}",
            "username": f"user_{i}@example.com",
            "first_name": "张" if i % 2 == 0 else "李",
            "last_name": "三" if i % 3 == 0 else "四",
            "age": 20 + (i % 50),
            "city": "北京" if i % 4 == 0 else "上海" if i % 4 == 1 else "广州" if i % 4 == 2 else "深圳",
            "score": 85.5 + (i % 15),
            "is_active": i % 2 == 0,
            "tags": ["标签A", "标签B", "标签C"][:i % 4],
            "metadata": {
                "created_at": "2024-01-01T00:00:00Z",
                "updated_at": "2024-11-06T00:00:00Z",
                "version": "1.0"
            }
        })
    
    print("=" * 80)
    print("大数据集压缩测试 (1000条记录)")
    print("=" * 80)
    
    original_json = json.dumps(large_data, ensure_ascii=False, indent=2)
    original_size = len(original_json.encode('utf-8'))
    print(f"\n原始JSON大小: {original_size:,} 字节 ({original_size/1024:.2f} KB)")
    
    # 测试各种压缩方法
    methods = [
        ("Minify", lambda: JSONCompressor.minify(large_data)),
        ("Gzip", lambda: JSONCompressor.compress_with_gzip(large_data)),
        ("Zlib", lambda: JSONCompressor.compress_with_zlib(large_data)),
        ("Bz2", lambda: JSONCompressor.compress_with_bz2(large_data)),
        ("LZMA", lambda: JSONCompressor.compress_with_lzma(large_data)),
    ]
    
    print("\n" + "-" * 80)
    print(f"{'方法':<15} {'压缩后大小':<20} {'压缩率':<15} {'相对原始':<15}")
    print("-" * 80)
    
    results = []
    for name, compress_func in methods:
        compressed = compress_func()
        size = len(compressed.encode('utf-8'))
        ratio = (1 - size / original_size) * 100
        results.append((name, size, ratio))
        
        if name == "Minify":
            print(f"{name:<15} {size:>8,} 字节      {ratio:>6.2f}%        {'-':<15}")
        else:
            print(f"{name:<15} {size:>8,} 字节      {ratio:>6.2f}%        {size/1024:.2f} KB")
    
    print("-" * 80)
    
    # 找出最佳方法
    best = min(results[1:], key=lambda x: x[1])
    print(f"\n✨ 最佳压缩: {best[0]} - {best[1]:,} 字节 ({best[1]/1024:.2f} KB), 压缩率 {best[2]:.2f}%")
    
    # 键名压缩效果
    print("\n" + "-" * 80)
    print("键名压缩效果:")
    print("-" * 80)
    compressed_keys_data, reverse_map = JSONCompressor.compress_keys(large_data)
    keys_json = json.dumps(compressed_keys_data, ensure_ascii=False, separators=(',', ':'))
    keys_size = len(keys_json.encode('utf-8'))
    keys_ratio = (1 - keys_size / original_size) * 100
    print(f"仅键名压缩: {keys_size:,} 字节 ({keys_size/1024:.2f} KB), 压缩率 {keys_ratio:.2f}%")
    
    # LZMA + 键名压缩
    lzma_keys = JSONCompressor.compress_with_lzma(compressed_keys_data)
    lzma_keys_size = len(lzma_keys.encode('utf-8'))
    lzma_keys_ratio = (1 - lzma_keys_size / original_size) * 100
    print(f"LZMA+键名: {lzma_keys_size:,} 字节 ({lzma_keys_size/1024:.2f} KB), 压缩率 {lzma_keys_ratio:.2f}%")
    
    print("\n" + "=" * 80)
    print("结论：")
    print("  • 对于大数据集，LZMA和Bz2能显著提高压缩率")
    print("  • 键名压缩对重复结构数据非常有效")
    print("  • LZMA+键名组合可获得最高压缩率")
    print("=" * 80)


def demo_auto_compress():
    """演示自动压缩功能"""
    
    setup_stdout()
    
    print("\n" + "=" * 80)
    print("自动压缩演示")
    print("=" * 80)
    
    # 测试数据
    small_data = {"key": "value", "items": [1, 2, 3, 4, 5]}
    
    # 创建中等大小数据
    medium_data = {"records": [{"id": i, "name": f"用户{i}", "score": 85.5 + i} for i in range(100)]}
    
    # 创建大数据
    large_data = {"records": [{"id": i, "username": f"user{i}@example.com", "age": 20 + (i % 50)} for i in range(1000)]}
    
    test_cases = [
        ("小数据 (50字节)", small_data),
        ("中等数据 (5KB)", medium_data),
        ("大数据 (50KB)", large_data)
    ]
    
    for name, data in test_cases:
        print(f"\n{name}:")
        print("-" * 40)
        
        # 测试三种优先级
        for priority in ['speed', 'balanced', 'ratio']:
            result = JSONCompressor.compress_auto(data, priority=priority)
            compressed_size = len(result['data'].encode('utf-8'))
            original_size = result['data_size']
            ratio = (1 - compressed_size / original_size) * 100
            
            print(f"  {priority:>8}: {result['type']:>6} "
                  f"{'(+键名)' if result['key_compressed'] else '      '} "
                  f"-> {compressed_size:>6,}字节 ({ratio:>5.1f}%)")


def main():
    """主函数：命令行接口"""
    import sys
    
    if len(sys.argv) > 1:
        command = sys.argv[1]
        
        if command == '--demo':
            # 演示模式
            demo()
            print("\n\n")
            demo_large_data()
            demo_auto_compress()
        elif command == '--auto':
            # 自动压缩演示
            demo_auto_compress()
        elif command == '--help':
            print("JSON压缩工具使用说明:")
            print("\n作为模块使用:")
            print("  from json_compressor import JSONCompressor")
            print("\n  # 快速压缩")
            print("  compressed = JSONCompressor.compress_with_zlib(data)")
            print("  original = JSONCompressor.decompress_zlib(compressed)")
            print("\n  # 自动选择最佳压缩")
            print("  result = JSONCompressor.compress_auto(data, priority='ratio')")
            print("  original = JSONCompressor.decompress_advanced(result)")
            print("\n命令行参数:")
            print("  --demo    : 运行完整演示")
            print("  --auto    : 运行自动压缩演示")
            print("  --help    : 显示帮助信息")
        else:
            print(f"未知命令: {command}")
            print("使用 --help 查看帮助")
    else:
        # 默认运行完整演示
        demo()
        print("\n\n")
        demo_large_data()
        demo_auto_compress()


if __name__ == '__main__':
    main()