"""Small, isolated SVG -> Illustrator 5 (PostScript) converter.

The WordCloud renderer emits paths, solid fills, strokes and affine transforms.
This service intentionally supports that deterministic subset and rejects SVG
features that would otherwise produce a silently corrupted AI document.
"""

from __future__ import annotations

import json
import math
import re
from datetime import datetime, timezone
from http import HTTPStatus
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from typing import Iterable
from xml.etree import ElementTree as ET

MAX_SVG_BYTES = 25 * 1024 * 1024
SVG_NS = "{http://www.w3.org/2000/svg}"
NUMBER = r"[-+]?(?:\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?"
PATH_TOKENS = re.compile(rf"[AaCcHhLlMmQqSsTtVvZz]|{NUMBER}")
TRANSFORM = re.compile(rf"([A-Za-z]+)\s*\(([^)]*)\)")


def convert_svg(raw: bytes) -> bytes:
    if not raw:
        raise RequestError(HTTPStatus.BAD_REQUEST, "SVG 内容不能为空")
    if len(raw) > MAX_SVG_BYTES:
        raise RequestError(HTTPStatus.REQUEST_ENTITY_TOO_LARGE, "SVG 文件超过 25 MB 限制")
    if b"<!DOCTYPE" in raw.upper() or b"<!ENTITY" in raw.upper():
        raise RequestError(HTTPStatus.BAD_REQUEST, "不支持包含 DTD 或实体的 SVG")

    try:
        root = ET.fromstring(raw)
        ai = svg_to_ai(root)
    except UnsupportedSvg as exc:
        raise RequestError(HTTPStatus.UNPROCESSABLE_ENTITY, str(exc)) from exc
    except (ET.ParseError, ValueError) as exc:
        raise RequestError(HTTPStatus.BAD_REQUEST, f"SVG 解析失败: {exc}") from exc
    return ai.encode("ascii")


class RequestError(ValueError):
    def __init__(self, status: HTTPStatus, detail: str):
        self.status = status
        self.detail = detail
        super().__init__(detail)


class ConverterHandler(BaseHTTPRequestHandler):
    server_version = "WordCloudAIConverter/0.1"

    def do_GET(self) -> None:
        if self.path == "/health":
            self.send_bytes(HTTPStatus.OK, b'{"status":"ok"}', "application/json")
            return
        self.send_error(HTTPStatus.NOT_FOUND)

    def do_POST(self) -> None:
        if self.path != "/convert":
            self.send_error(HTTPStatus.NOT_FOUND)
            return
        try:
            length = int(self.headers.get("Content-Length", ""))
            if length < 0:
                raise ValueError
        except ValueError:
            self.send_json_error(HTTPStatus.BAD_REQUEST, "缺少或无效 Content-Length")
            return
        if length > MAX_SVG_BYTES:
            self.send_json_error(HTTPStatus.REQUEST_ENTITY_TOO_LARGE, "SVG 文件超过 25 MB 限制")
            return
        raw = self.rfile.read(length)
        try:
            ai = convert_svg(raw)
        except RequestError as exc:
            self.send_json_error(exc.status, exc.detail)
            return
        self.send_bytes(
            HTTPStatus.OK,
            ai,
            "application/postscript",
            {"Content-Disposition": 'attachment; filename="wordcloud.ai"'},
        )

    def send_json_error(self, status: HTTPStatus, detail: str) -> None:
        body = json.dumps({"detail": detail}, ensure_ascii=False).encode("utf-8")
        self.send_bytes(status, body, "application/json; charset=utf-8")

    def send_bytes(self, status: HTTPStatus, body: bytes, content_type: str, headers: dict[str, str] | None = None) -> None:
        self.send_response(status)
        self.send_header("Content-Type", content_type)
        self.send_header("Content-Length", str(len(body)))
        for key, value in (headers or {}).items():
            self.send_header(key, value)
        self.end_headers()
        self.wfile.write(body)

    def log_message(self, _format: str, *_args: object) -> None:
        # The reverse proxy already logs requests; avoid echoing SVG payloads.
        return
class UnsupportedSvg(ValueError):
    pass


def svg_to_ai(root: ET.Element) -> str:
    if local_name(root.tag) != "svg":
        raise UnsupportedSvg("根节点必须是 svg")

    width, height = canvas_size(root)
    now = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S UTC")
    lines = [
        "%!PS-Adobe-3.0",
        "%%Creator: WordCloud AI Converter",
        "%%Title: WordCloud export",
        f"%%CreationDate: {now}",
        f"%%BoundingBox: 0 0 {format_number(width * 0.75)} {format_number(height * 0.75)}",
        "%%DocumentProcessColors: Cyan Magenta Yellow Black",
        "%%DocumentNeededResources: procset Adobe_packedarray 2.0 0",
        "%%DocumentSuppliedResources: procset Adobe_Illustrator 1.0 0",
        "%%AI5_FileFormat 3",
        "%%EndComments",
        "%%BeginProlog",
        "%%EndProlog",
        "%%BeginSetup",
        "%%EndSetup",
        "%%Page: 1 1",
        "q",
        # SVG uses 96 px/in and a top-left origin; AI/PostScript uses points and
        # a bottom-left origin.  This CTM preserves physical dimensions.
        f"[0.75 0 0 -0.75 0 {format_number(height * 0.75)}] concat",
    ]
    emit_children(root, lines, Style())
    lines.extend(["Q", "showpage", "%%Trailer", "%%EOF", ""])
    return "\n".join(lines)


def emit_children(parent: ET.Element, lines: list[str], inherited: "Style") -> None:
    for element in parent:
        tag = local_name(element.tag)
        if tag in {"title", "desc", "metadata", "defs", "clipPath", "mask"}:
            if tag in {"clipPath", "mask"}:
                raise UnsupportedSvg(f"暂不支持 SVG {tag}，请先将其转为路径")
            continue
        if tag in {"g", "svg"}:
            lines.append("q")
            transform = element.get("transform")
            if transform:
                lines.extend(postscript_transform(transform))
            emit_children(element, lines, inherited.merged(element))
            lines.append("Q")
            continue
        if tag == "path":
            emit_path(element, lines, inherited)
            continue
        if tag == "rect":
            emit_rect(element, lines, inherited)
            continue
        if tag == "circle":
            emit_circle(element, lines, inherited)
            continue
        if tag == "ellipse":
            emit_ellipse(element, lines, inherited)
            continue
        if tag == "line":
            emit_line(element, lines, inherited)
            continue
        if tag in {"image", "text", "use", "polygon", "polyline"}:
            raise UnsupportedSvg(f"暂不支持 SVG {tag}；词云导出仅支持路径、基础形状和描边")
        raise UnsupportedSvg(f"不支持的 SVG 节点: {tag}")


class Style:
    def __init__(self, *, fill: str = "#000000", stroke: str = "none", stroke_width: float = 1, opacity: float = 1):
        self.fill = fill
        self.stroke = stroke
        self.stroke_width = stroke_width
        self.opacity = opacity

    def merged(self, element: ET.Element) -> "Style":
        values: dict[str, str] = {}
        if element.get("style"):
            for declaration in element.get("style", "").split(";"):
                key, separator, value = declaration.partition(":")
                if separator:
                    values[key.strip()] = value.strip()
        for key in ("fill", "stroke", "stroke-width", "opacity", "fill-opacity", "stroke-opacity"):
            if element.get(key) is not None:
                values[key] = element.get(key, "")
        opacity = float(values.get("opacity", self.opacity))
        if float(values.get("fill-opacity", "1")) != 1 or float(values.get("stroke-opacity", "1")) != 1 or opacity != 1:
            raise UnsupportedSvg("AI5 导出暂不支持透明度；请先展平透明效果")
        return Style(
            fill=values.get("fill", self.fill),
            stroke=values.get("stroke", self.stroke),
            stroke_width=parse_number(values.get("stroke-width", str(self.stroke_width))),
            opacity=opacity,
        )


def emit_path(element: ET.Element, lines: list[str], inherited: Style) -> None:
    path = element.get("d")
    if not path:
        return
    emit_geometry(element, lines, inherited, path_to_postscript(path))


def emit_rect(element: ET.Element, lines: list[str], inherited: Style) -> None:
    if element.get("rx") or element.get("ry"):
        raise UnsupportedSvg("暂不支持圆角矩形")
    x = parse_number(element.get("x", "0"))
    y = parse_number(element.get("y", "0"))
    width = positive_number(element.get("width"), "rect width")
    height = positive_number(element.get("height"), "rect height")
    geometry = [
        f"{n(x)} {n(y)} m",
        f"{n(x + width)} {n(y)} l",
        f"{n(x + width)} {n(y + height)} l",
        f"{n(x)} {n(y + height)} l",
        "h",
    ]
    emit_geometry(element, lines, inherited, geometry)


def emit_circle(element: ET.Element, lines: list[str], inherited: Style) -> None:
    cx = parse_number(element.get("cx", "0"))
    cy = parse_number(element.get("cy", "0"))
    radius = positive_number(element.get("r"), "circle r")
    emit_geometry(element, lines, inherited, ellipse_path(cx, cy, radius, radius))


def emit_ellipse(element: ET.Element, lines: list[str], inherited: Style) -> None:
    cx = parse_number(element.get("cx", "0"))
    cy = parse_number(element.get("cy", "0"))
    rx = positive_number(element.get("rx"), "ellipse rx")
    ry = positive_number(element.get("ry"), "ellipse ry")
    emit_geometry(element, lines, inherited, ellipse_path(cx, cy, rx, ry))


def emit_line(element: ET.Element, lines: list[str], inherited: Style) -> None:
    x1 = parse_number(element.get("x1", "0"))
    y1 = parse_number(element.get("y1", "0"))
    x2 = parse_number(element.get("x2", "0"))
    y2 = parse_number(element.get("y2", "0"))
    emit_geometry(element, lines, inherited, [f"{n(x1)} {n(y1)} m", f"{n(x2)} {n(y2)} l"], force_stroke=True)


def emit_geometry(element: ET.Element, lines: list[str], inherited: Style, geometry: Iterable[str], force_stroke: bool = False) -> None:
    style = inherited.merged(element)
    path_commands = list(geometry)
    lines.append("q")
    if element.get("transform"):
        lines.extend(postscript_transform(element.get("transform", "")))
    draw_fill = style.fill.lower() != "none" and not force_stroke
    draw_stroke = style.stroke.lower() != "none" or force_stroke
    if draw_fill:
        lines.extend(path_commands)
        lines.extend(color_command(style.fill))
    if draw_fill:
        lines.append("f")
    if draw_stroke:
        # PostScript's combined fill-and-stroke operator uses one color for
        # both operations.  Replay the path after the fill so distinct SVG
        # fill and stroke colors remain distinct in Illustrator.
        lines.extend(path_commands)
        lines.append(f"{n(style.stroke_width)} w")
        lines.extend(color_command(style.stroke if style.stroke.lower() != "none" else "#000000"))
        lines.append("S")
    lines.append("Q")


def path_to_postscript(data: str) -> list[str]:
    tokens = PATH_TOKENS.findall(data.replace(",", " "))
    if not tokens:
        raise UnsupportedSvg("path 缺少可识别的路径数据")
    index = 0
    command: str | None = None
    x = y = start_x = start_y = 0.0
    previous_control: tuple[float, float] | None = None
    output: list[str] = []

    def take(count: int) -> list[float]:
        nonlocal index
        if index + count > len(tokens) or any(is_command(token) for token in tokens[index:index + count]):
            raise UnsupportedSvg("path 参数不完整")
        result = [float(token) for token in tokens[index:index + count]]
        index += count
        return result

    while index < len(tokens):
        if is_command(tokens[index]):
            command = tokens[index]
            index += 1
        elif command is None:
            raise UnsupportedSvg("path 缺少命令")
        assert command is not None
        relative = command.islower()
        op = command.upper()
        if op == "Z":
            output.append("h")
            x, y = start_x, start_y
            previous_control = None
            command = None
            continue
        if op == "M":
            values = take(2)
            x, y = coordinate(values[0], values[1], x, y, relative)
            start_x, start_y = x, y
            output.append(f"{n(x)} {n(y)} m")
            command = "l" if relative else "L"
            previous_control = None
            continue
        if op == "L":
            values = take(2)
            x, y = coordinate(values[0], values[1], x, y, relative)
            output.append(f"{n(x)} {n(y)} l")
            previous_control = None
            continue
        if op == "H":
            value = take(1)[0]
            x = x + value if relative else value
            output.append(f"{n(x)} {n(y)} l")
            previous_control = None
            continue
        if op == "V":
            value = take(1)[0]
            y = y + value if relative else value
            output.append(f"{n(x)} {n(y)} l")
            previous_control = None
            continue
        if op in {"C", "S"}:
            values = take(6 if op == "C" else 4)
            if op == "C":
                c1x, c1y = coordinate(values[0], values[1], x, y, relative)
                c2x, c2y = coordinate(values[2], values[3], x, y, relative)
                nx, ny = coordinate(values[4], values[5], x, y, relative)
            else:
                c1x, c1y = (2 * x - previous_control[0], 2 * y - previous_control[1]) if previous_control else (x, y)
                c2x, c2y = coordinate(values[0], values[1], x, y, relative)
                nx, ny = coordinate(values[2], values[3], x, y, relative)
            output.append(f"{n(c1x)} {n(c1y)} {n(c2x)} {n(c2y)} {n(nx)} {n(ny)} c")
            x, y, previous_control = nx, ny, (c2x, c2y)
            continue
        if op in {"Q", "T"}:
            values = take(4 if op == "Q" else 2)
            if op == "Q":
                qx, qy = coordinate(values[0], values[1], x, y, relative)
                nx, ny = coordinate(values[2], values[3], x, y, relative)
            else:
                qx, qy = (2 * x - previous_control[0], 2 * y - previous_control[1]) if previous_control else (x, y)
                nx, ny = coordinate(values[0], values[1], x, y, relative)
            c1x, c1y = x + (2 / 3) * (qx - x), y + (2 / 3) * (qy - y)
            c2x, c2y = nx + (2 / 3) * (qx - nx), ny + (2 / 3) * (qy - ny)
            output.append(f"{n(c1x)} {n(c1y)} {n(c2x)} {n(c2y)} {n(nx)} {n(ny)} c")
            x, y, previous_control = nx, ny, (qx, qy)
            continue
        if op == "A":
            raise UnsupportedSvg("暂不支持椭圆弧路径；请先转换为贝塞尔路径")
        raise UnsupportedSvg(f"不支持的 path 命令: {command}")
    return output


def postscript_transform(value: str) -> list[str]:
    commands: list[str] = []
    consumed = "".join(match.group(0) for match in TRANSFORM.finditer(value))
    if consumed.replace(" ", "") != value.replace(" ", ""):
        raise UnsupportedSvg(f"无法解析 transform: {value}")
    for match in TRANSFORM.finditer(value):
        name = match.group(1)
        values = [float(token) for token in re.findall(NUMBER, match.group(2))]
        if name == "translate" and len(values) in {1, 2}:
            commands.append(f"[1 0 0 1 {n(values[0])} {n(values[1] if len(values) == 2 else 0)}] concat")
        elif name == "scale" and len(values) in {1, 2}:
            commands.append(f"[{n(values[0])} 0 0 {n(values[1] if len(values) == 2 else values[0])} 0 0] concat")
        elif name == "matrix" and len(values) == 6:
            commands.append("[{}] concat".format(" ".join(n(number) for number in values)))
        elif name == "rotate" and len(values) in {1, 3}:
            angle = values[0]
            if len(values) == 3:
                commands.append(f"[1 0 0 1 {n(values[1])} {n(values[2])}] concat")
            commands.append(f"{n(angle)} rotate")
            if len(values) == 3:
                commands.append(f"[1 0 0 1 {n(-values[1])} {n(-values[2])}] concat")
        else:
            raise UnsupportedSvg(f"不支持的 transform: {name}")
    return commands


def ellipse_path(cx: float, cy: float, rx: float, ry: float) -> list[str]:
    kappa = 0.5522847498307936
    return [
        f"{n(cx + rx)} {n(cy)} m",
        f"{n(cx + rx)} {n(cy + kappa * ry)} {n(cx + kappa * rx)} {n(cy + ry)} {n(cx)} {n(cy + ry)} c",
        f"{n(cx - kappa * rx)} {n(cy + ry)} {n(cx - rx)} {n(cy + kappa * ry)} {n(cx - rx)} {n(cy)} c",
        f"{n(cx - rx)} {n(cy - kappa * ry)} {n(cx - kappa * rx)} {n(cy - ry)} {n(cx)} {n(cy - ry)} c",
        f"{n(cx + kappa * rx)} {n(cy - ry)} {n(cx + rx)} {n(cy - kappa * ry)} {n(cx + rx)} {n(cy)} c",
        "h",
    ]


def color_command(value: str) -> list[str]:
    text = value.strip()
    match = re.fullmatch(r"#([0-9a-fA-F]{6})", text)
    if not match:
        raise UnsupportedSvg(f"仅支持 #RRGGBB 颜色，收到: {value}")
    rgb = match.group(1)
    return [f"{n(int(rgb[0:2], 16) / 255)} {n(int(rgb[2:4], 16) / 255)} {n(int(rgb[4:6], 16) / 255)} setrgbcolor"]


def canvas_size(root: ET.Element) -> tuple[float, float]:
    view_box = root.get("viewBox") or root.get("viewbox")
    if view_box:
        values = [float(token) for token in re.findall(NUMBER, view_box)]
        if len(values) == 4 and values[2] > 0 and values[3] > 0:
            if values[0] != 0 or values[1] != 0:
                raise UnsupportedSvg("暂不支持非零 viewBox 起点")
            return values[2], values[3]
    return positive_number(root.get("width"), "svg width"), positive_number(root.get("height"), "svg height")


def coordinate(x: float, y: float, current_x: float, current_y: float, relative: bool) -> tuple[float, float]:
    return (x + current_x, y + current_y) if relative else (x, y)


def local_name(tag: str) -> str:
    return tag.rsplit("}", 1)[-1]


def is_command(value: str) -> bool:
    return len(value) == 1 and value.isalpha()


def parse_number(value: str) -> float:
    match = re.match(NUMBER, value.strip())
    if not match:
        raise ValueError(f"无效数字: {value}")
    return float(match.group(0))


def positive_number(value: str | None, label: str) -> float:
    if value is None:
        raise ValueError(f"缺少 {label}")
    number = parse_number(value)
    if not math.isfinite(number) or number <= 0:
        raise ValueError(f"无效 {label}")
    return number


def format_number(value: float) -> str:
    if not math.isfinite(value):
        raise ValueError("数值必须是有限数")
    return f"{value:.6f}".rstrip("0").rstrip(".") or "0"


def n(value: float) -> str:
    return format_number(value)


if __name__ == "__main__":
    ThreadingHTTPServer(("0.0.0.0", 8090), ConverterHandler).serve_forever()