#!/usr/bin/env python3
"""
Kiwi Browser API Server — läuft im Debian-Docker-Container.
Headless Chromium wrapper mit HTTP-Endpunkten für Web-Scraping.

Start im Container:
    cd /app && python3 kiwi-browser-server.py

API:
    GET  /health              → Status
    POST /visit               → Seite besuchen + Text extrahieren
    POST /screenshot          → Screenshot als Base64
"""

import subprocess, json, base64, os, tempfile, re
from http.server import HTTPServer, BaseHTTPRequestHandler

BROWSER = os.environ.get("CHROME_BIN", "/usr/bin/chromium")

def safe_json_response(data):
    return json.dumps(data, ensure_ascii=False).encode()

class Handler(BaseHTTPRequestHandler):
    def log_message(self, format, *args):
        pass

    def do_GET(self):
        if self.path == '/health':
            self.send_response(200)
            self.send_header('Content-type', 'application/json')
            self.end_headers()
            self.wfile.write(safe_json_response({
                "status": "ok",
                "browser": BROWSER,
                "version": self._chrome_version()
            }))
        else:
            self.send_response(404)
            self.end_headers()

    def do_POST(self):
        content_length = int(self.headers.get('Content-Length', 0))
        body = self.rfile.read(content_length) if content_length else b'{}'
        try:
            data = json.loads(body.decode())
        except:
            data = {}

        if self.path == '/visit':
            self.handle_visit(data)
        elif self.path == '/screenshot':
            self.handle_screenshot(data)
        else:
            self.send_response(404)
            self.end_headers()

    def _chrome_version(self):
        try:
            r = subprocess.run([BROWSER, "--version"], capture_output=True, text=True, timeout=5)
            return r.stdout.strip()
        except:
            return "unknown"

    def handle_visit(self, data):
        url = data.get('url', 'https://example.com')
        selector = data.get('selector', None)
        wait = data.get('wait', 'networkidle')

        cmd = [
            BROWSER, '--headless', '--no-sandbox', '--disable-gpu',
            '--disable-dev-shm-usage', '--disable-background-networking',
            '--window-size=1920,1080', '--timeout=20000',
            '--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
            '--dump-dom', url
        ]

        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
            html = result.stdout[:15000]

            extracted = None
            if selector:
                patterns = [
                    rf'class="[^"]*{re.escape(selector)}[^"]*"[^>]*>([^<]+)',
                    rf'id="{re.escape(selector)}"[^>]*>([^<]+)',
                    rf'<[^>]*class="[^"]*price[^"]*"[^>]*>([^<]+)',
                ]
                for pat in patterns:
                    m = re.search(pat, html, re.I | re.DOTALL)
                    if m:
                        extracted = re.sub(r'<[^>]+>', '', m.group(1)).strip()
                        break

            self.json_response({
                "success": result.returncode == 0,
                "url": url,
                "title": self._extract_title(html),
                "html_preview": html[:3000],
                "extracted": extracted,
                "error": result.stderr[:500] if result.returncode != 0 else None
            })
        except Exception as e:
            self.json_response({"success": False, "error": str(e)}, 500)

    def _extract_title(self, html):
        m = re.search(r'<title>(.*?)</title>', html, re.I | re.DOTALL)
        return re.sub(r'\s+', ' ', m.group(1)).strip() if m else None

    def handle_screenshot(self, data):
        url = data.get('url', 'https://example.com')
        full_page = data.get('full_page', False)

        with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as f:
            out_path = f.name

        cmd = [
            BROWSER, '--headless', '--no-sandbox', '--disable-gpu',
            '--disable-dev-shm-usage', '--window-size=1920,1080',
            f'--screenshot={out_path}', url
        ]
        if full_page:
            cmd.append('--hide-scrollbars')

        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)

            if os.path.exists(out_path) and os.path.getsize(out_path) > 0:
                with open(out_path, 'rb') as f:
                    img = base64.b64encode(f.read()).decode()
                os.unlink(out_path)
                self.json_response({"success": True, "screenshot_base64": img, "url": url})
            else:
                self.json_response({"success": False, "error": "no screenshot", "stderr": result.stderr[:200]}, 500)
        except Exception as e:
            self.json_response({"success": False, "error": str(e)}, 500)

    def json_response(self, data, status=200):
        self.send_response(status)
        self.send_header('Content-type', 'application/json')
        self.send_header('Access-Control-Allow-Origin', '*')
        self.end_headers()
        self.wfile.write(safe_json_response(data))

if __name__ == '__main__':
    import sys
    host = os.environ.get('HOST', '0.0.0.0')
    port = int(os.environ.get('PORT', 3000))
    server = HTTPServer((host, port), Handler)
    print(f"Kiwi Browser API running on http://{host}:{port}", flush=True)
    server.serve_forever()