# zmq_server.py - ZeroMQ 请求应答模式的服务器端

import zmq
import time

# 1. 创建 ZeroMQ Context 对象
# Context 是 ZeroMQ 运行时环境的管理者
context = zmq.Context()

# 2. 创建一个 REP (Reply) Socket
# REP Socket 用于接收请求并发送应答
socket = context.socket(zmq.REP)

# 3. 将 Socket 绑定到一个地址
# "tcp://*:5555" 表示使用 TCP 协议，绑定到所有可用网络接口的 5555 端口
# "*" 表示绑定到所有本地地址，方便客户端连接
bind_address = "tcp://localhost:5555"
socket.bind(bind_address)

print(f"ZeroMQ REP 服务器已启动，绑定在 {bind_address}")
print("等待接收请求...")

try:
    # 服务器通常在一个无限循环中运行，不断接收和处理请求
    while True:
        # 4. 接收请求
        # socket.recv_string() 会阻塞，直到收到一个字符串消息
        message = socket.recv_string()
        print(f"收到请求: '{message}'")

        # 模拟处理请求的过程
        time.sleep(1) # 假装服务器需要处理一下

        # 5. 准备应答消息
        reply_message = f"服务器收到你的消息: '{message}'"

        # 6. 发送应答
        # socket.send_string() 会发送一个字符串应答
        # 在 REP-REQ 模式中，REP Socket 必须在发送应答前先接收一个请求
        socket.send_string(reply_message)
        print(f"发送应答: '{reply_message}'")

except KeyboardInterrupt:
    print("\n检测到 Ctrl+C，正在关闭服务器...")
finally:
    # 清理 ZeroMQ 资源
    socket.close()
    context.term()
    print("服务器已安全关闭。")

# zmq_client.py - ZeroMQ 请求应答模式的客户端

import zmq

# 1. 创建 ZeroMQ Context 对象
context = zmq.Context()

# 2. 创建一个 REQ (Request) Socket
# REQ Socket 用于发送请求并接收应答
socket = context.socket(zmq.REQ)

# 3. 连接到服务器的地址
# "tcp://localhost:5555" 表示使用 TCP 协议，连接到本地的 5555 端口
# 如果服务器在另一台机器上，请将 'localhost' 替换为服务器的实际 IP 地址
connect_address = "tcp://localhost:5555"
socket.connect(connect_address)

print(f"ZeroMQ REQ 客户端已启动，连接到 {connect_address}")
print("你可以输入消息发送给服务器，输入 'quit' 退出。")

try:
    # 客户端通常在一个循环中运行，允许发送多条消息
    while True:
        # 获取用户输入
        user_input = input("请输入消息: ")

        # 检查是否输入 'quit'
        if user_input.lower() == 'quit':
            break

        # 4. 发送请求
        # socket.send_string() 会发送用户输入的字符串消息
        # 在 REQ-REP 模式中，REQ Socket 必须在发送请求后等待一个应答，不能连续发送请求
        print(f"发送请求: '{user_input}'")
        socket.send_string(user_input)

        # 5. 接收应答
        # socket.recv_string() 会阻塞，直到收到服务器的应答消息
        reply_message = socket.recv_string()
        print(f"收到应答: '{reply_message}'")
        print("-" * 20) # 分隔线

except KeyboardInterrupt:
    print("\n检测到 Ctrl+C，正在关闭客户端...")
finally:
    # 清理 ZeroMQ 资源
    socket.close()
    context.term()
    print("客户端已安全关闭。")

# inproc_asyncio_example.py - 在同一个进程内使用 inproc:// 传输协议

import asyncio
import zmq
import zmq.asyncio as azmq # 使用异步版本

# 定义 inproc 地址
INPROC_ADDRESS = "inproc://my_async_channel"

# 异步 REP Worker 协程 (运行在同一个进程内)
async def async_rep_worker(context: azmq.Context):
    # 从传入的异步 Context 创建 REP Socket
    socket = context.socket(zmq.REP)
    # 绑定到 inproc 地址
    socket.bind(INPROC_ADDRESS)
    print(f"REP Worker (进程内) 已启动，绑定到 {INPROC_ADDRESS}")

    try:
        while True:
            # 异步接收请求
            message = await socket.recv_string()
            print(f"REP Worker (进程内) 收到请求: '{message}'")

            # 模拟处理
            await asyncio.sleep(0.5)

            reply = f"REP Worker (进程内) 收到并处理了: '{message}'"
            # 异步发送应答
            await socket.send_string(reply)
            print(f"REP Worker (进程内) 发送应答: '{reply}'")

    except asyncio.CancelledError:
        print("\nREP Worker (进程内) 被取消，正在退出...")
    finally:
        socket.close()
        print("REP Worker (进程内) Socket 已关闭。")


# 异步 REQ Client 协程 (运行在同一个进程内)
async def async_req_client(context: azmq.Context):
     # 从传入的异步 Context 创建 REQ Socket
    socket = context.socket(zmq.REQ)
    # 连接到 inproc 地址 (注意：这个地址必须在同一个进程内已经被某个 socket 绑定了)
    socket.connect(INPROC_ADDRESS)
    print(f"REQ Client (进程内) 已启动，连接到 {INPROC_ADDRESS}")

    try:
        for i in range(3):
            request = f"进程内请求 {i+1}"
            print(f"REQ Client (进程内) 发送请求: '{request}'")
            # 异步发送请求
            await socket.send_string(request)

            # 异步接收应答
            reply = await socket.recv_string()
            print(f"REQ Client (进程内) 收到应答: '{reply}'")
            await asyncio.sleep(0.1) # 稍微等一下再发下一个请求
            
    finally:
        socket.close()
        print("REQ Client (进程内) Socket 已关闭。")

# 主异步函数，启动和管理 Worker 和 Client 协程
async def main():
    # 在主函数中创建唯一一个异步 Context
    # 这个 Context 将用于创建所有需要通过 inproc 通信的 Socket
    context = azmq.Context()
    print("主程序: Asyncio Context 已创建")

    # 使用 asyncio.create_task 启动 Worker 和 Client 协程
    # 它们将在同一个事件循环、同一个进程内并发运行
    worker_task = asyncio.create_task(async_rep_worker(context))
    client_task = asyncio.create_task(async_req_client(context))

    # 等待 Client 任务完成它的请求
    await client_task
    print("主程序: Client 任务完成。")

    # Client 任务完成后，取消 Worker 任务以退出
    worker_task.cancel()
    try:
        await worker_task # 等待 Worker 任务响应取消信号
    except asyncio.CancelledError:
        print("主程序: Worker 任务已被取消。")

    # Context 的清理通常由 asyncio.run() 负责，或者可以手动 context.term()
    # context.term() # 如果手动管理循环，需要 term

# 程序的入口点
if __name__ == "__main__":
    print("--- 进程内 ZeroMQ (inproc) 示例启动 ---")
    # 使用 asyncio.run 运行主异步函数
    # 这将启动事件循环，并在同一个进程中调度 worker_task 和 client_task
    asyncio.run(main())
    print("--- 进程内 ZeroMQ (inproc) 示例结束 ---")