api_server.py

"""Pure-Python JSON API server for the game catalogue.

Endpoints:
    GET /api/games          — Returns all games as JSON.
    GET /api/games?search=X — Returns games whose title or slug contain X (case-insensitive).

Also serves the output/ directory for static HTML game files.

Usage:
    python api_server.py [--port PORT] [--output-dir DIR]
"""

import argparse
import json
import os
import re
import urllib.parse
from http.server import BaseHTTPRequestHandler, HTTPServer
from pathlib import Path

# Matches filenames produced by process_game: {source}_{slug}.html
_FILENAME_RE = re.compile(r"^(?P<source>crazygames|poki)_(?P<slug>.+)\.html$")


def _build_game_index(output_dir: Path) -> list[dict]:
    """Scan output_dir for .html files and return game metadata list."""
    games: list[dict] = []
    if not output_dir.is_dir():
        return games
    for entry in sorted(output_dir.iterdir()):
        if not entry.is_file() or entry.suffix != ".html":
            continue
        m = _FILENAME_RE.match(entry.name)
        if not m:
            continue
        source = m.group("source")
        slug = m.group("slug")
        title = slug.replace("-", " ").replace("_", " ").title()
        games.append({
            "title": title,
            "slug": slug,
            "source": source,
            "filename": entry.name,
            "size": entry.stat().st_size,
        })
    return games


def _search_games(games: list[dict], query: str) -> list[dict]:
    """Filter games by title or slug containing query (case-insensitive)."""
    q = query.lower()
    return [
        g for g in games
        if q in g["title"].lower() or q in g["slug"].lower()
    ]


class GameAPIHandler(BaseHTTPRequestHandler):
    output_dir: Path
    game_index: list[dict]

    def _send_json(self, data: object, status: int = 200) -> None:
        body = json.dumps(data, ensure_ascii=False, indent=2).encode("utf-8")
        self.send_response(status)
        self.send_header("Content-Type", "application/json; charset=utf-8")
        self.send_header("Content-Length", str(len(body)))
        self.send_header("Access-Control-Allow-Origin", "*")
        self.end_headers()
        self.wfile.write(body)

    def _send_file(self, path: Path, content_type: str = "text/html") -> None:
        try:
            data = path.read_bytes()
        except OSError:
            self._send_json({"error": "File not found"}, 404)
            return
        self.send_response(200)
        self.send_header("Content-Type", f"{content_type}; charset=utf-8")
        self.send_header("Content-Length", str(len(data)))
        self.send_header("Access-Control-Allow-Origin", "*")
        self.end_headers()
        self.wfile.write(data)

    def do_GET(self) -> None:  # noqa: N802
        parsed = urllib.parse.urlparse(self.path)
        path = parsed.path.rstrip("/")
        qs = urllib.parse.parse_qs(parsed.query)

        if path == "/api/games":
            search = qs.get("search", [None])[0]
            if search:
                results = _search_games(self.game_index, search)
            else:
                results = self.game_index
            self._send_json(results)
            return

        # Serve static game files from output_dir
        if path.startswith("/games/"):
            filename = os.path.basename(path)
            file_path = self.output_dir / filename
            # Prevent path traversal
            if file_path.resolve().parent != self.output_dir.resolve():
                self._send_json({"error": "Forbidden"}, 403)
                return
            if file_path.is_file():
                self._send_file(file_path)
                return
            self._send_json({"error": "Not found"}, 404)
            return

        # Root: simple info page
        if path in ("", "/"):
            total = len(self.game_index)
            self._send_json({
                "service": "civil2-game-api",
                "total_games": total,
                "endpoints": {
                    "GET /api/games": "List all games (JSON)",
                    "GET /api/games?search=QUERY": "Search games by title/slug",
                    "GET /games/{filename}": "Serve a game HTML file",
                },
            })
            return

        self._send_json({"error": "Not found"}, 404)

    def log_message(self, fmt: str, *args: object) -> None:
        print(f"  [{self.log_date_time_string()}] {fmt % args}")


def run_server(port: int = 8080, output_dir: str = "output") -> None:
    out_path = Path(output_dir).resolve()
    game_index = _build_game_index(out_path)
    print(f"Indexed {len(game_index)} games from {out_path}")

    # Dynamically bind class attributes so the handler can access them
    GameAPIHandler.output_dir = out_path
    GameAPIHandler.game_index = game_index

    server = HTTPServer(("0.0.0.0", port), GameAPIHandler)
    print(f"API server listening on http://0.0.0.0:{port}")
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        print("\nShutting down.")
        server.server_close()


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Game catalogue JSON API server")
    parser.add_argument("--port", type=int, default=8080, help="Port to listen on (default: 8080)")
    parser.add_argument("--output-dir", default="output", help="Directory with game HTML files (default: output)")
    args = parser.parse_args()
    run_server(port=args.port, output_dir=args.output_dir)