"""
核心模块验证脚本

验证所有核心处理模块是否正常工作。
"""

import sys
sys.path.insert(0, '.')

def verify_error_response():
    """验证 ErrorResponse 模块"""
    from modules import (
        ErrorCode, ErrorType, ErrorResponse, ErrorFactory, create_error_response
    )
    
    print("ErrorResponse 功能检查:")
    
    # 测试创建错误响应
    error = ErrorResponse(
        error_code=ErrorCode.GROQ_RATE_LIMIT,
        error_type=ErrorType.RETRYABLE,
        message="测试错误消息",
        retry_available=True
    )
    
    print(f"  - ErrorCode枚举: {len(ErrorCode)} 个错误代码")
    print(f"  - ErrorType枚举: {len(ErrorType)} 个错误类型")
    print(f"  - to_dict方法: {hasattr(error, 'to_dict')}")
    print(f"  - to_user_message方法: {hasattr(error, 'to_user_message')}")
    
    # 测试工厂方法
    rate_limit_error = ErrorFactory.create_groq_rate_limit_error(retry_after=30)
    print(f"  - ErrorFactory工厂方法: 正常工作")
    
    # 测试便捷函数
    quick_error = create_error_response(
        ErrorCode.TIMEOUT_ERROR,
        "超时测试"
    )
    print(f"  - create_error_response函数: 正常工作")
    
    print("  ✓ ErrorResponse 验证通过")
    return True

def verify_logging_config():
    """验证 logging_config 模块"""
    from modules import (
        LogLevel, Component, StructuredLogRecord, ComponentLogger,
        setup_logging, get_component_logger, log_performance
    )
    
    print("\nLoggingConfig 功能检查:")
    
    # 测试组件枚举
    print(f"  - Component枚举: {len(Component)} 个组件")
    
    # 测试结构化日志记录
    record = StructuredLogRecord(
        timestamp="2024-01-01T00:00:00",
        level="INFO",
        component="Test",
        message="测试消息"
    )
    json_output = record.to_json()
    print(f"  - StructuredLogRecord: 正常工作")
    
    # 测试组件日志记录器
    logger = get_component_logger(Component.GROQ_CLIENT)
    print(f"  - ComponentLogger: 正常工作")
    print(f"  - log_performance装饰器: {callable(log_performance)}")
    
    print("  ✓ LoggingConfig 验证通过")
    return True

def verify_groq_client():
    """验证 GroqClient 模块"""
    from modules import GroqClient, GroqConfig, RetryStats
    
    config = GroqConfig(api_key='test_key')
    client = GroqClient(config)
    
    print("\nGroqClient 功能检查:")
    print(f"  - ASR模型: {client.asr_model}")
    print(f"  - LLM模型: {client.llm_model}")
    print(f"  - transcribe方法: {hasattr(client, 'transcribe')}")
    print(f"  - translate方法: {hasattr(client, 'translate')}")
    print(f"  - get_retry_stats方法: {hasattr(client, 'get_retry_stats')}")
    print(f"  - RetryStats类: 正常工作")
    print("  ✓ GroqClient 验证通过")
    return True

def verify_tts_generator():
    """验证 TTSGenerator 模块"""
    from modules import TTSGenerator, TTSConfig
    
    generator = TTSGenerator()
    voices = generator.get_available_voices()
    
    print("\nTTSGenerator 功能检查:")
    print(f"  - 可用语音: {list(voices.keys())}")
    print(f"  - generate_single方法: {hasattr(generator, 'generate_single')}")
    print(f"  - generate方法: {hasattr(generator, 'generate')}")
    print("  ✓ TTSGenerator 验证通过")
    return True

def verify_smart_segmenter():
    """验证 SmartSegmenter 模块"""
    from modules import SmartSegmenter, SegmenterConfig
    
    segmenter = SmartSegmenter()
    
    print("\nSmartSegmenter 功能检查:")
    print(f"  - 最大片段时长: {segmenter.config.max_segment_duration}s")
    print(f"  - 最小片段时长: {segmenter.config.min_segment_duration}s")
    print(f"  - 静音阈值: {segmenter.config.silence_threshold_db}dB")
    print(f"  - segment_audio方法: {hasattr(segmenter, 'segment_audio')}")
    print(f"  - should_segment方法: {hasattr(segmenter, 'should_segment')}")
    print("  ✓ SmartSegmenter 验证通过")
    return True

def verify_audio_sync_engine():
    """验证 AudioSyncEngine 模块"""
    from modules import AudioSyncEngine, SyncConfig
    
    engine = AudioSyncEngine()
    
    print("\nAudioSyncEngine 功能检查:")
    print(f"  - 最大变速比例: {engine.config.max_speed_ratio}x")
    print(f"  - 同步容差: {engine.config.sync_tolerance}s")
    print(f"  - align方法: {hasattr(engine, 'align')}")
    print(f"  - align_segment方法: {hasattr(engine, 'align_segment')}")
    print(f"  - check_sync_drift方法: {hasattr(engine, 'check_sync_drift')}")
    print("  ✓ AudioSyncEngine 验证通过")
    return True

def main():
    """主验证函数"""
    print("=" * 50)
    print("Universal Fast Dubbing - 核心模块验证")
    print("=" * 50)
    
    results = []
    
    try:
        results.append(("ErrorResponse", verify_error_response()))
    except Exception as e:
        print(f"ErrorResponse 验证失败: {e}")
        results.append(("ErrorResponse", False))
    
    try:
        results.append(("LoggingConfig", verify_logging_config()))
    except Exception as e:
        print(f"LoggingConfig 验证失败: {e}")
        results.append(("LoggingConfig", False))
    
    try:
        results.append(("GroqClient", verify_groq_client()))
    except Exception as e:
        print(f"GroqClient 验证失败: {e}")
        results.append(("GroqClient", False))
    
    try:
        results.append(("TTSGenerator", verify_tts_generator()))
    except Exception as e:
        print(f"TTSGenerator 验证失败: {e}")
        results.append(("TTSGenerator", False))
    
    try:
        results.append(("SmartSegmenter", verify_smart_segmenter()))
    except Exception as e:
        print(f"SmartSegmenter 验证失败: {e}")
        results.append(("SmartSegmenter", False))
    
    try:
        results.append(("AudioSyncEngine", verify_audio_sync_engine()))
    except Exception as e:
        print(f"AudioSyncEngine 验证失败: {e}")
        results.append(("AudioSyncEngine", False))
    
    print("\n" + "=" * 50)
    print("验证结果汇总:")
    print("=" * 50)
    
    all_passed = True
    for name, passed in results:
        status = "✓ 通过" if passed else "✗ 失败"
        print(f"  {name}: {status}")
        if not passed:
            all_passed = False
    
    print("=" * 50)
    if all_passed:
        print("所有核心模块验证通过!")
    else:
        print("部分模块验证失败，请检查!")
    
    return all_passed

if __name__ == "__main__":
    success = main()
    sys.exit(0 if success else 1)