#!/usr/bin/env python3
"""
本地并发控制模块演示脚本

展示本地并发控制的核心功能。
"""

import time
import threading
from core.concurrency_control import (
    SemaphoreControl,
    ReadWriteLock,
    RateLimiter,
    LocalDistributedLock,
    ConcurrentCounter,
    ThreadBarrier,
    BoundedTaskQueue,
    concurrency_manager,
)


def demo_semaphore():
    """演示信号量"""
    print("\n" + "="*60)
    print("演示1: 信号量并发控制")
    print("="*60)
    
    semaphore = SemaphoreControl(max_concurrent=3)
    active_count = [0]
    max_active = [0]
    lock = threading.Lock()
    
    def worker():
        with semaphore.acquire():
            with lock:
                active_count[0] += 1
                max_active[0] = max(max_active[0], active_count[0])
            time.sleep(0.2)
            with lock:
                active_count[0] -= 1
    
    threads = [threading.Thread(target=worker) for _ in range(10)]
    for t in threads:
        t.start()
    for t in threads:
        t.join()
    
    print(f"✅ 10个线程执行完成")
    print(f"✅ 最大并发数: {max_active[0]} (限制为3)")
    print(f"✅ 统计: {semaphore.get_stats()}")


def demo_read_write_lock():
    """演示读写锁"""
    print("\n" + "="*60)
    print("演示2: 读写锁")
    print("="*60)
    
    rw_lock = ReadWriteLock()
    data = {"value": 0}
    
    def reader():
        with rw_lock.read_lock():
            _ = data["value"]
            time.sleep(0.05)
    
    def writer():
        with rw_lock.write_lock():
            data["value"] += 1
            time.sleep(0.05)
    
    # 5个读线程
    read_threads = [threading.Thread(target=reader) for _ in range(5)]
    # 2个写线程
    write_threads = [threading.Thread(target=writer) for _ in range(2)]
    
    for t in read_threads + write_threads:
        t.start()
    for t in read_threads + write_threads:
        t.join()
    
    print(f"✅ 5个读线程 + 2个写线程执行完成")
    print(f"✅ 最终数据值: {data['value']}")


def demo_rate_limiter():
    """演示限流器"""
    print("\n" + "="*60)
    print("演示3: 限流器")
    print("="*60)
    
    limiter = RateLimiter(max_requests=5, time_window=1)
    
    # 前5个请求应该通过
    allowed = 0
    for i in range(5):
        if limiter.allow_request():
            allowed += 1
    print(f"✅ 前5个请求通过: {allowed}")
    
    # 超出限制应该被阻止
    blocked = 0
    for i in range(3):
        if not limiter.allow_request():
            blocked += 1
    print(f"✅ 超出限制被阻止: {blocked}")
    
    # 等待时间窗口重置
    print("⏱️ 等待1.1秒...")
    time.sleep(1.1)
    
    reset_allowed = 0
    for i in range(3):
        if limiter.allow_request():
            reset_allowed += 1
    print(f"✅ 重置后通过: {reset_allowed}")
    print(f"✅ 统计: {limiter.get_stats()}")


def demo_distributed_lock():
    """演示分布式锁"""
    print("\n" + "="*60)
    print("演示4: 分布式锁(本地模拟)")
    print("="*60)
    
    lock = LocalDistributedLock("test_resource")
    acquired_count = [0]
    lock_obj = threading.Lock()
    
    def try_acquire():
        if lock.acquire(timeout=0.5):
            with lock_obj:
                acquired_count[0] += 1
            time.sleep(0.2)
            lock.release()
    
    threads = [threading.Thread(target=try_acquire) for _ in range(5)]
    for t in threads:
        t.start()
    for t in threads:
        t.join()
    
    print(f"✅ 5个线程尝试获取锁")
    print(f"✅ 成功获取锁次数: {acquired_count[0]}")
    
    # 测试超时释放
    lock2 = LocalDistributedLock("test_resource2", expire_seconds=1)
    lock2.acquire()
    print("✅ 获取锁(1秒过期)")
    time.sleep(1.2)
    assert lock2.acquire(), "超时后应该可以重新获取锁"
    print("✅ 超时后成功重新获取锁")
    lock2.release()


def demo_concurrent_counter():
    """演示并发计数器"""
    print("\n" + "="*60)
    print("演示5: 并发计数器")
    print("="*60)
    
    counter = ConcurrentCounter(initial_value=0)
    
    def increment_worker():
        for _ in range(100):
            counter.increment()
    
    threads = [threading.Thread(target=increment_worker) for _ in range(10)]
    for t in threads:
        t.start()
    for t in threads:
        t.join()
    
    print(f"✅ 10个线程各递增100次")
    print(f"✅ 最终计数值: {counter.get_value()} (期望: 1000)")
    
    # 递减
    def decrement_worker():
        for _ in range(50):
            counter.decrement()
    
    threads = [threading.Thread(target=decrement_worker) for _ in range(5)]
    for t in threads:
        t.start()
    for t in threads:
        t.join()
    
    print(f"✅ 5个线程各递减50次")
    print(f"✅ 最终计数值: {counter.get_value()} (期望: 750)")


def demo_barrier():
    """演示屏障"""
    print("\n" + "="*60)
    print("演示6: 线程屏障")
    print("="*60)
    
    barrier = ThreadBarrier(parties=3)
    arrival_times = []
    lock = threading.Lock()
    
    def worker():
        time.sleep(0.05)
        barrier.wait()
        with lock:
            arrival_times.append(time.time())
    
    threads = [threading.Thread(target=worker) for _ in range(3)]
    start_time = time.time()
    for t in threads:
        t.start()
    for t in threads:
        t.join()
    
    max_diff = max(arrival_times) - min(arrival_times)
    print(f"✅ 3个线程通过屏障")
    print(f"✅ 最大到达时间差: {max_diff:.4f}s")


def demo_bounded_queue():
    """演示有界队列"""
    print("\n" + "="*60)
    print("演示7: 有界任务队列")
    print("="*60)
    
    queue = BoundedTaskQueue(max_size=3)
    
    # 添加3个任务
    for i in range(3):
        queue.put(f"task_{i}")
    print("✅ 添加3个任务")
    
    # 尝试添加第4个（应该阻塞）
    print("⏱️ 尝试添加第4个任务（应该超时）...")
    try:
        queue.put("overflow_task", timeout=0.1)
        print("⚠️ 添加成功（意外）")
    except TimeoutError:
        print("✅ 队列满时正确阻塞")
    
    # 消费任务
    tasks = []
    for _ in range(3):
        tasks.append(queue.get(timeout=0.1))
    print(f"✅ 消费任务: {tasks}")


def demo_manager():
    """演示并发管理器"""
    print("\n" + "="*60)
    print("演示8: 并发控制器管理器")
    print("="*60)
    
    # 创建命名信号量
    semaphore = concurrency_manager.create_semaphore("api_limit", max_concurrent=5)
    print("✅ 创建命名信号量: api_limit")
    
    # 获取已创建的组件
    retrieved = concurrency_manager.get_semaphore("api_limit")
    print(f"✅ 获取信号量: {retrieved is semaphore}")
    
    # 获取统计信息
    stats = concurrency_manager.get_all_stats()
    print(f"✅ 统计信息: {stats}")


def main():
    """主函数"""
    print("\n" + "="*60)
    print("本地并发控制模块演示")
    print("="*60)
    
    demo_semaphore()
    demo_read_write_lock()
    demo_rate_limiter()
    demo_distributed_lock()
    demo_concurrent_counter()
    demo_barrier()
    demo_bounded_queue()
    demo_manager()
    
    print("\n" + "="*60)
    print("✅ 所有演示完成!")
    print("="*60)


if __name__ == "__main__":
    main()