#!/usr/bin/env python3
"""
简单的 API 兼容性测试
专注于 API 格式验证，不连接实际的 Kafka 服务器
"""

import os
import sys

# 添加当前目录到 Python 路径
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

from client_v2 import KafkaConsumerWrapper, KafkaMessageWrapper

def test_poll_method_signature():
    """测试 poll 方法签名兼容性"""
    print("=== 测试 poll 方法签名 ===")
    
    # 创建模拟的消费者
    class MockConsumer:
        def poll(self, timeout_ms=None, max_records=None):
            return {}  # 返回空字典
    
    wrapper = KafkaConsumerWrapper(MockConsumer())
    
    # 测试不同的调用方式
    test_cases = [
        lambda: wrapper.poll(timeout=1.0),  # confluent-kafka 格式
        lambda: wrapper.poll(timeout_ms=1000),  # kafka-python 格式
        lambda: wrapper.poll(),  # 无参数
        lambda: wrapper.poll(timeout=2.0, max_records=10),  # 混合参数
    ]
    
    for i, test_func in enumerate(test_cases, 1):
        try:
            result = test_func()
            print(f"   ✓ 测试 {i}: 调用成功")
        except Exception as e:
            print(f"   ✗ 测试 {i}: 调用失败 - {e}")
            return False
    
    return True

def test_message_wrapper():
    """测试消息包装器"""
    print("\n=== 测试消息包装器 ===")
    
    # 创建模拟消息记录
    class MockRecord:
        def __init__(self):
            self.topic = "test-topic"
            self.partition = 0
            self.offset = 12345
            self.timestamp = 1234567890
            self.key = b"test-key"
            self.value = b"test-value"
    
    record = MockRecord()
    message = KafkaMessageWrapper(record)
    
    # 测试属性访问
    try:
        # 测试 lambda 属性
        print(f"   ✓ topic(): {message.topic()}")
        print(f"   ✓ partition(): {message.partition()}")
        print(f"   ✓ offset(): {message.offset()}")
        print(f"   ✓ timestamp(): {message.timestamp()}")
        print(f"   ✓ key(): {message.key()}")
        print(f"   ✓ value(): {message.value()}")
        print(f"   ✓ error(): {message.error()}")
        
        # 测试直接属性访问（兼容 confluent-kafka）
        print(f"   ✓ message.topic: {message.topic}")
        print(f"   ✓ message.value: {message.value}")
        
        return True
    except Exception as e:
        print(f"   ✗ 消息包装器测试失败: {e}")
        return False

def test_business_pattern():
    """测试业务代码模式"""
    print("\n=== 测试业务代码模式 ===")
    
    # 模拟业务代码中的调用模式
    POLL_TIMEOUT = 1.5
    
    class MockConsumer:
        def poll(self, timeout_ms=None, max_records=None):
            # 模拟返回空结果
            return {}
    
    # 创建包装消费者
    consumer = KafkaConsumerWrapper(MockConsumer())
    
    try:
        # 这是业务代码中的实际调用方式
        msg = consumer.poll(timeout=POLL_TIMEOUT)
        print(f"   ✓ 业务代码调用成功: poll(timeout={POLL_TIMEOUT})")
        
        # 测试消息处理
        if msg is None:
            print("   ✓ 无消息返回（正常情况）")
        else:
            print(f"   ✓ 消息返回: {type(msg)}")
        
        return True
        
    except Exception as e:
        print(f"   ✗ 业务代码模式调用失败: {e}")
        return False

def main():
    """主测试函数"""
    print("开始 API 兼容性测试（无服务器连接）...")
    
    results = []
    
    # 运行各项测试
    results.append(test_poll_method_signature())
    results.append(test_message_wrapper())
    results.append(test_business_pattern())
    
    # 汇总结果
    print("\n=== 测试结果汇总 ===")
    if all(results):
        print("✓ 所有测试通过！API 兼容性良好")
        print("✓ 修复方案有效，业务代码无需修改")
        return 0
    else:
        print("✗ 部分测试失败，需要检查")
        return 1

if __name__ == "__main__":
    sys.exit(main())