"""OCC-based 3D renderer — displays BRep shapes directly on the GPU.

Uses OCC's ``AIS_Shape`` and ``V3d_Viewer`` so that curved surfaces (cylinders,
spheres, etc.) render smoothly without manual triangulation, and edges/faces are
natively selectable.
"""

import logging
import uuid
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional, Tuple

import numpy as np

from .base import Renderer, RenderObject, RenderColor

logger = logging.getLogger(__name__)


@dataclass
class OCCRenderObject(RenderObject):
    """Internal object state for the OCC renderer."""

    obj_id: str = ""
    ais_shape: Any = None  # AIS_Shape
    ais_type: str = "shape"  # "shape" | "wireframe" | "points"
    color: RenderColor = field(default_factory=lambda: RenderColor(0.5, 0.5, 0.5))


class OCCRenderer(Renderer):
    """Renderer that uses OCC's native AIS display for smooth BRep rendering."""

    def __init__(self) -> None:
        super().__init__()
        self._viewer: Any = None
        self._view: Any = None
        self._context: Any = None
        self._window: Any = None
        self._initialized: bool = False
        self._objects: Dict[str, OCCRenderObject] = {}
        self._parent_widget: Any = None
        self._last_mouse_x: int = 0
        self._last_mouse_y: int = 0

    def initialize(self, parent_widget: Any) -> bool:
        """Initialise OCC viewer inside *parent_widget* (a QWidget)."""
        self._parent_widget = parent_widget

        import os as _os
        if _os.environ.get("QT_QPA_PLATFORM") == "offscreen":
            logger.warning("OCCRenderer skipped (QT_QPA_PLATFORM=offscreen)")
            return False

        logger.info("OCCRenderer imports starting...")
        from OCP.Aspect import (
            Aspect_DisplayConnection,
            Aspect_NeutralWindow,
            Aspect_GFM_VER,
        )
        from OCP.OpenGl import OpenGl_GraphicDriver
        from OCP.V3d import V3d_Viewer, V3d_View, V3d_TypeOfView
        from OCP.AIS import AIS_InteractiveContext
        from OCP.Quantity import Quantity_Color, Quantity_TOC_RGB
        logger.info("OCCRenderer imports complete")

        hwnd = int(parent_widget.winId())
        if hwnd <= 1:
            logger.warning("OCCRenderer skipped (no native window handle)")
            return False

        logger.info("OCCRenderer creating objects...")

        try:
            display = Aspect_DisplayConnection()
            driver = OpenGl_GraphicDriver(display)
            viewer = V3d_Viewer(driver)
            viewer.SetDefaultLights()
            viewer.SetLightOn()

            view = V3d_View(viewer, V3d_TypeOfView.V3d_ORTHOGRAPHIC)
            viewer.SetDefaultBgGradientColors(
                Quantity_Color(0.15, 0.15, 0.2, Quantity_TOC_RGB),
                Quantity_Color(0.25, 0.25, 0.3, Quantity_TOC_RGB),
                Aspect_GFM_VER,
            )

            context = AIS_InteractiveContext(viewer)

            # Attach OCC view to the Qt widget via the native window handle.
            win = Aspect_NeutralWindow()
            win.SetNativeHandle(hwnd)
            w, h = parent_widget.width(), parent_widget.height()
            win.SetSize(w, h)
            view.SetWindow(win)

            self._viewer = viewer
            self._view = view
            self._context = context
            self._window = win
            self._initialized = True

            logger.info("OCCRenderer initialised (native OCC display)")
            return True

        except Exception as exc:
            logger.error(f"OCCRenderer initialisation failed: {exc}")
            self._initialized = False
            return False

    def shutdown(self) -> None:
        """Clean up OCC viewer resources."""
        self.clear_scene()
        if self._view is not None:
            self._view.Remove()
            self._view = None
        if self._viewer is not None:
            self._viewer.Remove()
            self._viewer = None
        self._initialized = False

    # ─── BRep shape display (primary entry point) ───────────────────────

    def add_shape(
        self,
        shape: Any,
        color: Optional[Tuple[float, float, float]] = None,
        name: Optional[str] = None,
    ) -> str:
        """Display an OCC ``TopoDS_Shape`` directly via ``AIS_Shape``.

        Returns a unique object ID (or *name* if provided).
        """
        from OCP.AIS import AIS_Shape
        from OCP.Quantity import Quantity_Color, Quantity_TOC_RGB
        from OCP.Prs3d import Prs3d_Drawer

        obj_id = name or f"shape_{uuid.uuid4().hex[:8]}"

        ais = AIS_Shape(shape)

        if color is not None:
            qcol = Quantity_Color(*color, Quantity_TOC_RGB)
            ais.SetColor(qcol)

        # Enable selection of edges and faces.
        ais.SetDisplayMode(1)  # 0 = wireframe, 1 = shaded
        ais.SetMaterial(
            self._default_material()
        )  # use a helper to get the default material

        self._context.Display(ais, True)
        self._context.Deactivate(ais)

        defcol = color or (0.5, 0.5, 0.5)
        robj = OCCRenderObject(
            obj_id=obj_id,
            ais_shape=ais,
            ais_type="shape",
            color=RenderColor(*defcol),
        )
        self._objects[obj_id] = robj

        # Fit camera on first shape added.
        if len(self._objects) == 1:
            try:
                self.fit_camera()
            except Exception:
                logger.warning("fit_camera failed on first shape", exc_info=True)

        return obj_id

    def _default_material(self):
        """Return a default Graphic3d_MaterialAspect for shading."""
        from OCP.Graphic3d import Graphic3d_MaterialAspect, Graphic3d_NameOfMaterial

        return Graphic3d_MaterialAspect(
            Graphic3d_NameOfMaterial.Graphic3d_NOM_PLASTIC
        )

    # ─── Legacy mesh / wireframe (kept for backward compat) ────────────

    def add_mesh(
        self,
        vertices: np.ndarray,
        faces: np.ndarray,
        color: Tuple[float, float, float] = (0.2, 0.4, 0.8),
        name: Optional[str] = None,
    ) -> str:
        """Add triangulated mesh by converting it to an OCC polygonal shape.

        Prefer :meth:`add_shape` for native BRep display — it avoids meshing
        artifacts on curved surfaces.
        """
        from OCP.Poly import Poly_Triangulation, Poly_Triangle
        from OCP.TopoDS import TopoDS_Face
        from OCP.BRep import BRep_Builder
        from OCP.gp import gp_Pnt

        n_verts = len(vertices)
        n_tris = len(faces)

        # Build triangulation via (nbNodes, nbTriangles, hasUVNodes) constructor
        tri = Poly_Triangulation(n_verts, n_tris, False)

        for i, (x, y, z) in enumerate(vertices):
            tri.SetNode(i + 1, gp_Pnt(float(x), float(y), float(z)))

        for i, (a, b, cc) in enumerate(faces):
            tri.SetTriangle(i + 1, Poly_Triangle(int(a) + 1, int(b) + 1, int(cc) + 1))

        builder = BRep_Builder()
        shape = TopoDS_Face()
        builder.MakeFace(shape, tri)
        return self.add_shape(shape, color, name)

    def add_wireframe(
        self,
        vertices: np.ndarray,
        edges: np.ndarray,
        color: Tuple[float, float, float] = (1.0, 1.0, 1.0),
        line_width: float = 1.0,
        name: Optional[str] = None,
    ) -> str:
        """Add a wireframe from edge data (legacy, kept for compatibility).

        For new code prefer :meth:`add_shape` — OCC's AIS displays the
        shape boundary automatically.
        """
        obj_id = name or f"wf_{uuid.uuid4().hex[:8]}"
        logger.debug(f"add_wireframe {obj_id} — ignored (AIS draws edges natively)")
        # Wireframes are already provided by the AIS shaded display, so we
        # skip explicit line geometry unless there is a specific need.
        return obj_id

    def add_points(
        self,
        points: np.ndarray,
        color: Tuple[float, float, float] = (1.0, 0.0, 0.0),
        size: float = 5.0,
        name: Optional[str] = None,
    ) -> str:
        """Add point cloud (not yet implemented with OCC renderer)."""
        obj_id = name or f"pts_{uuid.uuid4().hex[:8]}"
        logger.debug(f"add_points {obj_id} — not implemented in OCCRenderer")
        return obj_id

    def add_lines(
        self,
        start_points: np.ndarray,
        end_points: np.ndarray,
        color: Tuple[float, float, float] = (1.0, 1.0, 1.0),
        line_width: float = 1.0,
        name: Optional[str] = None,
    ) -> str:
        """Add line segments (not yet implemented with OCC renderer)."""
        obj_id = name or f"ln_{uuid.uuid4().hex[:8]}"
        logger.debug(f"add_lines {obj_id} — not implemented in OCCRenderer")
        return obj_id

    # ─── Object management ─────────────────────────────────────────────

    def remove_object(self, obj: OCCRenderObject) -> bool:
        """Remove an object from the scene."""
        if obj.ais_shape is not None:
            self._context.Remove(obj.ais_shape, True)
        if obj.obj_id in self._objects:
            del self._objects[obj.obj_id]
            return True
        return False

    def remove_mesh(self, obj_id: str) -> None:
        """Remove an object by ID (legacy compatibility)."""
        obj = self._objects.get(obj_id)
        if obj is not None:
            self.remove_object(obj)

    def clear_scene(self) -> None:
        """Remove all objects from the scene."""
        if self._context is None:
            return
        # Remove all displayed AIS objects.
        from OCP.AIS import AIS_KindOfInteractive

        objs = self._context.DisplayedObjects()
        for ais in objs:
            self._context.Remove(ais, True)
        self._objects.clear()

    def update_mesh(
        self,
        obj: OCCRenderObject,
        vertices: np.ndarray,
        faces: np.ndarray,
    ) -> bool:
        """Update mesh geometry (not supported for OCC shapes; re-add instead)."""
        logger.warning("update_mesh not supported for OCC shapes — remove + re-add")
        return False

    # ─── Display properties ────────────────────────────────────────────

    def set_object_color(
        self,
        obj: OCCRenderObject,
        color: Tuple[float, float, float],
    ) -> None:
        """Set the colour of an object."""
        from OCP.Quantity import Quantity_Color, Quantity_TOC_RGB

        if obj.ais_shape is not None:
            qcol = Quantity_Color(*color, Quantity_TOC_RGB)
            obj.ais_shape.SetColor(qcol)
            self._context.RecomputePrsOnly(obj.ais_shape, True)

    def set_object_visible(self, obj: OCCRenderObject, visible: bool) -> None:
        """Show or hide an object."""
        if obj.ais_shape is not None:
            if visible:
                self._context.Display(obj.ais_shape, True)
            else:
                self._context.Erase(obj.ais_shape, True)

    # ─── Camera ────────────────────────────────────────────────────────

    def set_camera_position(
        self,
        position: Tuple[float, float, float],
        target: Tuple[float, float, float] = (0, 0, 0),
        up: Tuple[float, float, float] = (0, 0, 1),
    ) -> None:
        """Set camera position and orientation."""
        if self._view is None:
            return
        from OCP.gp import gp_Pnt, gp_Dir, gp_Vec

        self._view.SetProj(gp_Dir(position[0], position[1], position[2]))
        self._view.SetEye(gp_Pnt(*position))
        self._view.SetCenter(gp_Pnt(*target))
        self._view.SetUp(gp_Dir(*up))

    def get_camera_position(self) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
        """Get camera position, target, and up vector."""
        if self._view is None:
            return (
                np.array([1, 1, 1]),
                np.array([0, 0, 0]),
                np.array([0, 0, 1]),
            )
        eye = self._view.Eye()
        center = self._view.Center()
        up = self._view.Up()
        return (
            np.array([eye.X(), eye.Y(), eye.Z()]),
            np.array([center.X(), center.Y(), center.Z()]),
            np.array([up.X(), up.Y(), up.Z()]),
        )

    def fit_camera(self, padding: float = 0.05) -> None:
        """Fit camera to show all displayed objects.

        *padding* is the margin coefficient (0 ≤ padding < 1.0) passed to
        OCC's ``FitAll``, not a multiplicative factor.  A small value like
        0.05 adds 5% margin around the bounding box.
        """
        if self._view is None:
            return
        margin = max(0.0, min(padding, 0.99))
        self._view.FitAll(margin)

    def set_camera_perspective(
        self, fov: float = 50.0, near: float = 0.1, far: float = 10000.0
    ) -> None:
        """Set perspective camera."""
        if self._view is None:
            return
        from OCP.V3d import V3d_PERSPECTIVE

        self._view.SetComputedMode(False)  # manual mode
        self._view.ChangeRenderingParams()
        # perspective/orthographic toggle handled in set_camera_orthographic

    def set_camera_orthographic(
        self, width: float = 100.0, near: float = 0.1, far: float = 10000.0
    ) -> None:
        """Set orthographic camera."""
        if self._view is None:
            return
        from OCP.V3d import V3d_ORTHOGRAPHIC

        self._view.SetComputedMode(False)

    # ─── Rendering ─────────────────────────────────────────────────────

    def render(self) -> None:
        """Redraw the OCC view."""
        if self._view is None:
            return
        self._view.Redraw()

    def screenshot(self, width: int, height: int) -> bytes:
        """Take a screenshot."""
        return b""

    # ─── Stub implementations for remaining abstract methods ──────────

    def add_axes(self, size: float = 100.0) -> None:
        """Add coordinate axes."""
        pass

    def add_grid(self, size: float = 100.0) -> None:
        """Add a reference grid."""
        pass

    def get_screen_size(self) -> Tuple[int, int]:
        if self._parent_widget:
            return self._parent_widget.width(), self._parent_widget.height()
        return (800, 600)

    def on_camera_change(self, callback: Any) -> None:
        pass

    def on_pick(self, callback: Any) -> None:
        pass

    def project_to_screen(
        self, point: Tuple[float, float, float]
    ) -> Tuple[float, float]:
        return (0.0, 0.0)

    def save_screenshot(self, path: str, width: int = 1920, height: int = 1080) -> None:
        logger.warning("save_screenshot not implemented for OCCRenderer")

    def set_background_color(self, color: Tuple[float, float, float]) -> None:
        if self._view is None:
            return
        from OCP.Quantity import Quantity_Color, Quantity_TOC_RGB
        qcol = Quantity_Color(*color, Quantity_TOC_RGB)
        self._view.SetBackgroundColor(qcol)

    def take_screenshot(self) -> bytes:
        return b""

    def unproject_from_screen(
        self, x: float, y: float
    ) -> Tuple[float, float, float]:
        return (0.0, 0.0, 0.0)

    # ─── Mouse event forwarding ────────────────────────────────────────

    def handle_mouse_press(self, event) -> None:
        """Forward a QMouseEvent to the OCC view for orbit/pan/zoom/select."""
        from OCP.Aspect import Aspect_VKeyMouse
        from OCP.AIS import AIS_SelectionScheme

        if self._view is None or self._context is None:
            return

        # Middle mouse → start rotation
        if event.button() == 4:  # Qt.MiddleButton
            self._view.StartRotation(event.x(), event.y())
        # Left mouse → try selection (OCC picks nearest shape)
        elif event.button() == 1:  # Qt.LeftButton
            self._context.Select(True)

    def handle_mouse_move(self, event) -> None:
        """Forward mouse motion to OCC view (rotation, dynamic highlighting)."""
        from OCP.Aspect import Aspect_VKeyMouse

        if self._view is None or self._context is None:
            return

        buttons = event.buttons()
        if buttons & 4:  # Qt.MiddleButton
            self._view.Rotation(event.x(), event.y())
        elif buttons & 2:  # Qt.RightButton
            dx = event.x() - self._last_mouse_x
            dy = event.y() - self._last_mouse_y
            self._view.Pan(dx, dy)
        # Dynamic highlighting (detect)
        self._context.MoveTo(event.x(), event.y(), self._view, True)

        self._last_mouse_x = event.x()
        self._last_mouse_y = event.y()

    def handle_mouse_release(self, event) -> None:
        """End rotation/pan."""
        pass

    def handle_wheel(self, event) -> None:
        """Zoom on scroll."""
        if self._view is None:
            return
        delta = event.angleDelta().y()
        if delta > 0:
            self._view.SetZoom(1.1)
        else:
            self._view.SetZoom(0.9)

    def handle_resize(self, w: int, h: int) -> None:
        """Resize the OCC view when the widget is resized."""
        if self._window is not None:
            self._window.SetSize(w, h)
        if self._view is not None:
            self._view.MustBeResized()
            self._view.Redraw()