from __future__ import annotations

import math
import re
import time
from pathlib import Path
from typing import Any

from .models import Design


def _slug(value: str) -> str:
    return re.sub(r"[^a-z0-9]+", "_", value.lower()).strip("_")[:64] or "design"


def _family(design: Design) -> str:
    feature_types = {feature.type for feature in design.features}
    if "tabletop" in feature_types:
        return "table"
    if "stator_ring" in feature_types:
        return "motor_stator"
    if "seat_panel" in feature_types:
        return "chair"
    if "clamp_jaw" in feature_types:
        return "torque_clamp"
    if "hook_curve" in feature_types:
        return "wall_hook"
    if feature_types & {"generic_panel", "support_tube", "curved_tube", "flat_foot", "armrest", "headrest", "table_leg"}:
        return "freeform_object"
    return "bracket"


def _box(cq: Any, x: float, y: float, z: float, cx: float, cy: float, cz: float):
    return cq.Workplane("XY").box(x, y, z).translate((cx, cy, cz))


def _cylinder_x(cq: Any, radius: float, length: float, cx: float, cy: float, cz: float):
    return cq.Workplane("YZ").circle(radius).extrude(length).translate((cx - length / 2, cy, cz))


def _cylinder_y(cq: Any, radius: float, length: float, cx: float, cy: float, cz: float):
    return cq.Workplane("XZ").circle(radius).extrude(length).translate((cx, cy - length / 2, cz))


def _cylinder_z(cq: Any, radius: float, height: float, cx: float, cy: float, cz: float):
    return cq.Workplane("XY").circle(radius).extrude(height).translate((cx, cy, cz - height / 2))


def _merge(parts: list[Any]):
    body = parts[0]
    for part in parts[1:]:
        body = body.union(part)
    return body


def _box_between_xy(cq: Any, x1: float, y1: float, x2: float, y2: float, width: float, height: float, z: float):
    length = max(math.hypot(x2 - x1, y2 - y1), 1)
    part = _box(cq, length, max(width, 1), max(height, 1), (x1 + x2) / 2, (y1 + y2) / 2, z)
    return part.rotate(((x1 + x2) / 2, (y1 + y2) / 2, z), ((x1 + x2) / 2, (y1 + y2) / 2, z + 1), math.degrees(math.atan2(y2 - y1, x2 - x1)))


def _primitive_part(cq: Any, design: Design, feature: Any, ops: list[dict[str, Any]]):
    if feature.type in {"tabletop", "generic_panel"}:
        depth = max(design.base_width_mm, 18)
        z = 52 if feature.type == "tabletop" else max(feature.height, 4) / 2
        ops.append({"op": "box_extrude", "part": feature.type, "center_xy_mm": [feature.x, feature.y], "size_mm": [max(feature.width, 24), depth, max(feature.height, 4)]})
        return _box(cq, max(feature.width, 24), depth, max(feature.height, 4), feature.x or design.base_length_mm / 2, feature.y, z)
    if feature.type == "table_leg":
        height = max(feature.height, 24)
        radius = max(feature.radius, feature.width / 2, 2.4)
        ops.append({"op": "cylinder_extrude", "part": "table_leg", "center_xy_mm": [feature.x, feature.y], "height_mm": height, "radius_mm": radius})
        return _cylinder_z(cq, radius, height, feature.x, feature.y, height / 2)
    if feature.type == "support_tube":
        z = max(feature.height, 8)
        ops.append({"op": "box_between", "part": "support_tube", "from_xy_mm": [feature.x, feature.y], "to_xy_mm": [feature.x2, feature.y2]})
        return _box_between_xy(cq, feature.x, feature.y, feature.x2, feature.y2, max(feature.width, feature.radius * 2, 3), max(feature.radius * 2, 3), z)
    if feature.type == "curved_tube":
        z = max(feature.height, 18)
        ops.append({"op": "segmented_curve_proxy", "part": "curved_tube", "from_xy_mm": [feature.x, feature.y], "to_xy_mm": [feature.x2, feature.y2]})
        return _box_between_xy(cq, feature.x, feature.y, feature.x2, feature.y2, max(feature.width, feature.radius * 2, 3), max(feature.radius * 2, 3), z)
    if feature.type == "flat_foot":
        ops.append({"op": "box_extrude", "part": "flat_foot", "center_xy_mm": [feature.x, feature.y]})
        return _box(cq, max(feature.width, 16), max(feature.radius * 2.4, 8), max(feature.height, 2.5), feature.x, feature.y, max(feature.height, 2.5) / 2)
    return None


def _build_stator(cq: Any, design: Design, ops: list[dict[str, Any]]):
    ring = next((item for item in design.features if item.type == "stator_ring"), None)
    tooth = next((item for item in design.features if item.type == "stator_tooth"), None)
    cx = ring.x if ring else design.base_length_mm / 2
    cy = ring.y if ring else 0
    outer = ring.radius + ring.width if ring else 46
    inner = max((tooth.radius if tooth else 18), 12)
    height = max(ring.height if ring else design.base_thickness_mm, 4)

    body = cq.Workplane("XY").circle(outer).circle(inner).extrude(height)
    ops.append({"op": "sketch_annulus", "outer_radius_mm": outer, "inner_radius_mm": inner, "height_mm": height})
    tooth_count = 12
    for idx in range(tooth_count):
        angle = 360 * idx / tooth_count
        length = max((tooth.height if tooth else 18), 8)
        width = max((tooth.width if tooth else 8), 3)
        radial = inner + length / 2
        local = cq.Workplane("XY").box(length, width, height).translate((radial, 0, height / 2))
        local = local.rotate((0, 0, 0), (0, 0, 1), angle).translate((cx, cy, 0))
        body = body.union(local)
        ops.append({"op": "union_radial_tooth", "index": idx + 1, "angle_deg": angle, "length_mm": length, "width_mm": width})
    body = body.translate((cx, cy, 0))
    ops.append({"op": "export_ready_body", "family": "motor_stator", "note": "flat annular stator, not a torus placeholder"})
    return body


def _build_chair(cq: Any, design: Design, ops: list[dict[str, Any]]):
    parts = []
    seat_z = 48
    parts.append(_box(cq, design.base_length_mm, design.base_width_mm, design.base_thickness_mm, design.base_length_mm / 2, 0, seat_z))
    ops.append({"op": "box_extrude", "part": "seat_panel", "size_mm": [design.base_length_mm, design.base_width_mm, design.base_thickness_mm]})
    for leg in [item for item in design.features if item.type == "chair_leg"]:
        height = max(leg.height, 35)
        parts.append(_box(cq, max(leg.width, 4), max(leg.width, 4), height, leg.x, leg.y, height / 2))
        ops.append({"op": "extrude_leg", "part": leg.note, "top_xy_mm": [leg.x, leg.y], "height_mm": height})
    parts.append(_box(cq, design.base_length_mm, 5, 42, design.base_length_mm / 2, design.base_width_mm / 2 - 3, seat_z + 22))
    parts.append(_box(cq, 5, 5, 54, 10, design.base_width_mm / 2 - 3, seat_z + 25))
    parts.append(_box(cq, 5, 5, 54, design.base_length_mm - 10, design.base_width_mm / 2 - 3, seat_z + 25))
    ops.append({"op": "add_backrest", "parts": ["back_panel", "left_back_post", "right_back_post"]})
    decorative = [item for item in design.features if item.type == "decorative_curve"]
    if decorative:
        back_y = design.base_width_mm / 2 + 0.5
        cx = design.base_length_mm / 2
        cz = seat_z + 38
        if any("flower" in item.note.lower() or "petal" in item.note.lower() for item in decorative):
            parts.append(_cylinder_y(cq, 3.2, 1.8, cx, back_y, cz))
            for idx in range(6):
                angle = math.tau * idx / 6
                px = cx + math.cos(angle) * 10
                pz = cz + math.sin(angle) * 10
                parts.append(_cylinder_y(cq, 5.5, 1.6, px, back_y, pz))
                ops.append({"op": "union_flower_petal_disc", "index": idx + 1, "center_xz_mm": [round(px, 3), round(pz, 3)]})
            parts.append(_cylinder_y(cq, 1.6, 1.6, cx - 2, back_y, seat_z + 18))
            ops.append({"op": "add_backrest_flower_pattern", "note": "decorative raised petal discs on backrest"})
        else:
            for idx, item in enumerate(decorative, start=1):
                parts.append(_cylinder_y(cq, max(item.radius, 2), 1.4, item.x or cx, back_y, seat_z + 24 + idx * 8))
                ops.append({"op": "union_decorative_curve_proxy", "index": idx, "note": item.note})
    for item in [feature for feature in design.features if feature.type in {"armrest", "headrest", "flat_foot", "support_tube", "curved_tube"}]:
        primitive = _primitive_part(cq, design, item, ops)
        if primitive is not None:
            parts.append(primitive)
    ops.append({"op": "export_ready_body", "family": "chair"})
    return _merge(parts)


def _build_table(cq: Any, design: Design, ops: list[dict[str, Any]]):
    parts = []
    for feature in design.features:
        primitive = _primitive_part(cq, design, feature, ops)
        if primitive is not None:
            parts.append(primitive)
    if not parts:
        parts.append(_box(cq, design.base_length_mm, design.base_width_mm, design.base_thickness_mm, design.base_length_mm / 2, 0, 52))
        ops.append({"op": "box_extrude", "part": "fallback_tabletop"})
    ops.append({"op": "export_ready_body", "family": "table"})
    return _merge(parts)


def _build_freeform(cq: Any, design: Design, ops: list[dict[str, Any]]):
    parts = []
    for feature in design.features:
        primitive = _primitive_part(cq, design, feature, ops)
        if primitive is not None:
            parts.append(primitive)
    if not parts:
        parts.append(_box(cq, design.base_length_mm, design.base_width_mm, design.base_thickness_mm, design.base_length_mm / 2, 0, design.base_thickness_mm / 2))
        ops.append({"op": "box_extrude", "part": "fallback_freeform_panel"})
    ops.append({"op": "export_ready_body", "family": "freeform_object"})
    return _merge(parts)


def _build_clamp(cq: Any, design: Design, ops: list[dict[str, Any]]):
    parts = [
        _box(cq, 16, design.base_width_mm, 28, 8, 0, 14),
        _cylinder_x(cq, 11, 58, 58, 0, 22),
    ]
    ops.append({"op": "box_extrude", "part": "fixed_root", "size_mm": [16, design.base_width_mm, 28]})
    ops.append({"op": "cylinder_extrude", "part": "shaft_bore_proxy", "axis": "x", "radius_mm": 11, "length_mm": 58})
    for y in [-18, 18]:
        parts.append(_box(cq, 54, 10, 15, 53, y, 22))
        ops.append({"op": "box_extrude", "part": "split_clamp_jaw", "center_y_mm": y, "size_mm": [54, 10, 15]})
    parts.append(_cylinder_x(cq, 14, 12, 82, 0, 22))
    ops.append({"op": "add_end_collar", "radius_mm": 14, "note": "visual collar for torque/load application"})
    ops.append({"op": "export_ready_body", "family": "torque_clamp"})
    return _merge(parts)


def _build_hook(cq: Any, design: Design, ops: list[dict[str, Any]]):
    wall_h = max(design.base_width_mm, 50)
    parts = [_box(cq, 8, 26, wall_h, 4, 0, wall_h / 2)]
    ops.append({"op": "box_extrude", "part": "wall_plate", "size_mm": [8, 26, wall_h]})
    tube = 4
    root_z = wall_h * 0.58
    points = [(8, root_z), (32, root_z), (52, root_z - 8), (58, root_z - 28), (44, root_z - 38), (35, root_z - 24)]
    for idx, ((x1, z1), (x2, z2)) in enumerate(zip(points, points[1:]), start=1):
        length = math.hypot(x2 - x1, z2 - z1)
        angle = math.degrees(math.atan2(z2 - z1, x2 - x1))
        segment = _cylinder_x(cq, tube, length, (x1 + x2) / 2, 0, (z1 + z2) / 2)
        segment = segment.rotate(((x1 + x2) / 2, 0, (z1 + z2) / 2), ((x1 + x2) / 2, 1, (z1 + z2) / 2), -angle)
        parts.append(segment)
        ops.append({"op": "sweep_hook_segment", "index": idx, "from_xz_mm": [x1, z1], "to_xz_mm": [x2, z2], "tube_radius_mm": tube})
    ops.append({"op": "export_ready_body", "family": "wall_hook"})
    return _merge(parts)


def _build_bracket(cq: Any, design: Design, ops: list[dict[str, Any]]):
    body = _box(cq, design.base_length_mm, design.base_width_mm, design.base_thickness_mm, design.base_length_mm / 2, 0, design.base_thickness_mm / 2)
    ops.append({"op": "box_extrude", "part": "base_plate", "size_mm": [design.base_length_mm, design.base_width_mm, design.base_thickness_mm]})
    for feature in design.features:
        if feature.type == "rib":
            length = max(math.hypot(feature.x2 - feature.x, feature.y2 - feature.y), 1)
            rib = _box(cq, length, max(feature.width, 1), max(feature.height, 1), (feature.x + feature.x2) / 2, (feature.y + feature.y2) / 2, design.base_thickness_mm + max(feature.height, 1) / 2)
            rib = rib.rotate((feature.x, feature.y, design.base_thickness_mm), (feature.x, feature.y, design.base_thickness_mm + 1), math.degrees(math.atan2(feature.y2 - feature.y, feature.x2 - feature.x)))
            body = body.union(rib)
            ops.append({"op": "union_rib", "from_xy_mm": [feature.x, feature.y], "to_xy_mm": [feature.x2, feature.y2]})
        if feature.type == "boss":
            body = body.union(_cylinder_z(cq, max(feature.radius, 1), max(feature.height, 1), feature.x, feature.y, design.base_thickness_mm + max(feature.height, 1) / 2))
            ops.append({"op": "union_boss", "center_xy_mm": [feature.x, feature.y], "radius_mm": feature.radius})
    ops.append({"op": "export_ready_body", "family": "bracket"})
    return body


def build_cadquery_artifact(design: Design, output_root: str | Path = "runs") -> dict[str, Any]:
    """Build an actual CadQuery body and export manufacturable artifacts."""

    operations: list[dict[str, Any]] = []
    family = _family(design)
    output_dir = Path(output_root) / f"{int(time.time() * 1000)}_{_slug(design.title)}"
    output_dir.mkdir(parents=True, exist_ok=True)

    try:
        import cadquery as cq

        builders = {
            "motor_stator": _build_stator,
            "chair": _build_chair,
            "table": _build_table,
            "freeform_object": _build_freeform,
            "torque_clamp": _build_clamp,
            "wall_hook": _build_hook,
            "bracket": _build_bracket,
        }
        body = builders[family](cq, design, operations)
        step_path = output_dir / "design.step"
        stl_path = output_dir / "design.stl"
        cq.exporters.export(body, str(step_path))
        cq.exporters.export(body, str(stl_path))
        return {
            "valid": True,
            "family": family,
            "engine": "cadquery",
            "operations": operations,
            "step_path": str(step_path),
            "stl_path": str(stl_path),
        }
    except Exception as exc:  # pragma: no cover - keeps agent loop alive if CAD kernel fails.
        operations.append({"op": "cadquery_error", "error": str(exc)})
        return {
            "valid": False,
            "family": family,
            "engine": "cadquery",
            "operations": operations,
            "error": str(exc),
        }