#!/usr/bin/env python3
"""Loopback reverse proxy with streaming responses and private drain control."""
import argparse
import http.client
import http.server
import json
import os
import signal
import socketserver
import threading
from pathlib import Path

HOP = {'connection', 'keep-alive', 'proxy-authenticate', 'proxy-authorization',
       'te', 'trailer', 'transfer-encoding', 'upgrade', 'host', 'content-length'}
MAX_BODY = 32 * 1024 * 1024
# Long prefill (three 256K requests) can legitimately exceed ten minutes.
# Keep this bounded and aligned with the acceptance benchmark client timeout.
UPSTREAM_TIMEOUT = 1800


class Admission:
    def __init__(self):
        self.lock = threading.Lock()
        self.draining = False
        self.active = 0

    def enter(self):
        with self.lock:
            if self.draining:
                return False
            self.active += 1
            return True

    def leave(self):
        with self.lock:
            self.active -= 1

    def control(self, command):
        with self.lock:
            if command == 'drain':
                self.draining = True
            elif command == 'resume':
                self.draining = False
            elif command != 'status':
                return {'error': 'Unknown control command'}
            return {'draining': self.draining, 'active': self.active}


def handler_class(admission, upstream_port):
    class Proxy(http.server.BaseHTTPRequestHandler):
        protocol_version = 'HTTP/1.1'

        def log_message(self, *args):
            pass  # Never log request bodies, credentials or query strings.

        def reject(self, status, message):
            data = json.dumps({'error': {'message': message}}).encode()
            self.send_response(status)
            self.send_header('Content-Type', 'application/json')
            self.send_header('Content-Length', str(len(data)))
            self.send_header('Connection', 'close')
            if status == 503:
                self.send_header('Retry-After', '5')
            self.end_headers()
            if self.command != 'HEAD':
                self.wfile.write(data)
            self.close_connection = True

        def body(self):
            encoding = self.headers.get('Transfer-Encoding', '').lower()
            if encoding:
                if encoding != 'chunked' or self.headers.get('Content-Length'):
                    raise ValueError('Unsupported request framing')
                data = bytearray()
                while True:
                    line = self.rfile.readline(128)
                    if not line.endswith(b'\r\n'):
                        raise ValueError('Invalid chunk')
                    length = int(line.split(b';')[0].strip(), 16)
                    if length < 0 or len(data) + length > MAX_BODY:
                        raise ValueError('Request too large')
                    if length == 0:
                        # Consume bounded trailers, never forward them.
                        for _ in range(100):
                            if self.rfile.readline(8192) == b'\r\n':
                                return bytes(data)
                        raise ValueError('Too many trailers')
                    chunk = self.rfile.read(length)
                    if len(chunk) != length or self.rfile.read(2) != b'\r\n':
                        raise ValueError('Incomplete chunk')
                    data.extend(chunk)
            length = int(self.headers.get('Content-Length', '0'))
            if not 0 <= length <= MAX_BODY:
                raise ValueError('Request too large')
            data = self.rfile.read(length)
            if len(data) != length:
                raise ValueError('Incomplete body')
            return data

        def proxy(self):
            if not self.path.startswith('/') or self.path.startswith('//'):
                return self.reject(400, 'Origin-form request required')
            if not admission.enter():
                return self.reject(503, 'Engine changing profile; retry shortly')
            upstream = None
            started = False
            try:
                self.connection.settimeout(60)
                body = self.body()
                blocked = HOP | {h.strip().lower() for h in self.headers.get('Connection', '').split(',')}
                headers = {k: v for k, v in self.headers.items() if k.lower() not in blocked}
                upstream = http.client.HTTPConnection('127.0.0.1', upstream_port, timeout=UPSTREAM_TIMEOUT)
                upstream.request(self.command, self.path, body=body, headers=headers)
                response = upstream.getresponse()
                self.send_response(response.status, response.reason)
                blocked = HOP | {h.strip().lower() for h in (response.getheader('Connection') or '').split(',')}
                for key, value in response.getheaders():
                    if key.lower() not in blocked:
                        self.send_header(key, value)
                no_body = self.command == 'HEAD' or response.status in (204, 304) or response.status < 200
                if not no_body:
                    self.send_header('Transfer-Encoding', 'chunked')
                self.send_header('Connection', 'close')
                self.end_headers()
                started = True
                self.close_connection = True
                if not no_body:
                    while True:
                        chunk = response.read1(65536)
                        if not chunk:
                            break
                        self.wfile.write(('%x\r\n' % len(chunk)).encode() + chunk + b'\r\n')
                        self.wfile.flush()
                    self.wfile.write(b'0\r\n\r\n')
                    self.wfile.flush()
            except ValueError:
                if not started:
                    self.reject(400, 'Invalid or oversized request body')
            except (OSError, http.client.HTTPException):
                if not started:
                    try:
                        self.reject(502, 'Backend unavailable')
                    except OSError:
                        pass
            finally:
                if upstream:
                    upstream.close()
                admission.leave()

        do_GET = do_POST = do_PUT = do_DELETE = do_PATCH = do_OPTIONS = do_HEAD = proxy
    return Proxy


class UnixControl(socketserver.ThreadingMixIn, socketserver.UnixStreamServer):
    daemon_threads = True


def control_handler(admission):
    class Control(socketserver.StreamRequestHandler):
        def handle(self):
            self.request.settimeout(5)
            try:
                request = json.loads(self.rfile.readline(4096))
                answer = admission.control(request.get('command'))
                self.wfile.write(json.dumps(answer).encode() + b'\n')
            except (ValueError, OSError):
                pass
    return Control


def serve(port, upstream_port, socket_path):
    path = Path(socket_path)
    path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
    if path.parent.stat().st_uid != os.getuid() or path.parent.stat().st_mode & 0o077:
        raise RuntimeError('Control directory must be private and owned by this user')
    # Never unlink a potentially live/foreign socket. systemd ExecStopPost or
    # the controller may remove a verified stale socket after the unit stops.
    admission = Admission()
    control = UnixControl(str(path), control_handler(admission))
    os.chmod(path, 0o600)
    server = http.server.ThreadingHTTPServer(('127.0.0.1', port), handler_class(admission, upstream_port))
    server.daemon_threads = True
    thread = threading.Thread(target=control.serve_forever, daemon=True)
    thread.start()
    def stop(*_):
        threading.Thread(target=server.shutdown, daemon=True).start()
    signal.signal(signal.SIGTERM, stop)
    signal.signal(signal.SIGINT, stop)
    try:
        server.serve_forever()
    finally:
        control.shutdown()
        server.server_close()
        control.server_close()
        path.unlink(missing_ok=True)


if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('--port', required=True, type=int)
    parser.add_argument('--upstream-port', required=True, type=int)
    parser.add_argument('--socket', required=True)
    args = parser.parse_args()
    serve(args.port, args.upstream_port, args.socket)
