#!/usr/bin/env python3
"""
Example of using logging middleware with aiohttp client.

This example shows how to implement a middleware that logs request timing
and response status. This is useful for debugging, monitoring, and
understanding the flow of HTTP requests in your application.

This example includes a test server with various endpoints.
"""

import asyncio
import json
import logging
import time
from collections.abc import Coroutine
from typing import Any

from aiohttp import ClientHandlerType, ClientRequest, ClientResponse, ClientSession, web

logging.basicConfig(
    level=logging.DEBUG, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
)
_LOGGER = logging.getLogger(__name__)


class LoggingMiddleware:
    """Middleware that logs request timing and response status."""

    async def __call__(
        self,
        request: ClientRequest,
        handler: ClientHandlerType,
    ) -> ClientResponse:
        start_time = time.monotonic()

        # Log request
        _LOGGER.info("[REQUEST] %s %s", request.method, request.url)
        if request.headers:
            _LOGGER.debug("[REQUEST HEADERS] %s", request.headers)

        # Execute request
        response = await handler(request)

        # Log response
        duration = time.monotonic() - start_time
        _LOGGER.info(
            "[RESPONSE] %s %s - Status: %s - Duration: %.3fs",
            request.method,
            request.url,
            response.status,
            duration,
        )
        _LOGGER.debug("[RESPONSE HEADERS] %s", response.headers)

        return response


class TestServer:
    """Test server for logging middleware demo."""

    async def handle_hello(self, request: web.Request) -> web.Response:
        """Simple hello endpoint."""
        name = request.match_info.get("name", "World")
        return web.json_response({"message": f"Hello, {name}!"})

    async def handle_slow(self, request: web.Request) -> web.Response:
        """Endpoint that simulates slow response."""
        delay = float(request.match_info.get("delay", 1))
        await asyncio.sleep(delay)
        return web.json_response({"message": "Slow response completed", "delay": delay})

    async def handle_error(self, request: web.Request) -> web.Response:
        """Endpoint that returns an error."""
        status = int(request.match_info.get("status", 500))
        return web.Response(status=status, text=f"Error response with status {status}")

    async def handle_json_data(self, request: web.Request) -> web.Response:
        """Endpoint that echoes JSON data."""
        try:
            data = await request.json()
            return web.json_response({"echo": data, "received_at": time.time()})
        except json.JSONDecodeError:
            return web.json_response({"error": "Invalid JSON"}, status=400)


async def run_test_server() -> web.AppRunner:
    """Run a simple test server."""
    app = web.Application()
    server = TestServer()

    app.router.add_get("/hello", server.handle_hello)
    app.router.add_get("/hello/{name}", server.handle_hello)
    app.router.add_get("/slow/{delay}", server.handle_slow)
    app.router.add_get("/error/{status}", server.handle_error)
    app.router.add_post("/echo", server.handle_json_data)

    runner = web.AppRunner(app)
    await runner.setup()
    site = web.TCPSite(runner, "localhost", 8080)
    await site.start()
    return runner


async def run_tests() -> None:
    """Run all the middleware tests."""
    # Create logging middleware
    logging_middleware = LoggingMiddleware()

    # Use middleware in session
    async with ClientSession(middlewares=(logging_middleware,)) as session:
        # Test 1: Simple GET request
        print("\n=== Test 1: Simple GET request ===")
        async with session.get("http://localhost:8080/hello") as resp:
            data = await resp.json()
            print(f"Response: {data}")

        # Test 2: GET with parameter
        print("\n=== Test 2: GET with parameter ===")
        async with session.get("http://localhost:8080/hello/Alice") as resp:
            data = await resp.json()
            print(f"Response: {data}")

        # Test 3: Slow request
        print("\n=== Test 3: Slow request (2 seconds) ===")
        async with session.get("http://localhost:8080/slow/2") as resp:
            data = await resp.json()
            print(f"Response: {data}")

        # Test 4: Error response
        print("\n=== Test 4: Error response ===")
        async with session.get("http://localhost:8080/error/404") as resp:
            text = await resp.text()
            print(f"Response: {text}")

        # Test 5: POST with JSON data
        print("\n=== Test 5: POST with JSON data ===")
        payload = {"name": "Bob", "age": 30, "city": "New York"}
        async with session.post("http://localhost:8080/echo", json=payload) as resp:
            data = await resp.json()
            print(f"Response: {data}")

        # Test 6: Multiple concurrent requests
        print("\n=== Test 6: Multiple concurrent requests ===")
        coros: list[Coroutine[Any, Any, ClientResponse]] = []
        for i in range(3):
            coro = session.get(f"http://localhost:8080/hello/User{i}")
            coros.append(coro)

        responses = await asyncio.gather(*coros)
        for i, resp in enumerate(responses):
            async with resp:
                data = await resp.json()
                print(f"Concurrent request {i}: {data}")


async def main() -> None:
    # Start test server
    server = await run_test_server()

    try:
        await run_tests()

    finally:
        # Cleanup server
        await server.cleanup()


if __name__ == "__main__":
    asyncio.run(main())
