"""独立示例：本地 WSGI HTTP 请求与内存 ASGI 协议驱动。"""
import asyncio
import json
from collections import deque
from threading import Thread
from urllib.parse import parse_qs
from urllib.request import urlopen
from wsgiref.simple_server import make_server, WSGIRequestHandler


def response(query):
    raw = parse_qs(query, keep_blank_values=True).get("limit", ["10"])
    if len(raw) != 1:
        return 400, {"error": "invalid limit"}
    if len(raw[0]) > 3:
        return 400, {"error": "limit out of range"}
    if not raw[0].isascii() or not raw[0].isdecimal():
        return 400, {"error": "invalid limit"}
    if not 1 <= int(raw[0]) <= 100:
        return 400, {"error": "limit out of range"}
    return 200, {"limit": int(raw[0]), "errors": 2}


def wsgi_app(environ, start_response):
    status, payload = response(environ.get("QUERY_STRING", ""))
    body = json.dumps(payload, sort_keys=True).encode("utf-8")
    phrase = "OK" if status == 200 else "Bad Request"
    start_response(f"{status} {phrase}", [("Content-Type", "application/json"),
                                           ("Content-Length", str(len(body)))])
    return [body]  # WSGI 输出必须是 bytes，而非 str。


async def asgi_app(scope, receive, send):
    if scope["type"] != "http":
        raise ValueError("this example handles HTTP only")
    try:
        while True:
            event = await receive()
            if event["type"] == "http.disconnect":
                return
            if event["type"] == "http.request" and not event.get("more_body", False):
                break
        status, payload = response(scope["query_string"].decode("ascii"))
        body = json.dumps(payload, sort_keys=True).encode("utf-8")
        await send({"type": "http.response.start", "status": status,
                    "headers": [(b"content-type", b"application/json")]})
        await send({"type": "http.response.body", "body": body, "more_body": False})
    finally:
        scope.setdefault("state", {})["closed"] = True


async def exercise_asgi():
    messages = []
    incoming = deque([
        {"type": "http.request", "body": b"first", "more_body": True},
        {"type": "http.request", "body": b"last", "more_body": False},
    ])
    async def receive():
        return incoming.popleft()
    async def send(message):
        messages.append(message)
    scope = {"type": "http", "asgi": {"version": "3.0", "spec_version": "2.5"},
             "http_version": "1.1", "method": "GET", "scheme": "http",
             "path": "/", "raw_path": b"/", "query_string": b"limit=0",
             "root_path": "", "headers": [], "server": ("127.0.0.1", 80),
             "client": ("127.0.0.1", 12345)}
    await asgi_app(scope, receive, send)
    assert messages[0]["status"] == 400
    assert messages[-1]["more_body"] is False
    assert not incoming
    assert scope["state"]["closed"]
    print("ASGI:", messages[0]["status"], messages[-1]["body"].decode())
    messages.clear()
    incoming.append({"type": "http.disconnect"})
    scope["state"]["closed"] = False
    await asgi_app(scope, receive, send)
    assert not messages and scope["state"]["closed"]
    incoming.append({"type": "http.request", "body": b"", "more_body": False})
    async def failed_send(message):
        raise RuntimeError("injected send failure")
    scope["state"]["closed"] = False
    try:
        await asgi_app(scope, receive, failed_send)
    except RuntimeError as error:
        assert str(error) == "injected send failure"
    else:
        raise AssertionError("send failure swallowed")
    assert scope["state"]["closed"]
    print("ASGI disconnect/send failure cleanup: passed")


class QuietHandler(WSGIRequestHandler):
    def setup(self):
        super().setup()
        self.connection.settimeout(3)  # 已接收连接的读写也必须有界。

    def log_message(self, format, *args):
        pass  # 示例不打印时间等非确定性日志。


if __name__ == "__main__":
    with make_server("127.0.0.1", 0, wsgi_app, handler_class=QuietHandler) as server:
        server.timeout = 3  # 客户端未发出请求时，handle_request 也会退出。
        worker = Thread(target=server.handle_request)
        worker.start()
        try:
            with urlopen(f"http://127.0.0.1:{server.server_port}/?limit=3", timeout=3) as result:
                body = result.read().decode("utf-8")
                assert result.status == 200
                print("WSGI:", result.status, body)
        finally:
            worker.join(timeout=7)
            if worker.is_alive():
                raise RuntimeError("demo server did not stop")
    asyncio.run(exercise_asgi())
