"""Development-only JSON webhook receiver. Run with Python 3.11+.

No business actions, persistent storage, or payload logging. Add provider signature
verification and duplicate-event handling before using real webhook data.
"""
from __future__ import annotations

import argparse
import json
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from typing import Any

MAX_BODY = 64 * 1024


class WebhookHandler(BaseHTTPRequestHandler):
    def setup(self) -> None:
        super().setup()
        self.connection.settimeout(10)

    def log_message(self, format: str, *args: Any) -> None:
        pass  # Never log request paths, payloads, or credentials in this demo.

    def reply(self, status: int, payload: dict[str, object]) -> None:
        body = json.dumps(payload, separators=(",", ":")).encode()
        self.send_response(status)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(body)))
        self.send_header("Cache-Control", "no-store")
        self.send_header("Connection", "close")
        self.end_headers()
        self.wfile.write(body)
        self.close_connection = True

    def do_GET(self) -> None:  # noqa: N802 - standard-library handler contract
        if self.path == "/health":
            self.reply(200, {"ok": True})
        else:
            self.reply(404, {"error": "not_found"})

    def do_POST(self) -> None:  # noqa: N802 - standard-library handler contract
        if self.path != "/webhook":
            self.reply(404, {"error": "not_found"})
            return
        if self.headers.get("Transfer-Encoding"):
            self.reply(400, {"error": "content_length_required"})
            return
        lengths = self.headers.get_all("Content-Length", [])
        try:
            if len(lengths) != 1:
                raise ValueError
            length = int(lengths[0])
        except ValueError:
            self.reply(411, {"error": "content_length_required"})
            return
        if not 0 < length <= MAX_BODY:
            self.reply(413, {"error": "body_size_out_of_range"})
            return
        if self.headers.get_content_type() != "application/json":
            self.reply(415, {"error": "expected_application_json"})
            return
        try:
            data = self.rfile.read(length)
            if len(data) != length:
                raise ValueError
            payload = json.loads(data)
            if not isinstance(payload, dict):
                raise ValueError
        except (ValueError, UnicodeError, TimeoutError):
            self.reply(400, {"error": "invalid_json"})
            return
        event = payload.get("event")
        self.reply(200, {"received": True, "event": event if isinstance(event, str) else None})


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--port", type=int, default=8000)
    args = parser.parse_args()
    if not 1 <= args.port <= 65535:
        parser.error("port must be between 1 and 65535")
    server = ThreadingHTTPServer(("127.0.0.1", args.port), WebhookHandler)
    print(f"Listening on http://127.0.0.1:{args.port}/webhook", flush=True)
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        pass
    finally:
        server.server_close()


if __name__ == "__main__":
    main()