#!/usr/bin/env python3
"""Statischer Server mit Passwortschutz fuer die RAM-Sortierhilfe.

Liefert das gebaute Ergebnis aus dist/ aus, gibt aber ohne gueltiges Passwort
nichts heraus - weder HTML noch Skripte. Nutzt ausschliesslich die
Python-Standardbibliothek, damit keine zusaetzliche Abhaengigkeit entsteht.

Das Passwort kommt aus der Umgebungsvariable APP_PASSWORD. Fehlt sie, startet
der Server absichtlich nicht: Ein vergessener Eintrag soll auffallen, statt
stillschweigend eine ungeschuetzte Seite ins Netz zu stellen.
"""

import base64
import hmac
import os
import sys
from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer

SERVE_DIRECTORY = 'dist'
HEALTH_PATH = '/healthz'
REALM = 'RAM-Sortierhilfe'


def read_password():
    """Liest das Passwort aus der Umgebung. Fehlt es, wird der Start abgebrochen."""
    password = os.environ.get('APP_PASSWORD', '')
    if not password:
        sys.stderr.write(
            'FEHLER: Die Umgebungsvariable APP_PASSWORD ist nicht gesetzt.\n'
            'Der Server startet nicht, damit die Seite nicht ungeschuetzt\n'
            'erreichbar wird. Setze das Passwort in den VCH-Einstellungen.\n'
        )
        sys.exit(1)
    return password


def build_handler(password):
    """Erzeugt einen Handler, der das Passwort per HTTP-Basic-Auth prueft."""
    expected = base64.b64encode(f':{password}'.encode('utf-8'))

    class ProtectedHandler(SimpleHTTPRequestHandler):
        def __init__(self, *args, **kwargs):
            super().__init__(*args, directory=SERVE_DIRECTORY, **kwargs)

        def is_authorised(self):
            """Prueft nur das Passwort; der Benutzername darf beliebig sein."""
            header = self.headers.get('Authorization', '')
            if not header.startswith('Basic '):
                return False
            try:
                decoded = base64.b64decode(header[6:].strip(), validate=True)
            except (ValueError, TypeError):
                return False
            _, separator, supplied = decoded.partition(b':')
            if not separator:
                return False
            # Zeitkonstanter Vergleich, damit die Antwortdauer nichts verraet.
            return hmac.compare_digest(
                base64.b64encode(b':' + supplied), expected
            )

        def demand_password(self):
            self.send_response(401)
            self.send_header('WWW-Authenticate', f'Basic realm="{REALM}", charset="UTF-8"')
            self.send_header('Content-Type', 'text/plain; charset=utf-8')
            self.send_header('Content-Length', '0')
            self.end_headers()

        def answer_health(self):
            """Lebenszeichen fuer die Ueberwachung - ohne Passwort, ohne Inhalt."""
            body = b'ok'
            self.send_response(200)
            self.send_header('Content-Type', 'text/plain; charset=utf-8')
            self.send_header('Content-Length', str(len(body)))
            self.end_headers()
            if self.command != 'HEAD':
                self.wfile.write(body)

        def guard(self):
            """True, wenn die Anfrage weiterverarbeitet werden darf."""
            if self.path.split('?', 1)[0] == HEALTH_PATH:
                self.answer_health()
                return False
            if not self.is_authorised():
                self.demand_password()
                return False
            return True

        def do_GET(self):
            if self.guard():
                super().do_GET()

        def do_HEAD(self):
            if self.guard():
                super().do_HEAD()

    return ProtectedHandler


def main():
    password = read_password()
    port = int(os.environ.get('PORT', '8000'))
    server = ThreadingHTTPServer(('0.0.0.0', port), build_handler(password))
    sys.stderr.write(f'RAM-Sortierhilfe laeuft auf Port {port}, Zugang nur mit Passwort.\n')
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        server.server_close()


if __name__ == '__main__':
    main()