#!/usr/bin/env python3
"""Synthetic fixture server for proof_of_done tests (127.0.0.1, ephemeral port).

Routes: /ok 200 page, /redirect 301 -> /ok, /redirect-wrong 301 -> /missing,
/missing 404, /file.bin known bytes, /slow (3 s before responding), /loop redirect loop.
Run standalone: prints the port and serves until interrupted.
"""
import hashlib
import http.server
import ssl
import threading
import time

OK_BODY = b"<html><body><h1>Carehab fixture OK</h1><p>synthetic page</p></body></html>\n"
FILE_BODY = b"carehab synthetic file v1\n" * 100
FILE_SHA256 = hashlib.sha256(FILE_BODY).hexdigest()
SLOW_SECONDS = 3.0


class Handler(http.server.BaseHTTPRequestHandler):
    def log_message(self, *a):
        pass

    def _send(self, code, body=b"", headers=()):
        self.send_response(code)
        for k, v in headers:
            self.send_header(k, v)
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        self.wfile.write(body)

    def do_GET(self):
        path = self.path.split("?")[0]
        try:
            if path == "/ok":
                self._send(200, OK_BODY, [("Content-Type", "text/html")])
            elif path == "/redirect":
                self._send(301, b"", [("Location", "/ok")])
            elif path == "/redirect-wrong":
                self._send(301, b"", [("Location", "/missing")])
            elif path == "/loop":
                self._send(302, b"", [("Location", "/loop")])
            elif path == "/file.bin":
                self._send(200, FILE_BODY, [("Content-Type", "application/octet-stream")])
            elif path == "/slow":
                time.sleep(SLOW_SECONDS)
                self._send(200, OK_BODY)
            else:
                self._send(404, b"not found\n")
        except (BrokenPipeError, ConnectionResetError, ssl.SSLError):
            pass


class Server(http.server.ThreadingHTTPServer):
    daemon_threads = True

    def handle_error(self, request, client_address):
        pass  # expected: clients that reject our cert or time out


def start(certfile=None, keyfile=None):
    """Start server in a daemon thread. Returns (server, port)."""
    srv = Server(("127.0.0.1", 0), Handler)
    if certfile:
        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
        ctx.load_cert_chain(certfile, keyfile)
        srv.socket = ctx.wrap_socket(srv.socket, server_side=True)
    threading.Thread(target=srv.serve_forever, daemon=True).start()
    return srv, srv.server_address[1]


if __name__ == "__main__":
    srv, port = start()
    print(port, flush=True)
    try:
        threading.Event().wait()
    except KeyboardInterrupt:
        srv.shutdown()