"""Stdlib smart-HTTP git server: ThreadingHTTPServer CGI-execing `git http-backend`.

This is the git side of the netshape lane's "both subjects served from local

disk through the same shaped pipe" promise — and unlike the shaped pipe it

runs everywhere, including the macOS dev host, so it is tested for real

(clone and push over HTTP, not mocks).

Contract:

- GET/POST are forwarded to `git http-backend` with the CGI environment it

  documents: GIT_PROJECT_ROOT, GIT_HTTP_EXPORT_ALL=1, PATH_INFO,

  QUERY_STRING, REQUEST_METHOD, CONTENT_TYPE, CONTENT_LENGTH, request body on

  stdin. REMOTE_USER is explicitly unset: this server is anonymous, pushes

  are allowed only when the served repo sets http.receivepack=true.

- Protocol v2 passes through: the client's Git-Protocol header is forwarded

  as HTTP_GIT_PROTOCOL (http-backend hands it to upload-pack as

  GIT_PROTOCOL). Observed header values are recorded on the server object so

  tests can assert v2 actually traversed the server.

- request_log records "METHOD /path?query" for every request, so lanes and

  tests can assert the smart paths (/info/refs?service=...) were exercised.

"""

from __future__ import annotations

import os

import subprocess

import threading

import urllib.parse

from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

from pathlib import Path

from typing import Optional

class _GitHTTPRequestHandler(BaseHTTPRequestHandler):

    protocol_version = "HTTP/1.1"

    server_version = "oakbench-gitserver/1"

    def do_GET(self) -> None:  # noqa: N802 - BaseHTTPRequestHandler API

        self._backend()

    def do_POST(self) -> None:  # noqa: N802 - BaseHTTPRequestHandler API

        self._backend()

    def log_message(self, format: str, *args) -> None:  # noqa: A002 - stdlib signature

        # request_log is the observable record; stderr noise is not.

        pass

    def _read_body(self) -> bytes:

        if self.command != "POST":

            return b""

        transfer_encoding = (self.headers.get("Transfer-Encoding") or "").lower()

        if "chunked" in transfer_encoding:

            # git uses chunked uploads past http.postBuffer; decode so a plain

            # CONTENT_LENGTH body reaches http-backend.

            chunks: list[bytes] = []

            while True:

                size_line = self.rfile.readline().strip()

                size = int(size_line.split(b";", 1)[0], 16)

                if size == 0:

                    self.rfile.readline()  # trailing CRLF after last chunk

                    break

                chunks.append(self.rfile.read(size))

                self.rfile.read(2)  # CRLF after each chunk

            return b"".join(chunks)

        length = int(self.headers.get("Content-Length") or 0)

        return self.rfile.read(length) if length > 0 else b""

    def _backend(self) -> None:

        owner: "GitHTTPServer" = self.server.owner  # type: ignore[attr-defined]

        path, _, query = self.path.partition("?")

        owner._record_request(f"{self.command} {self.path}")

        git_protocol = self.headers.get("Git-Protocol")

        if git_protocol:

            owner._record_protocol(git_protocol)

        body = self._read_body()

        env = os.environ.copy()

        env.pop("REMOTE_USER", None)  # anonymous server; never an auth identity

        env.update(

            {

                "GIT_PROJECT_ROOT": str(owner.root),

                "GIT_HTTP_EXPORT_ALL": "1",

                "PATH_INFO": urllib.parse.unquote(path),

                "QUERY_STRING": query,

                "REQUEST_METHOD": self.command,

                "REMOTE_ADDR": self.client_address[0],

            }

        )

        if self.command == "POST":

            env["CONTENT_LENGTH"] = str(len(body))

        content_type = self.headers.get("Content-Type")

        if content_type:

            env["CONTENT_TYPE"] = content_type

        content_encoding = self.headers.get("Content-Encoding")

        if content_encoding:

            # http-backend inflates gzip request bodies itself.

            env["HTTP_CONTENT_ENCODING"] = content_encoding

        if git_protocol:

            env["HTTP_GIT_PROTOCOL"] = git_protocol  # protocol v2 passthrough

        try:

            proc = subprocess.run(

                [str(owner.git_bin), "http-backend"],

                input=body,

                env=env,

                stdout=subprocess.PIPE,

                stderr=subprocess.PIPE,

            )

        except OSError as exc:

            self._send_error_response(500, f"git http-backend failed to start: {exc}")

            return

        head, sep, payload = proc.stdout.partition(b"\r\n\r\n")

        if not sep:

            head, sep, payload = proc.stdout.partition(b"\n\n")

        if not sep:

            detail = proc.stderr.decode("utf-8", "replace")[-2000:]

            self._send_error_response(500, f"malformed CGI response from git http-backend: {detail}")

            return

        status = 200

        headers: list[tuple[str, str]] = []

        for line in head.decode("iso-8859-1").splitlines():

            if ":" not in line:

                continue

            key, value = line.split(":", 1)

            key, value = key.strip(), value.strip()

            if key.lower() == "status":

                status = int(value.split(None, 1)[0])

            else:

                headers.append((key, value))

        self.send_response(status)

        for key, value in headers:

            self.send_header(key, value)

        self.send_header("Content-Length", str(len(payload)))

        self.end_headers()

        self.wfile.write(payload)

    def _send_error_response(self, status: int, message: str) -> None:

        body = message.encode("utf-8", "replace")

        self.send_response(status)

        self.send_header("Content-Type", "text/plain; charset=utf-8")

        self.send_header("Content-Length", str(len(body)))

        self.end_headers()

        self.wfile.write(body)

class GitHTTPServer:

    """Serve every bare repo under `root` over smart HTTP at /<name>.git.

    port=0 binds an ephemeral port (read it back from `url`). Pushes work only

    on repos configured with http.receivepack=true; that is the served repo's

    choice, not this server's.

    """

    def __init__(self, root: Path, port: int = 0, *, host: str = "127.0.0.1", git_bin: str = "git") -> None:

        self.root = Path(root)

        self.host = host

        self.port = port

        self.git_bin = git_bin

        self.request_log: list[str] = []

        self.git_protocol_headers: list[str] = []

        self._lock = threading.Lock()

        self._httpd: Optional[ThreadingHTTPServer] = None

        self._thread: Optional[threading.Thread] = None

    def _record_request(self, entry: str) -> None:

        with self._lock:

            self.request_log.append(entry)

    def _record_protocol(self, value: str) -> None:

        with self._lock:

            self.git_protocol_headers.append(value)

    @property

    def server_port(self) -> int:

        if self._httpd is None:

            raise RuntimeError("server is not started")

        return int(self._httpd.server_address[1])

    @property

    def url(self) -> str:

        return f"http://{self.host}:{self.server_port}"

    def start(self) -> "GitHTTPServer":

        if self._httpd is not None:

            return self

        httpd = ThreadingHTTPServer((self.host, self.port), _GitHTTPRequestHandler)

        httpd.owner = self  # type: ignore[attr-defined]

        httpd.daemon_threads = True

        self._httpd = httpd

        self._thread = threading.Thread(

            target=httpd.serve_forever,

            name="oakbench-gitserver",

            daemon=True,

        )

        self._thread.start()

        return self

    def stop(self) -> None:

        if self._httpd is None:

            return

        self._httpd.shutdown()

        self._httpd.server_close()

        if self._thread is not None:

            self._thread.join(timeout=5.0)

        self._httpd = None

        self._thread = None

    def __enter__(self) -> "GitHTTPServer":

        return self.start()

    def __exit__(self, exc_type, exc, tb) -> None:  # type: ignore[no-untyped-def]

        self.stop()