sketchmol.py

#!/usr/bin/env python3
"""SketchMol - molecular renderer using a cross-hatching shader."""

import argparse
import math
import os
import sys
from dataclasses import dataclass
from typing import List, Optional, Tuple

import numpy as np
from PIL import Image, ImageDraw, ImageFont

from molecule_parser import MoleculeParser

__version__ = "0.1.0"


# CPK colors (Corey-Pauling-Koltun) for common elements
# Colors are in RGB format (0-255)
CPK_COLORS = {
    'H': (255, 255, 255),    # white
    'C': (0, 0, 0),          # black
    'N': (0, 0, 255),        # blue
    'O': (255, 0, 0),        # red
    'F': (0, 255, 0),        # green (fluorine)
    'Cl': (0, 255, 0),       # green (chlorine)
    'Br': (139, 0, 0),       # dark red
    'I': (148, 0, 211),      # dark violet
    'He': (0, 255, 255),     # cyan
    'Ne': (0, 255, 255),     # cyan
    'Ar': (0, 255, 255),     # cyan
    'Kr': (0, 255, 255),     # cyan
    'Xe': (0, 255, 255),     # cyan
    'Rn': (0, 255, 255),     # cyan
    'P': (255, 165, 0),      # orange
    'S': (255, 255, 0),      # yellow
    'B': (245, 245, 220),    # beige
    'Li': (218, 112, 214),   # violet (alkali metal)
    'Na': (218, 112, 214),   # violet
    'K': (218, 112, 214),    # violet
    'Rb': (218, 112, 214),   # violet
    'Cs': (218, 112, 214),   # violet
    'Fr': (218, 112, 214),   # violet
    'Be': (0, 100, 0),       # dark green (alkaline earth)
    'Mg': (0, 100, 0),       # dark green
    'Ca': (0, 100, 0),       # dark green
    'Sr': (0, 100, 0),       # dark green
    'Ba': (0, 100, 0),       # dark green
    'Ra': (0, 100, 0),       # dark green
    'Ti': (128, 128, 128),   # grey
    'Fe': (255, 140, 0),     # dark orange
}


@dataclass
class CrossHatchSettings:
    """Configuration for cross-hatching renderer appearance.

    Attributes:
        ambient: Ambient lighting weight (0-100).
        diffuse: Diffuse lighting weight (0-100).
        specular: Specular highlight weight (0-100).
        rim: Rim lighting weight for edge emphasis (0-100).
        shininess: Specular shininess exponent.
        invert_rim: If True, invert the rim lighting effect.
        solid_render: If True, render solid shading instead of cross-hatching.
        display_outline: If True, draw outlines around atoms.
        outline_width: Outline thickness as fraction of atom radius.
        ink_color: RGB tuple for ink color when not using CPK colors.
        light_direction: XYZ direction vector for main light source.
        hatch_scale: Scale factor for hatch texture frequency.
        hatch_repeat: UV repeat factors for hatch textures.
        paper_path: Filename of paper texture in assets directory.
        use_cpk_colors: If True, use element-based CPK coloring.
        show_symbols: If True, display element labels on atoms.
        label_size: Label size preset ('small', 'medium', or 'large').
    """

    ambient: float = 13.0
    diffuse: float = 27.0
    specular: float = 100.0
    rim: float = 76.0
    shininess: float = 27.0
    invert_rim: bool = False
    solid_render: bool = False
    display_outline: bool = True
    outline_width: float = 0.05
    ink_color: Tuple[int, int, int] = (41, 41, 202)
    light_direction: Tuple[float, float, float] = (-100.0, 100.0, 0.0)
    hatch_scale: float = 1.0
    hatch_repeat: Tuple[float, float] = (4.0, 4.0)
    paper_path: str = "brown.jpg"
    use_cpk_colors: bool = False
    show_symbols: bool = False
    label_size: str = "small"


class CrossHatchTextures:
    """Load and sample hatch textures and paper background."""

    PRESETS = {
        "Classroom (Brown Paper)": "brown.jpg",
        "White": "placeholder.jpg",
        "Aged Paper": "white",  # Special case for grey90
    }

    def __init__(self, assets_dir: str, paper_override: Optional[str] = None, preset: Optional[str] = None):
        hatch_prefix = os.path.join(assets_dir, "hatch_")
        self.hatches = []
        for idx in range(6):
            path = f"{hatch_prefix}{idx}.jpg"
            if not os.path.exists(path):
                raise FileNotFoundError(f"Missing hatch texture: {path}")
            tex = Image.open(path).convert("L")
            self.hatches.append(np.asarray(tex, dtype=np.float32) / 255.0)

        # Handle preset selection
        if preset and preset in self.PRESETS:
            paper_name = self.PRESETS[preset]
        else:
            paper_name = paper_override or "brown.jpg"

        # Create grey90 background if requested
        if paper_name is None or paper_name.lower() == "white":
            # Create a small grey90 texture (will be tiled) - 90% brightness = 0.9
            self.paper = np.full((256, 256, 3), 0.9, dtype=np.float32)
        else:
            paper_path = os.path.join(assets_dir, paper_name)
            if not os.path.exists(paper_path):
                raise FileNotFoundError(f"Missing paper texture: {paper_path}")
            self.paper = np.asarray(Image.open(paper_path).convert("RGB"), dtype=np.float32) / 255.0

    def sample_hatch(self, idx: int, u: np.ndarray, v: np.ndarray) -> np.ndarray:
        """Sample hatch texture with wrapping (like GLSL texture() with repeat wrapping).

        u and v are in texture repeat space (can be > 1.0 for tiling).
        We need to convert them to pixel coordinates and wrap.
        """
        tex = self.hatches[idx]
        h, w = tex.shape
        # Convert to pixel coordinates: multiply by texture size
        u_px = u * w
        v_px = v * h
        # Floor and wrap (modulo)
        u_idx = np.mod(np.floor(u_px).astype(np.int32), w)
        v_idx = np.mod(np.floor(v_px).astype(np.int32), h)
        return tex[v_idx, u_idx]

    def tile_paper(self, width: int, height: int) -> np.ndarray:
        h, w, _ = self.paper.shape
        y_idx = np.mod(np.arange(height), h)
        x_idx = np.mod(np.arange(width), w)
        return self.paper[np.ix_(y_idx, x_idx)].copy()

    def set_preset(self, assets_dir: str, preset: str) -> None:
        """Change the background to a different preset."""
        if preset not in self.PRESETS:
            return

        paper_name = self.PRESETS[preset]
        if paper_name is None or paper_name.lower() == "white":
            self.paper = np.full((256, 256, 3), 0.9, dtype=np.float32)
        else:
            paper_path = os.path.join(assets_dir, paper_name)
            if os.path.exists(paper_path):
                self.paper = np.asarray(Image.open(paper_path).convert("RGB"), dtype=np.float32) / 255.0


class RotationState:
    """Simple Euler rotation container."""

    def __init__(self):
        self.matrix = np.eye(3, dtype=np.float32)

    def reset(self) -> None:
        self.matrix = np.eye(3, dtype=np.float32)

    def rotate_x(self, angle: float) -> None:
        c, s = math.cos(angle), math.sin(angle)
        rot = np.array([[1, 0, 0], [0, c, -s], [0, s, c]], dtype=np.float32)
        self.matrix = self.matrix @ rot

    def rotate_y(self, angle: float) -> None:
        c, s = math.cos(angle), math.sin(angle)
        rot = np.array([[c, 0, s], [0, 1, 0], [-s, 0, c]], dtype=np.float32)
        self.matrix = self.matrix @ rot

    def rotate_z(self, angle: float) -> None:
        c, s = math.cos(angle), math.sin(angle)
        rot = np.array([[c, -s, 0], [s, c, 0], [0, 0, 1]], dtype=np.float32)
        self.matrix = self.matrix @ rot


class CrossHatchRenderer:
    """Renderer that applies cross-hatching shading to molecular spheres."""

    def __init__(self, width: int, height: int, textures: CrossHatchTextures, settings: CrossHatchSettings):
        self.width = width
        self.height = height
        self.textures = textures
        self.settings = settings
        self.rotation = RotationState()
        self.zoom = 10.0
        self.radius_scale = 0.15
        self.auto_zoom = True
        self.pan = np.zeros(2, dtype=np.float32)

        self.light_dir = np.array(settings.light_direction, dtype=np.float32)
        norm = np.linalg.norm(self.light_dir)
        if norm == 0:
            raise ValueError("Light direction vector must be non-zero")
        self.light_dir /= norm
        self.view_dir = np.array([0.0, 0.0, 1.0], dtype=np.float32)

    @staticmethod
    def _normalized_weight(value: float) -> float:
        return value / 100.0 if value > 1.0 else value

    def project(self, rotated: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
        x = rotated[:, 0] * self.zoom + self.width / 2.0 + self.pan[0]
        y = rotated[:, 1] * self.zoom + self.height / 2.0 + self.pan[1]
        z = rotated[:, 2]
        return x, y, z

    def update_zoom(self, coords: np.ndarray) -> None:
        if not self.auto_zoom:
            return

        rotated = coords @ self.rotation.matrix.T
        max_extent = np.max(np.linalg.norm(rotated[:, :2], axis=1))
        if max_extent > 1e-6:
            self.zoom = min(self.width, self.height) / (2.6 * max_extent)
            self.zoom = float(max(self.zoom, 1.0))

    def adjust_zoom(self, factor: float) -> None:
        if factor <= 0:
            raise ValueError("Zoom factor must be positive")
        self.zoom = float(np.clip(self.zoom * factor, 1.0, 1e4))
        self.auto_zoom = False

    def set_zoom(self, value: float) -> None:
        if value <= 0:
            raise ValueError("Zoom value must be positive")
        self.zoom = float(np.clip(value, 1.0, 1e4))
        self.auto_zoom = False

    def adjust_pan(self, dx: float, dy: float) -> None:
        self.pan[0] += float(dx)
        self.pan[1] += float(dy)

    def reset_view(self) -> None:
        self.rotation.reset()
        self.zoom = 10.0
        self.pan[:] = 0.0
        self.auto_zoom = True

    def render(self, symbols: List[str], coords: np.ndarray, bonds: Optional[List[Tuple[int, int]]] = None) -> Image.Image:
        if len(symbols) == 0:
            raise ValueError("No atoms to render")

        center = np.mean(coords, axis=0)
        coords_centered = coords - center
        self.update_zoom(coords_centered)

        weights = (
            self._normalized_weight(self.settings.ambient),
            self._normalized_weight(self.settings.diffuse),
            self._normalized_weight(self.settings.rim),
            self._normalized_weight(self.settings.specular),
        )
        ink_rgb = np.array(self.settings.ink_color, dtype=np.float32) / 255.0
        hatch_repeat = np.array(self.settings.hatch_repeat, dtype=np.float32)
        if hatch_repeat.shape != (2,):
            hatch_repeat = np.ones(2, dtype=np.float32)
        hatch_repeat = np.where(hatch_repeat == 0.0, 1.0, hatch_repeat)

        rotated = coords_centered @ self.rotation.matrix.T
        x, y, z = self.project(rotated)

        order = np.argsort(z)  # back to front

        image = self.textures.tile_paper(self.width, self.height)

        # Draw bonds first (behind atoms)
        if bonds:
            self._draw_bonds(image, rotated, x, y, z, bonds, ink_rgb, symbols)

        for idx in order:
            symbol = symbols[idx]
            center_world = rotated[idx]
            center_screen = np.array([x[idx], y[idx]], dtype=np.float32)
            radius_world = self._radius_for_symbol(symbol)
            # Get per-atom color (CPK or default)
            atom_ink_rgb = self._color_for_symbol(symbol)
            if self.settings.display_outline:
                self._shade_outline(
                    image,
                    center_screen,
                    radius_world,
                    atom_ink_rgb,
                )
            self._shade_sphere(
                image,
                center_world,
                center_screen,
                radius_world,
                weights,
                atom_ink_rgb,
                hatch_repeat,
            )

        np.clip(image, 0.0, 1.0, out=image)
        img_uint8 = (image * 255).astype(np.uint8)
        pil_image = Image.fromarray(img_uint8)

        if self.settings.show_symbols:
            self._draw_labels(pil_image, symbols, x, y)

        return pil_image

    def _draw_labels(
        self,
        image: Image.Image,
        symbols: List[str],
        x: np.ndarray,
        y: np.ndarray,
    ) -> None:
        """Draw element labels at lower-right of each atom."""
        draw = ImageDraw.Draw(image)

        # Calculate font size based on carbon atom's apparent size
        carbon_radius = self._radius_for_symbol('C')
        carbon_pixels = carbon_radius * self.zoom * self.radius_scale

        # Base sizes scaled by carbon atom size (reference: 40px carbon = base sizes)
        scale = carbon_pixels / 40.0
        base_sizes = {"small": 28, "medium": 36, "large": 48}
        base = base_sizes.get(self.settings.label_size, 28)
        font_size = max(12, int(base * scale))

        # Try to load a font, fall back to default if not available
        font = None
        for path in [
            "/System/Library/Fonts/Helvetica.ttc",
            "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
            "arial.ttf",
        ]:
            try:
                font = ImageFont.truetype(path, font_size)
                break
            except OSError:
                continue
        if font is None:
            font = ImageFont.load_default()

        label_color = (0, 0, 0)

        for idx, symbol in enumerate(symbols):
            radius_world = self._radius_for_symbol(symbol)
            radius_pixels = radius_world * self.zoom * self.radius_scale

            # Position label at lower-right of atom
            label_x = x[idx] + radius_pixels + 2
            label_y = y[idx] + radius_pixels + 2

            draw.text((label_x, label_y), symbol, fill=label_color, font=font)

    def _color_for_symbol(self, symbol: str) -> np.ndarray:
        """Get ink color for a symbol, using CPK colors if enabled."""
        if self.settings.use_cpk_colors:
            # Use CPK color if available, otherwise use default ink color
            cpk_rgb = CPK_COLORS.get(symbol, self.settings.ink_color)
            return np.array(cpk_rgb, dtype=np.float32) / 255.0
        else:
            return np.array(self.settings.ink_color, dtype=np.float32) / 255.0

    def _radius_for_symbol(self, symbol: str) -> float:
        radii = {
            'H': 1.2, 'C': 1.7, 'N': 1.55, 'O': 1.52, 'F': 1.47,
            'S': 1.8, 'P': 1.8, 'Cl': 1.75, 'Br': 1.85, 'I': 1.98,
        }
        return radii.get(symbol, 1.7)

    def _clip_bond_against_sphere(
        self,
        p1: np.ndarray,
        p2: np.ndarray,
        center: np.ndarray,
        radius: float,
    ) -> List[Tuple[np.ndarray, np.ndarray]]:
        """Clip a bond line segment against a sphere, returning visible segments.

        Returns a list of (start, end) tuples for line segments that are outside the sphere.
        """
        # Vector from p1 to p2
        d = p2 - p1
        # Vector from p1 to sphere center
        f = p1 - center

        # Quadratic equation: ||p1 + t*d - center||^2 = radius^2
        # Expanding: a*t^2 + b*t + c = 0
        a = np.dot(d, d)
        b = 2 * np.dot(f, d)
        c = np.dot(f, f) - radius * radius

        discriminant = b*b - 4*a*c

        # No intersection
        if discriminant < 0:
            return [(p1, p2)]

        # Find intersection points (t values along the line)
        sqrt_disc = np.sqrt(discriminant)
        t1 = (-b - sqrt_disc) / (2*a)
        t2 = (-b + sqrt_disc) / (2*a)

        # Clip t values to [0, 1] range (the bond segment)
        t1 = np.clip(t1, 0, 1)
        t2 = np.clip(t2, 0, 1)

        segments = []

        # If t1 > 0, we have a segment from start to first intersection
        if t1 > 0.01:  # Small epsilon to avoid tiny segments
            segments.append((p1, p1 + t1 * d))

        # If t2 < 1, we have a segment from second intersection to end
        if t2 < 0.99:  # Small epsilon to avoid tiny segments
            segments.append((p1 + t2 * d, p2))

        return segments

    def _draw_bonds(
        self,
        image: np.ndarray,
        rotated: np.ndarray,
        x: np.ndarray,
        y: np.ndarray,
        z: np.ndarray,
        bonds: List[Tuple[int, int]],
        ink_rgb: np.ndarray,
        symbols: List[str],
    ) -> None:
        """Draw bonds as thin wireframe lines, clipped against atom spheres."""
        bond_color = ink_rgb * 0.7  # Lighter color (70% of ink)
        line_width = 1.5  # Thin line

        for atom1, atom2 in bonds:
            # 3D coordinates in rotated space
            p1_3d = rotated[atom1]
            p2_3d = rotated[atom2]

            # Start with the full bond segment
            segments = [(p1_3d, p2_3d)]

            # Clip against all atom spheres
            for atom_idx in range(len(rotated)):
                # Skip the bond's endpoint atoms (allow small overlap)
                if atom_idx == atom1 or atom_idx == atom2:
                    continue

                sphere_center = rotated[atom_idx]
                # Radius in world space (without zoom - zoom is only for screen projection)
                sphere_radius = self._radius_for_symbol(symbols[atom_idx]) * self.radius_scale

                # Clip all current segments against this sphere
                new_segments = []
                for seg_start, seg_end in segments:
                    clipped = self._clip_bond_against_sphere(seg_start, seg_end, sphere_center, sphere_radius)
                    new_segments.extend(clipped)
                segments = new_segments

            # Draw all visible segments
            for seg_start, seg_end in segments:
                # Project to screen coordinates
                x1 = seg_start[0] * self.zoom + self.width / 2.0 + self.pan[0]
                y1 = seg_start[1] * self.zoom + self.height / 2.0 + self.pan[1]
                x2 = seg_end[0] * self.zoom + self.width / 2.0 + self.pan[0]
                y2 = seg_end[1] * self.zoom + self.height / 2.0 + self.pan[1]

                # Draw line using Bresenham-like algorithm
                self._draw_line(image, x1, y1, x2, y2, bond_color, line_width)

    def _draw_line(
        self,
        image: np.ndarray,
        x1: float,
        y1: float,
        x2: float,
        y2: float,
        color: np.ndarray,
        width: float,
    ) -> None:
        """Draw a line on the image using anti-aliased algorithm."""
        # Convert to integer coordinates
        x1_int, y1_int = int(x1), int(y1)
        x2_int, y2_int = int(x2), int(y2)

        # Calculate line direction and length
        dx = x2 - x1
        dy = y2 - y1
        length = np.sqrt(dx * dx + dy * dy)

        if length < 0.5:
            return

        # Number of samples along the line
        num_samples = int(length) + 1

        for i in range(num_samples):
            t = i / max(num_samples - 1, 1)
            px = x1 + t * dx
            py = y1 + t * dy

            # Draw a small circle at this point for thickness
            px_int = int(px)
            py_int = int(py)

            radius = int(width + 0.5)
            for dy_offset in range(-radius, radius + 1):
                for dx_offset in range(-radius, radius + 1):
                    if dx_offset * dx_offset + dy_offset * dy_offset <= width * width:
                        img_x = px_int + dx_offset
                        img_y = py_int + dy_offset

                        if 0 <= img_x < self.width and 0 <= img_y < self.height:
                            image[img_y, img_x] *= color

    def _shade_sphere(
        self,
        image: np.ndarray,
        center_world: np.ndarray,
        center_screen: np.ndarray,
        radius_world: float,
        weights: Tuple[float, float, float, float],
        ink_rgb: np.ndarray,
        hatch_repeat: np.ndarray,
    ) -> None:
        radius_pixels = radius_world * self.zoom * self.radius_scale
        if radius_pixels <= 1.0:
            return

        xmin = max(int(center_screen[0] - radius_pixels - 1), 0)
        xmax = min(int(center_screen[0] + radius_pixels + 1), self.width - 1)
        ymin = max(int(center_screen[1] - radius_pixels - 1), 0)
        ymax = min(int(center_screen[1] + radius_pixels + 1), self.height - 1)

        if xmin >= xmax or ymin >= ymax:
            return

        xs = np.arange(xmin, xmax + 1)
        ys = np.arange(ymin, ymax + 1)
        grid_x, grid_y = np.meshgrid(xs, ys)

        # Calculate pixel offset from center in screen space
        dx = (grid_x + 0.5) - center_screen[0]
        dy = (grid_y + 0.5) - center_screen[1]

        dist2 = dx ** 2 + dy ** 2
        mask = dist2 <= radius_pixels ** 2
        if not np.any(mask):
            return

        # Calculate normalized offset (like the GLSL offset in fragment shader)
        # This is the key fix: normals should be in VIEW SPACE, not world space
        # Note: Y is negated because screen Y increases downward but we want up to be positive
        offset_x = dx / radius_pixels
        offset_y = -dy / radius_pixels  # Flip Y axis
        dist2_norm = offset_x ** 2 + offset_y ** 2

        # Update mask for actual sphere boundary
        mask &= dist2_norm <= 1.0
        if not np.any(mask):
            return

        # Calculate z component of normal (depth into sphere)
        # Like GLSL: float dz = sqrt(max(0.0, 1.0 - dist2));
        dz = np.sqrt(np.maximum(0.0, 1.0 - dist2_norm))

        # Build view-space normals (this is the surface normal of the sphere in view coordinates)
        # Like GLSL: vec3 normal = normalize(vec3(offset, dz));
        normals = np.stack((offset_x, offset_y, dz), axis=-1)
        normals_mag = np.linalg.norm(normals, axis=-1, keepdims=True)
        normals = np.divide(normals, normals_mag, where=normals_mag > 0)

        # Diffuse lighting: max(dot(normal, light_dir), 0.0)
        diffuse = np.maximum(0.0, np.sum(normals * self.light_dir, axis=-1))

        # Specular reflection: -light_dir + 2.0 * diffuse * normal
        # Like GLSL: vec3 reflect_dir = normalize(-light_dir + 2.0 * diff_val * normal);
        reflect_dir = -self.light_dir + 2.0 * diffuse[..., np.newaxis] * normals
        reflect_norm = np.linalg.norm(reflect_dir, axis=-1, keepdims=True)
        reflect_dir = np.divide(reflect_dir, reflect_norm, where=reflect_norm > 0)

        # Specular component: pow(max(dot(reflect_dir, view_dir), 0.0), shininess)
        specular = np.power(
            np.maximum(0.0, np.sum(reflect_dir * self.view_dir, axis=-1)),
            self.settings.shininess,
        )
        specular *= (diffuse > 0.0)

        # Rim lighting: abs(dot(normal, view_dir))
        rim = np.abs(np.sum(normals * self.view_dir, axis=-1))
        if self.settings.invert_rim:
            rim = 1.0 - rim
        rim = np.clip(rim, 0.0, 1.0)

        # Combine lighting components
        ambient_w, diffuse_w, rim_w, specular_w = weights
        shading = (
            ambient_w * 1.0
            + diffuse_w * diffuse
            + rim_w * rim
            + specular_w * specular
        )
        shading = np.clip(shading, 0.0, 1.0)

        # Calculate texture coordinates like Three.js SphereGeometry
        # The normals are in view space: (dx/r, dy/r, dz/r) where r=1 for normalized
        # Three.js sphere UV mapping:
        #   U = atan2(x, z) / (2*PI) + 0.5
        #   V = asin(y) / PI + 0.5
        # Since normals = (offset_x, offset_y, dz) in view space:
        base_u = np.arctan2(normals[..., 0], normals[..., 2]) / (2.0 * math.pi) + 0.5
        base_v = np.arcsin(np.clip(normals[..., 1], -1.0, 1.0)) / math.pi + 0.5

        scale = self.settings.hatch_scale
        u = base_u * scale * hatch_repeat[0]
        v = base_v * scale * hatch_repeat[1]

        # Sample cross-hatch or render solid
        if self.settings.solid_render:
            src = np.repeat(shading[..., np.newaxis], 3, axis=-1)
        else:
            # For cross-hatch sampling, use shading WITHOUT specular
            # This prevents specular from making the hatching disappear
            shading_for_hatch = np.clip(
                ambient_w * 1.0 + diffuse_w * diffuse + rim_w * rim,
                0.0, 1.0
            )
            c = self._sample_cross_hatch(shading_for_hatch, u, v)
            c_rgb = np.repeat(c[..., np.newaxis], 3, axis=-1)
            # Like GLSL: vec3 mix1 = ink_color * (1.0 - c_rgb) + vec3(1.0) * c_rgb;
            #           src = 0.5 * mix1 + 0.5 * c_rgb;
            mix1 = ink_rgb * (1.0 - c_rgb) + 1.0 * c_rgb
            src = 0.5 * mix1 + 0.5 * c_rgb

            # Add specular highlight as pure white on top
            # Blend toward white where specular is strong
            specular_rgb = np.repeat(specular[..., np.newaxis], 3, axis=-1)
            src = src * (1.0 - specular_rgb * specular_w) + specular_rgb * specular_w

        # Multiply with paper texture (like GLSL: vec3 color = paper * src;)
        paper_patch = image[ymin:ymax + 1, xmin:xmax + 1]
        paper_patch[mask] *= src[mask]

    def _shade_outline(
        self,
        image: np.ndarray,
        center_screen: np.ndarray,
        radius_world: float,
        ink_rgb: np.ndarray,
    ) -> None:
        if self.settings.outline_width <= 0.0:
            return

        base_radius = radius_world * self.zoom * self.radius_scale
        if base_radius <= 1.0:
            return

        outline_radius = base_radius * (1.0 + self.settings.outline_width)

        xmin = max(int(center_screen[0] - outline_radius - 1), 0)
        xmax = min(int(center_screen[0] + outline_radius + 1), self.width - 1)
        ymin = max(int(center_screen[1] - outline_radius - 1), 0)
        ymax = min(int(center_screen[1] + outline_radius + 1), self.height - 1)
        if xmin >= xmax or ymin >= ymax:
            return

        xs = np.arange(xmin, xmax + 1)
        ys = np.arange(ymin, ymax + 1)
        grid_x, grid_y = np.meshgrid(xs, ys)

        dx = (grid_x + 0.5) - center_screen[0]
        dy = (grid_y + 0.5) - center_screen[1]
        dist2 = dx ** 2 + dy ** 2

        outer_mask = dist2 <= outline_radius ** 2
        inner_mask = dist2 < base_radius ** 2
        ring_mask = outer_mask & (~inner_mask)
        if not np.any(ring_mask):
            return

        paper_patch = image[ymin:ymax + 1, xmin:xmax + 1]
        # Lighter outline color (0.6 instead of 0.5 for less darkness)
        outline_color = 0.6 * ink_rgb
        paper_patch[ring_mask] *= outline_color

    def _sample_cross_hatch(self, shading: np.ndarray, u: np.ndarray, v: np.ndarray) -> np.ndarray:
        step = 1.0 / 6.0

        c = np.zeros_like(shading)

        def lerp(a, b, t):
            return a * (1.0 - t) + b * t

        bins = [self.textures.sample_hatch(i, u, v) for i in range(6)]
        white = np.ones_like(shading)

        mask = shading <= step
        if np.any(mask):
            t = shading[mask] * 6.0
            c[mask] = lerp(bins[5][mask], bins[4][mask], t)

        mask = (shading > step) & (shading <= 2 * step)
        if np.any(mask):
            t = (shading[mask] - step) * 6.0
            c[mask] = lerp(bins[4][mask], bins[3][mask], t)

        mask = (shading > 2 * step) & (shading <= 3 * step)
        if np.any(mask):
            t = (shading[mask] - 2 * step) * 6.0
            c[mask] = lerp(bins[3][mask], bins[2][mask], t)

        mask = (shading > 3 * step) & (shading <= 4 * step)
        if np.any(mask):
            t = (shading[mask] - 3 * step) * 6.0
            c[mask] = lerp(bins[2][mask], bins[1][mask], t)

        mask = (shading > 4 * step) & (shading <= 5 * step)
        if np.any(mask):
            t = (shading[mask] - 4 * step) * 6.0
            c[mask] = lerp(bins[1][mask], bins[0][mask], t)

        mask = shading > 5 * step
        if np.any(mask):
            t = (shading[mask] - 5 * step) * 6.0
            c[mask] = lerp(bins[0][mask], white[mask], t)

        return c


class CrossHatchOpenGLViewer:
    """Interactive OpenGL viewer with GLSL cross-hatching shader."""

    ROTATE_STEP = math.pi / 36.0
    AUTO_ROTATE_STEP = math.pi / 180.0

    def __init__(
        self,
        symbols: List[str],
        coords: np.ndarray,
        renderer: CrossHatchRenderer,
        textures: CrossHatchTextures,
        settings: CrossHatchSettings,
        assets_dir: str,
        bonds: Optional[List[Tuple[int, int]]] = None,
    ) -> None:
        # Lazy import of OpenGL dependencies
        try:
            import glfw as _glfw
            import moderngl as _moderngl
            import imgui as _imgui
            from imgui.integrations.glfw import GlfwRenderer as _GlfwRenderer
        except ImportError as exc:
            missing = []
            for name in ("glfw", "moderngl", "imgui"):
                try:
                    __import__(name)
                except ImportError:
                    missing.append(name)
            dep_list = ", ".join(missing) if missing else "glfw, moderngl, imgui"
            raise RuntimeError(
                f"Interactive mode requires: {dep_list}. "
                "Install with: conda install -c conda-forge glfw moderngl imgui\n"
                "Or use --render for batch mode without OpenGL."
            ) from exc

        self.glfw = _glfw
        self.mgl = _moderngl
        self._imgui = _imgui
        self._GlfwRenderer = _GlfwRenderer

        self.symbols = symbols
        self.coords = coords
        self.renderer = renderer
        self.textures = textures
        self.settings = settings
        self.assets_dir = assets_dir
        self.bonds = bonds

        self.center = np.mean(coords, axis=0)
        self.coords_centered = coords - self.center
        self.radius_world = np.array([renderer._radius_for_symbol(sym) for sym in symbols], dtype=np.float32)
        # Per-atom colors (CPK or default ink color)
        self.atom_colors = np.array([renderer._color_for_symbol(sym) for sym in symbols], dtype=np.float32)

        self.ztoggle = False
        self.auto_rotate = [False, False, False]
        self.controls_visible = True

        # Mouse control state
        self.mouse_left_pressed = False
        self.mouse_right_pressed = False
        self.mouse_middle_pressed = False
        self.last_mouse_pos = np.array([0.0, 0.0], dtype=np.float32)

        self.window = None
        self.ctx = None
        self.program = None
        self.background_program = None
        self.bond_program = None
        self.corner_buffer = None
        self.center_buffer = None
        self.radius_buffer = None
        self.quad_vao = None
        self.background_vao = None
        self.bond_vao = None
        self.paper_texture = None
        self.hatch_textures: List[object] = []
        self._last_time = 0.0

        # ImGui state
        self.imgui_context = None
        self.imgui_renderer = None
        self.current_preset = "Classroom (Brown Paper)"
        self.export_filename = "molecule"

        self.renderer.auto_zoom = True
        self.renderer.pan[:] = 0.0
        self.renderer.update_zoom(self.coords_centered)
        self.renderer.auto_zoom = False
        self.pan_step = max(10.0, min(renderer.width, renderer.height) * 0.04)

    # --- Keyboard handling (polling-based to not interfere with ImGui) ----
    def _poll_keyboard(self) -> None:
        """Poll keyboard state for molecule controls. Uses polling instead of
        callbacks so ImGui can handle text input in its own callbacks."""
        io = self._imgui.get_io()
        if io.want_capture_keyboard:
            return

        glfw = self.glfw
        window = self.window

        # Quit
        if glfw.get_key(window, glfw.KEY_ESCAPE) == glfw.PRESS:
            glfw.set_window_should_close(window, True)
            return
        if glfw.get_key(window, glfw.KEY_Q) == glfw.PRESS:
            glfw.set_window_should_close(window, True)
            return

        # Rotation
        if glfw.get_key(window, glfw.KEY_UP) == glfw.PRESS:
            self.renderer.rotation.rotate_x(-self.ROTATE_STEP)
        if glfw.get_key(window, glfw.KEY_DOWN) == glfw.PRESS:
            self.renderer.rotation.rotate_x(self.ROTATE_STEP)
        if glfw.get_key(window, glfw.KEY_LEFT) == glfw.PRESS:
            if self.ztoggle:
                self.renderer.rotation.rotate_z(self.ROTATE_STEP)
            else:
                self.renderer.rotation.rotate_y(self.ROTATE_STEP)
        if glfw.get_key(window, glfw.KEY_RIGHT) == glfw.PRESS:
            if self.ztoggle:
                self.renderer.rotation.rotate_z(-self.ROTATE_STEP)
            else:
                self.renderer.rotation.rotate_y(-self.ROTATE_STEP)

        # Pan
        if glfw.get_key(window, glfw.KEY_W) == glfw.PRESS:
            self.renderer.adjust_pan(0.0, self.pan_step)
        if glfw.get_key(window, glfw.KEY_S) == glfw.PRESS:
            self.renderer.adjust_pan(0.0, -self.pan_step)
        if glfw.get_key(window, glfw.KEY_A) == glfw.PRESS:
            self.renderer.adjust_pan(-self.pan_step, 0.0)
        if glfw.get_key(window, glfw.KEY_D) == glfw.PRESS:
            self.renderer.adjust_pan(self.pan_step, 0.0)

        # Zoom
        if glfw.get_key(window, glfw.KEY_EQUAL) == glfw.PRESS:
            self.renderer.adjust_zoom(1.12)
        if glfw.get_key(window, glfw.KEY_MINUS) == glfw.PRESS:
            self.renderer.adjust_zoom(1.0 / 1.12)

        # Toggle keys (check for just-pressed to avoid repeat)
        self._handle_toggle_keys()

    def _handle_toggle_keys(self) -> None:
        """Handle toggle keys that should only fire once per press."""
        glfw = self.glfw
        window = self.window

        # Track previous key states for edge detection
        if not hasattr(self, '_prev_keys'):
            self._prev_keys = {}

        def just_pressed(key):
            curr = glfw.get_key(window, key) == glfw.PRESS
            prev = self._prev_keys.get(key, False)
            self._prev_keys[key] = curr
            return curr and not prev

        if just_pressed(glfw.KEY_R):
            self.renderer.reset_view()
            self.renderer.update_zoom(self.coords_centered)
            self.renderer.auto_zoom = False
            self.ztoggle = False
            self.auto_rotate = [False, False, False]
        if just_pressed(glfw.KEY_Z):
            self.ztoggle = not self.ztoggle
        if just_pressed(glfw.KEY_F1):
            self.auto_rotate[0] = not self.auto_rotate[0]
        if just_pressed(glfw.KEY_F2):
            self.auto_rotate[1] = not self.auto_rotate[1]
        if just_pressed(glfw.KEY_F3):
            self.auto_rotate[2] = not self.auto_rotate[2]

    # --- GLFW callbacks -------------------------------------------------
    def _on_mouse_button(self, window, button, action, _mods):
        # Let ImGui handle the event first
        io = self._imgui.get_io()
        if io.want_capture_mouse:
            return

        if button == self.glfw.MOUSE_BUTTON_LEFT:
            self.mouse_left_pressed = (action == self.glfw.PRESS)
        elif button == self.glfw.MOUSE_BUTTON_RIGHT:
            self.mouse_right_pressed = (action == self.glfw.PRESS)
        elif button == self.glfw.MOUSE_BUTTON_MIDDLE:
            self.mouse_middle_pressed = (action == self.glfw.PRESS)

        # Update last mouse position when button is pressed
        if action == self.glfw.PRESS:
            x, y = self.glfw.get_cursor_pos(window)
            self.last_mouse_pos[:] = [x, y]

    def _on_mouse_move(self, window, xpos, ypos):
        # Let ImGui handle the event first
        io = self._imgui.get_io()
        if io.want_capture_mouse:
            return

        current_pos = np.array([xpos, ypos], dtype=np.float32)
        delta = current_pos - self.last_mouse_pos

        # Left mouse button: rotate
        if self.mouse_left_pressed:
            # Scale rotation based on mouse movement
            rotation_scale = 0.01
            self.renderer.rotation.rotate_y(-delta[0] * rotation_scale)
            self.renderer.rotation.rotate_x(-delta[1] * rotation_scale)

        # Right mouse button: pan
        elif self.mouse_right_pressed:
            self.renderer.adjust_pan(delta[0], -delta[1])

        # Middle mouse button: zoom
        elif self.mouse_middle_pressed:
            zoom_scale = 1.0 + delta[1] * 0.01
            self.renderer.adjust_zoom(zoom_scale)

        self.last_mouse_pos[:] = current_pos

    def _on_scroll(self, _window, _xoffset, yoffset):
        # Let ImGui handle the event first
        io = self._imgui.get_io()
        if io.want_capture_mouse:
            return

        # Scroll wheel: zoom in/out
        zoom_factor = 1.1 if yoffset > 0 else 1.0 / 1.1
        self.renderer.adjust_zoom(zoom_factor)

    def _on_framebuffer_size(self, _window, width, height):
        if width <= 0 or height <= 0:
            return
        self.renderer.width = width
        self.renderer.height = height
        self.pan_step = max(10.0, min(width, height) * 0.04)
        if self.ctx is not None:
            self.ctx.viewport = (0, 0, width, height)

    # --- Buffer helpers -------------------------------------------------
    @staticmethod
    def _quad_vertices() -> np.ndarray:
        return np.array([
            [-1.0, -1.0],
            [1.0, -1.0],
            [-1.0, 1.0],
            [1.0, 1.0],
        ], dtype=np.float32)

    def _compile_shaders(self) -> None:
        self.program = self.ctx.program(
            vertex_shader="""
                #version 330
                in vec2 in_corner;
                in vec3 in_center;
                in float in_radius;
                in vec3 in_color;

                uniform mat3 rotation;
                uniform float zoom;
                uniform float radius_scale;
                uniform float outline_scale;
                uniform bool show_outline;
                uniform vec2 pan;
                uniform vec2 screen_size;

                out vec2 v_center_screen;
                out float v_radius_px;
                out vec3 v_unrotated_center;
                out vec3 v_color;

                void main() {
                    vec3 rotated_center = rotation * in_center;
                    float outline_multiplier = show_outline ? (1.0 + outline_scale) : 1.0;
                    float radius_px = in_radius * zoom * radius_scale * outline_multiplier;
                    vec2 center_screen = rotated_center.xy * zoom + pan + screen_size * 0.5;
                    vec2 vertex_screen = center_screen + in_corner * radius_px;
                    vec2 ndc = (vertex_screen / (screen_size * 0.5)) - 1.0;

                    gl_Position = vec4(ndc, rotated_center.z * 0.01, 1.0);

                    v_center_screen = center_screen;
                    v_radius_px = radius_px;
                    v_unrotated_center = in_center;
                    v_color = in_color;
                }
            """,
            fragment_shader="""
                #version 330

                uniform sampler2D paper_tex;
                uniform sampler2D hatch_0;
                uniform sampler2D hatch_1;
                uniform sampler2D hatch_2;
                uniform sampler2D hatch_3;
                uniform sampler2D hatch_4;
                uniform sampler2D hatch_5;
                uniform vec3 light_dir;
                uniform vec3 view_dir;
                uniform float ambient;
                uniform float diffuse;
                uniform float rim_weight;
                uniform float specular;
                uniform float shininess;
                uniform float hatch_scale;
                uniform vec2 hatch_repeat;
                uniform vec2 paper_size;
                uniform float outline_scale;
                uniform bool invert_rim;
                uniform bool solid_render;
                uniform bool show_outline;

                in vec2 v_center_screen;
                in float v_radius_px;
                in vec3 v_unrotated_center;
                in vec3 v_color;

                out vec4 fragColor;

                const float PI = 3.14159265358979323846;

                float lerp_val(float a, float b, float t) {
                    return a * (1.0 - t) + b * t;
                }

                vec2 paper_uv(vec2 frag) {
                    return vec2(
                        mod(frag.x, paper_size.x) / paper_size.x,
                        mod(frag.y, paper_size.y) / paper_size.y
                    );
                }

                float sample_cross_hatch(float shading, vec2 uv) {
                    float step = 1.0 / 6.0;
                    float b0 = texture(hatch_0, uv).r;
                    float b1 = texture(hatch_1, uv).r;
                    float b2 = texture(hatch_2, uv).r;
                    float b3 = texture(hatch_3, uv).r;
                    float b4 = texture(hatch_4, uv).r;
                    float b5 = texture(hatch_5, uv).r;
                    float white = 1.0;

                    if (shading <= step) {
                        float t = shading * 6.0;
                        return lerp_val(b5, b4, t);
                    } else if (shading <= 2.0 * step) {
                        float t = (shading - step) * 6.0;
                        return lerp_val(b4, b3, t);
                    } else if (shading <= 3.0 * step) {
                        float t = (shading - 2.0 * step) * 6.0;
                        return lerp_val(b3, b2, t);
                    } else if (shading <= 4.0 * step) {
                        float t = (shading - 3.0 * step) * 6.0;
                        return lerp_val(b2, b1, t);
                    } else if (shading <= 5.0 * step) {
                        float t = (shading - 4.0 * step) * 6.0;
                        return lerp_val(b1, b0, t);
                    }
                    float t = (shading - 5.0 * step) * 6.0;
                    return lerp_val(b0, white, t);
                }

                void main() {
                    vec2 frag = gl_FragCoord.xy;
                    vec2 offset_raw = (frag - v_center_screen) / v_radius_px;
                    // Flip Y to match CPU renderer (screen Y increases downward)
                    vec2 offset = vec2(offset_raw.x, -offset_raw.y);
                    float dist2 = dot(offset, offset);

                    if (show_outline) {
                        float inner = 1.0 / (1.0 + outline_scale);
                        if (dist2 > 1.0 || dist2 < inner * inner) {
                            discard;
                        }
                        vec3 paper = texture(paper_tex, paper_uv(frag)).rgb;
                        vec3 outline_color = 0.5 * v_color;
                        vec3 color = paper * outline_color;
                        fragColor = vec4(clamp(color, 0.0, 1.0), 1.0);
                        return;
                    }

                    if (dist2 > 1.0) {
                        discard;
                    }

                    float dz = sqrt(max(0.0, 1.0 - dist2));
                    vec3 normal = normalize(vec3(offset, dz));

                    float diff_val = max(dot(normal, light_dir), 0.0);
                    vec3 reflect_dir = normalize(-light_dir + 2.0 * diff_val * normal);
                    float spec_val = pow(max(dot(reflect_dir, view_dir), 0.0), shininess);
                    if (diff_val <= 0.0) {
                        spec_val = 0.0;
                    }

                    float rim = abs(dot(normal, view_dir));
                    if (invert_rim) {
                        rim = 1.0 - rim;
                    }
                    rim = clamp(rim, 0.0, 1.0);

                    float shading = ambient + diffuse * diff_val + rim_weight * rim + specular * spec_val;
                    shading = clamp(shading, 0.0, 1.0);

                    // Calculate texture coordinates from unrotated surface position
                    // This makes hatching rotate with the sphere, not stay screen-fixed
                    vec3 surface_normal = normalize(v_unrotated_center + vec3(offset, dz));
                    float base_u = atan(surface_normal.x, surface_normal.z) / (2.0 * PI) + 0.5;
                    float base_v = asin(clamp(surface_normal.y, -1.0, 1.0)) / PI + 0.5;
                    vec2 hatch_uv = vec2(base_u, base_v) * hatch_scale * hatch_repeat;
                    vec3 paper = texture(paper_tex, paper_uv(frag)).rgb;

                    vec3 src;
                    if (solid_render) {
                        src = vec3(shading);
                    } else {
                        // For cross-hatch sampling, use shading WITHOUT specular
                        float shading_for_hatch = clamp(
                            ambient + diffuse * diff_val + rim_weight * rim,
                            0.0, 1.0
                        );
                        float hatch_val = sample_cross_hatch(shading_for_hatch, hatch_uv);
                        vec3 c_rgb = vec3(hatch_val);
                        vec3 mix1 = v_color * (1.0 - c_rgb) + vec3(1.0) * c_rgb;
                        src = 0.5 * mix1 + 0.5 * c_rgb;

                        // Add specular highlight as pure white on top
                        src = src + vec3(spec_val * specular);
                    }

                    vec3 color = paper * src;
                    fragColor = vec4(clamp(color, 0.0, 1.0), 1.0);
                }
            """,
        )

        self.background_program = self.ctx.program(
            vertex_shader="""
                #version 330
                in vec2 in_position;
                void main() {
                    gl_Position = vec4(in_position, 0.0, 1.0);
                }
            """,
            fragment_shader="""
                #version 330
                uniform sampler2D paper_tex;
                uniform vec2 paper_size;
                out vec4 fragColor;
                void main() {
                    vec2 uv = vec2(
                        mod(gl_FragCoord.x, paper_size.x) / paper_size.x,
                        mod(gl_FragCoord.y, paper_size.y) / paper_size.y
                    );
                    vec3 color = texture(paper_tex, uv).rgb;
                    fragColor = vec4(color, 1.0);
                }
            """,
        )

        # Bond rendering program - simple version without per-fragment sphere culling
        # (Depth testing handles most occlusion, and bonds are drawn before atoms)
        self.bond_program = self.ctx.program(
            vertex_shader="""
                #version 330
                in vec3 in_position;
                uniform mat3 rotation;
                uniform float zoom;
                uniform vec2 pan;
                uniform vec2 screen_size;

                void main() {
                    vec3 rotated = rotation * in_position;
                    vec2 screen_pos = rotated.xy * zoom + pan + screen_size * 0.5;
                    vec2 ndc = (screen_pos / (screen_size * 0.5)) - 1.0;
                    gl_Position = vec4(ndc, rotated.z * 0.01, 1.0);
                }
            """,
            fragment_shader="""
                #version 330
                uniform vec3 bond_color;
                out vec4 fragColor;

                void main() {
                    fragColor = vec4(bond_color, 1.0);
                }
            """,
        )

        # Label rendering program
        self.label_program = self.ctx.program(
            vertex_shader="""
                #version 330
                in vec2 in_corner;
                in vec3 in_center;
                in float in_radius;
                in vec2 in_size;

                uniform mat3 rotation;
                uniform float zoom;
                uniform float base_zoom;
                uniform float radius_scale;
                uniform vec2 pan;
                uniform vec2 screen_size;

                out vec2 v_texcoord;

                void main() {
                    vec3 rotated = rotation * in_center;
                    vec2 atom_screen = rotated.xy * zoom + pan + screen_size * 0.5;
                    float radius_px = in_radius * zoom * radius_scale;

                    // Scale labels with zoom, capped at 3x original size
                    float zoom_scale = clamp(zoom / base_zoom, 0.5, 3.0);
                    vec2 scaled_size = in_size * zoom_scale;

                    vec2 label_offset = vec2(radius_px + 2.0, -scaled_size.y * 0.5);
                    vec2 label_center_screen = atom_screen + label_offset + scaled_size * 0.5;
                    vec2 screen_pos = label_center_screen + in_corner * scaled_size * 0.5;

                    vec2 ndc = (screen_pos / (screen_size * 0.5)) - 1.0;
                    gl_Position = vec4(ndc, rotated.z * 0.01 + 0.001, 1.0);

                    vec2 uv = (in_corner + 1.0) * 0.5;
                    v_texcoord = vec2(uv.x, 1.0 - uv.y);
                }
            """,
            fragment_shader="""
                #version 330
                in vec2 v_texcoord;
                uniform sampler2D label_tex;
                out vec4 fragColor;

                void main() {
                    vec4 tex_color = texture(label_tex, v_texcoord);
                    if (tex_color.a < 0.01) discard;
                    fragColor = tex_color;
                }
            """,
        )

    def _create_label_textures(self) -> None:
        """Create textures for element labels."""
        unique_symbols = list(set(self.symbols))
        self.label_textures = {}
        self.label_sizes = {}

        # Store base zoom for scaling labels when user zooms
        self.label_base_zoom = self.renderer.zoom

        # Calculate font size based on carbon atom's apparent size
        carbon_radius = self.renderer._radius_for_symbol('C')
        carbon_pixels = carbon_radius * self.renderer.zoom * self.renderer.radius_scale

        # Base sizes scaled by carbon atom size (reference: 40px carbon = base sizes)
        scale = carbon_pixels / 40.0
        base_sizes = {"small": 28, "medium": 36, "large": 48}
        base = base_sizes.get(self.settings.label_size, 28)
        font_size = max(12, int(base * scale))

        # Try to load a font
        font = None
        for path in [
            "/System/Library/Fonts/Helvetica.ttc",
            "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
            "arial.ttf",
        ]:
            try:
                font = ImageFont.truetype(path, font_size)
                break
            except OSError:
                continue
        if font is None:
            font = ImageFont.load_default()

        for symbol in unique_symbols:
            dummy_img = Image.new('RGBA', (1, 1))
            dummy_draw = ImageDraw.Draw(dummy_img)
            bbox = dummy_draw.textbbox((0, 0), symbol, font=font)
            text_width = bbox[2] - bbox[0]
            text_height = bbox[3] - bbox[1]

            img_width = text_width + 4
            img_height = text_height + 4
            img = Image.new('RGBA', (img_width, img_height), (0, 0, 0, 0))
            draw = ImageDraw.Draw(img)
            draw.text((2 - bbox[0], 2 - bbox[1]), symbol, fill=(0, 0, 0, 255), font=font)

            img_data = img.tobytes()
            texture = self.ctx.texture((img_width, img_height), 4, img_data)
            texture.filter = (self.mgl.LINEAR, self.mgl.LINEAR)

            self.label_textures[symbol] = texture
            self.label_sizes[symbol] = (img_width, img_height)

    def _create_label_geometry(self) -> None:
        """Create VAOs for label quads."""
        corners = self._quad_vertices()
        corner_buffer = self.ctx.buffer(corners.tobytes())

        self.label_vaos = {}
        for symbol in self.label_textures.keys():
            indices = [i for i, s in enumerate(self.symbols) if s == symbol]
            if not indices:
                continue

            centers = self.coords_centered[indices].astype(np.float32)
            radii = np.array([self.renderer._radius_for_symbol(symbol) for _ in indices], dtype=np.float32)
            sizes = np.array([self.label_sizes[symbol] for _ in indices], dtype=np.float32)

            center_buf = self.ctx.buffer(centers.tobytes())
            radius_buf = self.ctx.buffer(radii.tobytes())
            size_buf = self.ctx.buffer(sizes.tobytes())

            vao = self.ctx.vertex_array(self.label_program, [
                (corner_buffer, "2f", "in_corner"),
                (center_buf, "3f /i", "in_center"),
                (radius_buf, "1f /i", "in_radius"),
                (size_buf, "2f /i", "in_size"),
            ])
            self.label_vaos[symbol] = (vao, len(indices))

    def _destroy_labels(self) -> None:
        """Clean up label resources."""
        if hasattr(self, 'label_vaos'):
            delattr(self, 'label_vaos')
        if hasattr(self, 'label_textures'):
            for tex in self.label_textures.values():
                tex.release()
            delattr(self, 'label_textures')
        if hasattr(self, 'label_sizes'):
            delattr(self, 'label_sizes')
        if hasattr(self, 'label_base_zoom'):
            delattr(self, 'label_base_zoom')

    def _create_textures(self) -> None:
        paper = (self.textures.paper * 255.0).astype(np.uint8)
        paper_h, paper_w, _ = paper.shape
        self.paper_texture = self.ctx.texture((paper_w, paper_h), 3, paper.tobytes())
        self.paper_texture.filter = (self.mgl.LINEAR, self.mgl.LINEAR)
        self.paper_texture.repeat_x = True
        self.paper_texture.repeat_y = True
        self.paper_texture.use(location=0)
        self.program["paper_tex"].value = 0
        self.program["paper_size"].value = (float(paper_w), float(paper_h))
        self.background_program["paper_tex"].value = 0
        self.background_program["paper_size"].value = (float(paper_w), float(paper_h))
        self.program["outline_scale"].value = float(self.settings.outline_width)
        self.program["show_outline"].value = False
        self.program["hatch_repeat"].value = (
            float(self.settings.hatch_repeat[0]),
            float(self.settings.hatch_repeat[1]),
        )

        self.hatch_textures = []
        texture_unit = 1
        for idx, hatch in enumerate(self.textures.hatches):
            data = (hatch * 255.0).astype(np.uint8)
            h, w = data.shape
            texture = self.ctx.texture((w, h), 1, data.tobytes())
            texture.filter = (self.mgl.LINEAR, self.mgl.LINEAR)
            texture.repeat_x = True
            texture.repeat_y = True
            texture.use(location=texture_unit)
            self.hatch_textures.append(texture)
            uniform_name = f"hatch_{idx}"  # Individual sampler names instead of array
            if uniform_name in self.program:
                self.program[uniform_name].value = texture_unit
            texture_unit += 1

    def _create_vertex_arrays(self) -> None:
        corners = self._quad_vertices()
        self.corner_buffer = self.ctx.buffer(corners.tobytes())
        centers = self.coords_centered.astype(np.float32)
        self.center_buffer = self.ctx.buffer(centers.tobytes())
        radii = self.radius_world.astype(np.float32)
        self.radius_buffer = self.ctx.buffer(radii.tobytes())
        colors = self.atom_colors.astype(np.float32)
        self.color_buffer = self.ctx.buffer(colors.tobytes())

        vao_content = [
            (self.corner_buffer, "2f", "in_corner"),
            (self.center_buffer, "3f /i", "in_center"),
            (self.radius_buffer, "1f /i", "in_radius"),
            (self.color_buffer, "3f /i", "in_color"),
        ]
        self.quad_vao = self.ctx.vertex_array(self.program, vao_content)

        fs_vertices = self._quad_vertices()
        fs_buffer = self.ctx.buffer(fs_vertices.tobytes())
        self.background_vao = self.ctx.vertex_array(
            self.background_program,
            [(fs_buffer, "2f", "in_position")],
        )

        # Create bond vertices if bonds exist
        # Filter out bonds where both endpoints are very close together
        # (this happens when bonds are mostly inside large spheres)
        if self.bonds:
            bond_vertices = []
            for atom1, atom2 in self.bonds:
                p1 = self.coords_centered[atom1]
                p2 = self.coords_centered[atom2]
                # Only add bond if endpoints are reasonably separated
                dist = np.linalg.norm(p2 - p1)
                if dist > 0.5:  # Minimum bond length threshold
                    bond_vertices.append(p1)
                    bond_vertices.append(p2)

            if bond_vertices:
                bond_array = np.array(bond_vertices, dtype=np.float32)
                bond_buffer = self.ctx.buffer(bond_array.tobytes())
                self.bond_vao = self.ctx.vertex_array(
                    self.bond_program,
                    [(bond_buffer, "3f", "in_position")],
                )

    def _apply_auto_rotation(self, delta: float) -> None:
        step = self.AUTO_ROTATE_STEP * (delta * 60.0)
        if self.auto_rotate[0]:
            self.renderer.rotation.rotate_x(step)
        if self.auto_rotate[1]:
            self.renderer.rotation.rotate_y(step)
        if self.auto_rotate[2]:
            self.renderer.rotation.rotate_z(step)

    def _update_uniforms(self, show_outline: bool) -> None:
        rotation = self.renderer.rotation.matrix.astype(np.float32).T
        self.program["rotation"].write(rotation.tobytes())
        self.program["zoom"].value = float(self.renderer.zoom)
        self.program["radius_scale"].value = float(self.renderer.radius_scale)
        self.program["pan"].value = (float(self.renderer.pan[0]), float(self.renderer.pan[1]))
        self.program["screen_size"].value = (float(self.renderer.width), float(self.renderer.height))
        self.program["light_dir"].value = tuple(float(x) for x in self.renderer.light_dir)
        self.program["view_dir"].value = tuple(float(x) for x in self.renderer.view_dir)
        self.program["show_outline"].value = show_outline
        self.program["outline_scale"].value = float(self.settings.outline_width)

        ambient = self.renderer._normalized_weight(self.settings.ambient)
        diffuse = self.renderer._normalized_weight(self.settings.diffuse)
        rim = self.renderer._normalized_weight(self.settings.rim)
        specular = self.renderer._normalized_weight(self.settings.specular)

        self.program["ambient"].value = float(ambient)
        self.program["diffuse"].value = float(diffuse)
        self.program["rim_weight"].value = float(rim)
        self.program["specular"].value = float(specular)
        self.program["shininess"].value = float(self.settings.shininess)
        self.program["hatch_scale"].value = float(self.settings.hatch_scale)
        self.program["hatch_repeat"].value = (
            float(self.settings.hatch_repeat[0]),
            float(self.settings.hatch_repeat[1]),
        )
        self.program["invert_rim"].value = bool(self.settings.invert_rim)
        self.program["solid_render"].value = bool(self.settings.solid_render)

    def _apply_imgui_style(self) -> None:
        """Apply a dark brown paper style to ImGui windows."""
        ui = self._imgui
        style = ui.get_style()

        # Dark brown color palette (classroom paper but darker)
        bg_dark = (0.25, 0.18, 0.12, 0.95)       # Dark brown background
        bg_mid = (0.32, 0.24, 0.16, 1.0)         # Medium brown for headers
        bg_light = (0.40, 0.30, 0.20, 1.0)       # Lighter brown for hover
        accent = (0.55, 0.40, 0.25, 1.0)         # Warm accent for active
        text = (0.95, 0.92, 0.85, 1.0)           # Cream text
        text_dim = (0.70, 0.65, 0.55, 1.0)       # Dimmed text
        border = (0.45, 0.35, 0.25, 0.5)         # Subtle border

        # Window
        ui.push_style_color(ui.COLOR_WINDOW_BACKGROUND, *bg_dark)
        ui.push_style_color(ui.COLOR_TITLE_BACKGROUND, *bg_mid)
        ui.push_style_color(ui.COLOR_TITLE_BACKGROUND_ACTIVE, *accent)
        ui.push_style_color(ui.COLOR_BORDER, *border)

        # Text
        ui.push_style_color(ui.COLOR_TEXT, *text)
        ui.push_style_color(ui.COLOR_TEXT_DISABLED, *text_dim)

        # Buttons
        ui.push_style_color(ui.COLOR_BUTTON, *bg_mid)
        ui.push_style_color(ui.COLOR_BUTTON_HOVERED, *bg_light)
        ui.push_style_color(ui.COLOR_BUTTON_ACTIVE, *accent)

        # Frame (input fields, sliders)
        ui.push_style_color(ui.COLOR_FRAME_BACKGROUND, 0.20, 0.14, 0.10, 1.0)
        ui.push_style_color(ui.COLOR_FRAME_BACKGROUND_HOVERED, *bg_mid)
        ui.push_style_color(ui.COLOR_FRAME_BACKGROUND_ACTIVE, *bg_light)

        # Slider
        ui.push_style_color(ui.COLOR_SLIDER_GRAB, *accent)
        ui.push_style_color(ui.COLOR_SLIDER_GRAB_ACTIVE, 0.65, 0.50, 0.35, 1.0)

        # Checkbox
        ui.push_style_color(ui.COLOR_CHECK_MARK, *text)

        # Header (collapsing headers, combo boxes)
        ui.push_style_color(ui.COLOR_HEADER, *bg_mid)
        ui.push_style_color(ui.COLOR_HEADER_HOVERED, *bg_light)
        ui.push_style_color(ui.COLOR_HEADER_ACTIVE, *accent)

        # Popup
        ui.push_style_color(ui.COLOR_POPUP_BACKGROUND, *bg_dark)

        # Rounding
        style.window_rounding = 6.0
        style.frame_rounding = 4.0
        style.grab_rounding = 4.0

    def _render_imgui(self) -> None:
        """Render the ImGui control panel."""
        ui = self._imgui
        ui.new_frame()

        # Show hamburger menu button when controls are hidden
        if not self.controls_visible:
            ui.set_next_window_position(10, 10, ui.ALWAYS)
            ui.set_next_window_size(32, 32, ui.ALWAYS)
            ui.push_style_var(ui.STYLE_WINDOW_PADDING, (4, 4))
            ui.push_style_color(ui.COLOR_WINDOW_BACKGROUND, 0.0, 0.0, 0.0, 0.0)
            ui.begin(
                "##hamburger",
                flags=ui.WINDOW_NO_TITLE_BAR | ui.WINDOW_NO_RESIZE | ui.WINDOW_NO_MOVE
            )
            # Invisible button for click detection
            clicked = ui.invisible_button("##menu_btn", 24, 24)
            # Draw three horizontal lines manually
            draw_list = ui.get_window_draw_list()
            px, py = ui.get_item_rect_min()
            line_color = ui.get_color_u32_rgba(0.2, 0.2, 0.2, 1.0)
            for i in range(3):
                y = py + 6 + i * 6
                draw_list.add_line(px + 4, y, px + 20, y, line_color, 2.0)
            if clicked:
                self.controls_visible = True
            ui.end()
            ui.pop_style_color()
            ui.pop_style_var()
            ui.render()
            self.imgui_renderer.render(ui.get_draw_data())
            return

        ui.set_next_window_position(10, 10, ui.ONCE)
        ui.set_next_window_size(320, 340, ui.ONCE)

        expanded, opened = ui.begin("Controls", True)
        if not opened:
            self.controls_visible = False
            ui.end()
            ui.render()
            self.imgui_renderer.render(ui.get_draw_data())
            return

        # Background preset dropdown
        ui.text("Background Preset:")
        presets = list(CrossHatchTextures.PRESETS.keys())
        current_idx = presets.index(self.current_preset) if self.current_preset in presets else 0

        changed, new_idx = ui.combo("##preset", current_idx, presets)
        if changed:
            self.current_preset = presets[new_idx]
            self.textures.set_preset(self.assets_dir, self.current_preset)
            self._update_paper_texture()

        ui.spacing()
        ui.separator()
        ui.spacing()

        # Atom radius slider (display as percentage 0-100, actual range 0.1-0.5)
        ui.text("Atom Radius (%):")
        # Convert actual scale (0.1-0.5) to percentage (0-100)
        radius_percentage = ((self.renderer.radius_scale - 0.1) / (0.5 - 0.1)) * 100.0
        changed, new_percentage = ui.slider_float(
            "##radius_percentage",
            radius_percentage,
            0.0,
            100.0,
            "%.0f%%"
        )
        if changed:
            # Convert percentage back to actual scale (0.1-0.5)
            self.renderer.radius_scale = 0.1 + (new_percentage / 100.0) * (0.5 - 0.1)

        ui.spacing()
        ui.separator()
        ui.spacing()

        # Element labels
        label_changed, self.settings.show_symbols = ui.checkbox("Show Element Labels", self.settings.show_symbols)
        if label_changed:
            if self.settings.show_symbols and not hasattr(self, 'label_vaos'):
                self._create_label_textures()
                self._create_label_geometry()
            elif not self.settings.show_symbols and hasattr(self, 'label_vaos'):
                self._destroy_labels()

        if self.settings.show_symbols:
            label_sizes = ["small", "medium", "large"]
            current_idx = label_sizes.index(self.settings.label_size) if self.settings.label_size in label_sizes else 0
            size_changed, new_idx = ui.combo("##labelsize", current_idx, label_sizes)
            if size_changed:
                self.settings.label_size = label_sizes[new_idx]
                # Recreate labels with new size
                self._destroy_labels()
                self._create_label_textures()
                self._create_label_geometry()

        ui.spacing()
        ui.separator()
        ui.spacing()

        # Export filename
        ui.text("Export Filename:")
        changed, self.export_filename = ui.input_text("##filename", self.export_filename, 256)

        ui.spacing()

        # Export buttons
        if ui.button("Export PNG", width=295):
            self._export_png()

        if ui.button("Export PDF (Vector)", width=295):
            self._export_pdf()

        ui.end()
        ui.render()
        self.imgui_renderer.render(ui.get_draw_data())

    def _export_png(self) -> None:
        """Export current view as PNG."""
        filename = self.export_filename if self.export_filename.endswith('.png') else f"{self.export_filename}.png"
        img = self.renderer.render(self.symbols, self.coords, self.bonds)
        try:
            img.save(filename)
            print(f"Saved PNG to {filename}")
        except Exception as exc:
            print(f"Error saving PNG: {exc}", file=sys.stderr)

    def _export_pdf(self) -> None:
        """Export current view as PDF using the CPU renderer (same quality as PNG export)."""
        filename = self.export_filename if self.export_filename.endswith('.pdf') else f"{self.export_filename}.pdf"

        # Use the CPU renderer to get the cross-hatched image
        img = self.renderer.render(self.symbols, self.coords, self.bonds)

        try:
            # Convert PIL Image to PDF
            img.save(filename, "PDF", resolution=100.0)
            print(f"Saved PDF to {filename}")
        except Exception as exc:
            print(f"Error saving PDF: {exc}", file=sys.stderr)

    def _update_paper_texture(self) -> None:
        """Update the OpenGL paper texture after changing presets."""
        if self.paper_texture is None:
            return

        paper = (self.textures.paper * 255.0).astype(np.uint8)
        paper_h, paper_w, _ = paper.shape

        # Delete old texture and create new one
        self.paper_texture.release()
        self.paper_texture = self.ctx.texture((paper_w, paper_h), 3, paper.tobytes())
        self.paper_texture.filter = (self.mgl.LINEAR, self.mgl.LINEAR)
        self.paper_texture.repeat_x = True
        self.paper_texture.repeat_y = True
        self.paper_texture.use(location=0)
        self.program["paper_tex"].value = 0
        self.program["paper_size"].value = (float(paper_w), float(paper_h))
        self.background_program["paper_tex"].value = 0
        self.background_program["paper_size"].value = (float(paper_w), float(paper_h))

    def _draw_frame(self) -> None:
        self.ctx.clear(0.0, 0.0, 0.0, 1.0)

        self.ctx.disable(self.mgl.DEPTH_TEST)
        self.paper_texture.use(location=0)
        self.background_vao.render(self.mgl.TRIANGLE_STRIP)

        self.ctx.enable(self.mgl.DEPTH_TEST)

        # Bind all textures BEFORE rendering
        self.paper_texture.use(location=0)
        for idx, texture in enumerate(self.hatch_textures, start=1):
            texture.use(location=idx)

        # Draw bonds first (lighter color: 0.7 instead of 0.4 for lighter appearance)
        # Bonds are automatically occluded by atoms drawn later due to depth testing
        if self.bond_vao is not None:
            rotation = self.renderer.rotation.matrix.astype(np.float32).T
            self.bond_program["rotation"].write(rotation.tobytes())
            self.bond_program["zoom"].value = float(self.renderer.zoom)
            self.bond_program["pan"].value = (float(self.renderer.pan[0]), float(self.renderer.pan[1]))
            self.bond_program["screen_size"].value = (float(self.renderer.width), float(self.renderer.height))

            # Lighter bond color (70% of ink color)
            ink_color = np.array(self.settings.ink_color, dtype=np.float32) / 255.0
            self.bond_program["bond_color"].value = tuple(float(c * 0.7) for c in ink_color)
            self.bond_vao.render(self.mgl.LINES)

        if self.settings.display_outline and self.settings.outline_width > 0.0:
            self.ctx.depth_mask = False
            self._update_uniforms(show_outline=True)
            self.quad_vao.render(self.mgl.TRIANGLE_STRIP, instances=len(self.symbols))

        self.ctx.depth_mask = True
        self._update_uniforms(show_outline=False)
        self.quad_vao.render(self.mgl.TRIANGLE_STRIP, instances=len(self.symbols))

        # Draw labels if enabled
        if self.settings.show_symbols and hasattr(self, 'label_vaos'):
            self.ctx.enable(self.mgl.BLEND)
            self.ctx.blend_func = self.mgl.SRC_ALPHA, self.mgl.ONE_MINUS_SRC_ALPHA

            rotation = self.renderer.rotation.matrix.astype(np.float32).T
            self.label_program["rotation"].write(rotation.tobytes())
            self.label_program["zoom"].value = float(self.renderer.zoom)
            self.label_program["base_zoom"].value = float(self.label_base_zoom)
            self.label_program["radius_scale"].value = float(self.renderer.radius_scale)
            self.label_program["pan"].value = (float(self.renderer.pan[0]), float(self.renderer.pan[1]))
            self.label_program["screen_size"].value = (float(self.renderer.width), float(self.renderer.height))

            for symbol, (vao, count) in self.label_vaos.items():
                self.label_textures[symbol].use(location=7)
                self.label_program["label_tex"].value = 7
                vao.render(self.mgl.TRIANGLE_STRIP, instances=count)

            self.ctx.disable(self.mgl.BLEND)

        # Render ImGui on top
        self._render_imgui()

    def run(self) -> int:
        if not self.glfw.init():
            print("Failed to initialize GLFW", file=sys.stderr)
            return 1

        self.glfw.window_hint(self.glfw.CONTEXT_VERSION_MAJOR, 3)
        self.glfw.window_hint(self.glfw.CONTEXT_VERSION_MINOR, 3)
        self.glfw.window_hint(self.glfw.OPENGL_PROFILE, self.glfw.OPENGL_CORE_PROFILE)
        if sys.platform == "darwin":  # pragma: no cover - macOS specific
            self.glfw.window_hint(self.glfw.OPENGL_FORWARD_COMPAT, self.glfw.TRUE)

        self.window = self.glfw.create_window(
            int(self.renderer.width),
            int(self.renderer.height),
            "SketchMol",
            None,
            None,
        )
        if not self.window:
            self.glfw.terminate()
            print("Could not create GLFW window (check OpenGL 3.3 support)", file=sys.stderr)
            return 1

        self.glfw.make_context_current(self.window)
        self.ctx = self.mgl.create_context()
        self.ctx.enable(self.mgl.DEPTH_TEST)

        # Initialize ImGui
        self.imgui_context = self._imgui.create_context()

        # Load a font with unicode support
        io = self._imgui.get_io()
        font_paths = [
            "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
            "/usr/share/fonts/TTF/DejaVuSans.ttf",
            "/System/Library/Fonts/Helvetica.ttc",
        ]
        for font_path in font_paths:
            if os.path.exists(font_path):
                io.fonts.add_font_from_file_ttf(font_path, 16.0)
                break

        self.imgui_renderer = self._GlfwRenderer(self.window)

        # Apply dark brown paper style to ImGui
        self._apply_imgui_style()

        fb_width, fb_height = self.glfw.get_framebuffer_size(self.window)
        self._on_framebuffer_size(self.window, fb_width, fb_height)

        self._compile_shaders()
        self._create_vertex_arrays()
        self._create_textures()

        # Initialize labels if enabled from command line
        if self.settings.show_symbols:
            self._create_label_textures()
            self._create_label_geometry()

        self.glfw.set_framebuffer_size_callback(self.window, self._on_framebuffer_size)
        self.glfw.set_mouse_button_callback(self.window, self._on_mouse_button)
        self.glfw.set_cursor_pos_callback(self.window, self._on_mouse_move)
        self.glfw.set_scroll_callback(self.window, self._on_scroll)
        self.glfw.swap_interval(1)

        print(
            "Controls:\n"
            "  Keyboard: arrows rotate, WASD pan, +/- zoom, Z axis toggle, R reset, F1-F3 auto-rotate, Q/Esc quit\n"
            "  Mouse: left-drag rotate, right-drag pan, scroll wheel zoom",
            file=sys.stderr,
        )

        self._last_time = self.glfw.get_time()
        try:
            while not self.glfw.window_should_close(self.window):
                self.glfw.poll_events()
                self.imgui_renderer.process_inputs()
                self._poll_keyboard()

                current = self.glfw.get_time()
                delta = max(1e-6, current - self._last_time)
                self._last_time = current
                self._apply_auto_rotation(delta)
                self._draw_frame()
                self.glfw.swap_buffers(self.window)
        finally:
            if self.imgui_renderer:
                self.imgui_renderer.shutdown()
            self.glfw.terminate()

        return 0


def build_arg_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(
        description="SketchMol - render molecules with pen-and-ink cross-hatching"
    )
    parser.add_argument("input", help="Input molecule (PDB file, XYZ file, or SMILES string)")
    parser.add_argument(
        "--render",
        action="store_true",
        help="Render to file instead of launching interactive viewer",
    )
    parser.add_argument("--output", "-o", default="molecule.png", help="Output file for --render mode")
    parser.add_argument("--width", type=int, default=800, help="Window/output width in pixels")
    parser.add_argument("--height", type=int, default=600, help="Window/output height in pixels")
    parser.add_argument("--assets", default=None, help="Directory with hatch textures")
    parser.add_argument("--paper", default="brown.jpg", help="Paper texture (file name inside assets dir)")
    parser.add_argument("--ink", default="41,41,202", help="Ink color as R,G,B")
    parser.add_argument("--ambient", type=float, default=13.0, help="Ambient contribution weight")
    parser.add_argument("--diffuse", type=float, default=27.0, help="Diffuse contribution weight")
    parser.add_argument("--rim", type=float, default=76.0, help="Rim contribution weight")
    parser.add_argument("--specular", type=float, default=100.0, help="Specular contribution weight")
    parser.add_argument("--shininess", type=float, default=27.0, help="Specular shininess")
    parser.add_argument("--invert-rim", action="store_true", help="Invert rim term")
    parser.add_argument("--hatch-scale", type=float, default=1.0, help="Frequency scale for hatch textures")
    parser.add_argument("--hatch-repeat", default="4.0,4.0", help="U,V repeat factors for hatching (e.g. 4,4)")
    parser.add_argument("--no-outline", action="store_true", help="Disable outline around atoms")
    parser.add_argument("--solid-render", action="store_true", help="Disable hatching and render solid shading")
    parser.add_argument("--outline-width", type=float, default=0.05, help="Outline thickness as a fraction of radius")
    parser.add_argument("--light", default=None, help="Custom light direction as x,y,z")
    parser.add_argument("--radius-scale", type=float, default=0.15, help="Scale factor for atom radii")
    parser.add_argument("--rotate-x", type=float, default=0.0, help="Initial rotation around X (radians)")
    parser.add_argument("--rotate-y", type=float, default=0.0, help="Initial rotation around Y (radians)")
    parser.add_argument("--rotate-z", type=float, default=0.0, help="Initial rotation around Z (radians)")
    parser.add_argument(
        "--cpk-colors",
        action="store_true",
        help="Use CPK (Corey-Pauling-Koltun) colors for atoms instead of single ink color",
    )
    parser.add_argument(
        "--show-symbols",
        action="store_true",
        help="Show element labels next to atoms",
    )
    parser.add_argument(
        "--label-size",
        choices=["small", "medium", "large"],
        default="small",
        help="Size of element labels (default: small)",
    )
    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
    return parser


def resolve_assets_dir(provided: Optional[str]) -> str:
    if provided:
        return provided
    script_dir = os.path.dirname(os.path.abspath(__file__))

    # Try multiple possible locations
    candidates = [
        os.path.join(script_dir, "cross-hatching", "assets"),
        os.path.join(script_dir, "exclude", "cross-hatching", "assets"),
        os.path.join(script_dir, "assets"),
    ]

    for candidate in candidates:
        if os.path.isdir(candidate):
            return candidate

    raise FileNotFoundError("Could not locate cross-hatching assets directory; pass --assets explicitly")


def parse_color(value: str) -> Tuple[int, int, int]:
    parts = value.split(",")
    if len(parts) != 3:
        raise ValueError("Ink color must be in R,G,B format")
    return tuple(int(p) for p in parts)


def parse_vector(value: str, length: int, name: str) -> Tuple[float, ...]:
    parts = value.split(",")
    if len(parts) != length:
        raise ValueError(f"{name} must have {length} comma-separated values")
    try:
        return tuple(float(p) for p in parts)
    except ValueError as exc:  # pragma: no cover - simple validation
        raise ValueError(f"{name} components must be numeric") from exc


def load_molecule(path_or_smiles: str) -> Tuple[List[str], np.ndarray, Optional[List[Tuple[int, int]]]]:
    symbols, coords, bonds = None, None, None
    if os.path.isfile(path_or_smiles):
        # Try parsing as XYZ first if extension is .xyz
        if path_or_smiles.lower().endswith('.xyz'):
            symbols, coords, bonds = MoleculeParser.parse_xyz(path_or_smiles)
        else:
            # Try PDB format
            symbols, coords, bonds = MoleculeParser.parse_pdb(path_or_smiles)

        # If parsing failed, try reading as SMILES string from file
        if symbols is None:
            with open(path_or_smiles, "r", encoding="utf-8") as handle:
                smiles = handle.read().strip().split()[0]
                symbols, coords, bonds = MoleculeParser.parse_smiles(smiles)
    else:
        symbols, coords, bonds = MoleculeParser.parse_smiles(path_or_smiles)

    if symbols is None or coords is None:
        raise ValueError(f"Failed to parse molecule from '{path_or_smiles}'")
    return symbols, coords, bonds


def main(argv: Optional[List[str]] = None) -> int:
    parser = build_arg_parser()
    args = parser.parse_args(argv)

    try:
        ink_color = parse_color(args.ink)
    except ValueError as exc:
        print(f"Error parsing ink color: {exc}", file=sys.stderr)
        return 1

    try:
        symbols, coords, bonds = load_molecule(args.input)
    except Exception as exc:  # pylint: disable=broad-except
        print(f"Error loading molecule: {exc}", file=sys.stderr)
        return 1

    try:
        assets_dir = resolve_assets_dir(args.assets)
        # Default to "Classroom (Brown Paper)" preset if no paper override specified
        textures = CrossHatchTextures(
            assets_dir,
            paper_override=args.paper,
            preset="Classroom (Brown Paper)" if not args.paper else None
        )
    except Exception as exc:  # pylint: disable=broad-except
        print(f"Error loading textures: {exc}", file=sys.stderr)
        return 1

    hatch_repeat = (
        parse_vector(args.hatch_repeat, 2, "hatch-repeat") if args.hatch_repeat else (1.0, 1.0)
    )
    light_direction = (
        parse_vector(args.light, 3, "light") if args.light else CrossHatchSettings().light_direction
    )

    settings = CrossHatchSettings(
        ambient=args.ambient,
        diffuse=args.diffuse,
        rim=args.rim,
        specular=args.specular,
        shininess=args.shininess,
        invert_rim=args.invert_rim,
        solid_render=args.solid_render,
        display_outline=not args.no_outline,
        outline_width=args.outline_width,
        ink_color=ink_color,
        light_direction=light_direction,
        hatch_scale=args.hatch_scale,
        hatch_repeat=hatch_repeat,
        paper_path=args.paper or "placeholder.jpg",
        use_cpk_colors=args.cpk_colors,
        show_symbols=args.show_symbols,
        label_size=args.label_size,
    )

    renderer = CrossHatchRenderer(args.width, args.height, textures, settings)
    renderer.radius_scale = args.radius_scale
    if args.rotate_x:
        renderer.rotation.rotate_x(args.rotate_x)
    if args.rotate_y:
        renderer.rotation.rotate_y(args.rotate_y)
    if args.rotate_z:
        renderer.rotation.rotate_z(args.rotate_z)

    if args.render:
        # Batch render mode
        img = renderer.render(symbols, coords, bonds)
        try:
            img.save(args.output)
        except OSError as exc:
            print(f"Failed to save image: {exc}", file=sys.stderr)
            return 1
        print(f"Saved rendering to {args.output}")
        return 0

    # Interactive mode (default)
    try:
        viewer = CrossHatchOpenGLViewer(symbols, coords, renderer, textures, settings, assets_dir, bonds)
    except RuntimeError as exc:
        print(f"Interactive viewer unavailable: {exc}", file=sys.stderr)
        return 1
    return viewer.run()


if __name__ == "__main__":
    raise SystemExit(main())