"""lyra digit links: finger phalanges and the thumb column.

Local frames (see lib.py):
- Finger phalanges: origin at the proximal joint center, +Z distal along
  the segment, +Y palmar, flexion axis -X.
- Thumb segments: origin at the proximal joint center, +X distal along the
  column, +Z palmar pad direction, flexion axis -Y (the thumb_base yaw
  turret tang spins about +Z).

Each phalanx is a pearl composite shell TUBE over an exposed graphite
structural spine: graphite tang barrel -> center spine bar -> fork
crossbar -> clevis cheeks, one connected solid, with the spine visible at
both joint ends (the "visible precision joints" design language). The
soft-touch tactile strip rides the tube's palmar face.

Articulation-safety rules (hold for every joint at any angle in range):
- Full-width child geometry (the shell tube) starts beyond parent lobe
  radius + 0.4 from the joint axis; only the circular tang barrel and the
  narrow center spine (which never shares an x/y band with the parent
  cheeks, and stays clear of the pin bore radius) sit closer.
- Fork crossbars sit >= 9 mm proximal of their own joint axis, outside the
  +/-43 deg corner sweep of the child spine at full flexion.

Joint hardware ownership: the parent link owns clevis cheeks, aluminum rim
washers, and the pivot pin; the child owns the bored tang barrel.
"""

from __future__ import annotations

from build123d import Axis, Box, Cone, Pos, Rot, Sphere

from .chain import (
    SEGMENT_MM,
    THUMB_METACARPAL_LEN_MM,
    THUMB_PROXIMAL_LEN_MM,
    THUMB_BASE_LEN_MM,
)
from .lib import (
    ALU_COLOR,
    GRAPHITE_COLOR,
    PAD_COLOR,
    PEARL_COLOR,
    part_compound,
    pin,
    safe_chamfer,
    safe_fillet,
    styled,
    xcyl,
    ycyl,
    zcyl,
)

# Per-finger width scale (lengths come from chain.SEGMENT_MM).
FINGER_SCALE = {"index": 1.0, "middle": 1.03, "ring": 0.97, "pinky": 0.88}

# Knuckle hardware (mm at scale 1). Tang widths match the parent fork gap
# minus 0.6 clearance; bores give the parent-owned pin a 0.4 running fit.
PALM_LOBE_R = 8.0          # palm knuckle lobe radius (palm.py uses this too)
PROX_TANG_R, PROX_TANG_W, PROX_BORE_R = 7.2, 10.4, 3.0
PROX_FORK_GAP, PROX_CHEEK_T, PROX_LOBE_R = 9.6, 2.6, 6.5
PROX_PIN_R, PROX_RIM_R = 2.4, 4.4
MID_TANG_R, MID_TANG_W, MID_BORE_R = 6.4, 9.0, 2.8
MID_FORK_GAP, MID_CHEEK_T, MID_LOBE_R = 8.4, 2.4, 5.8
MID_PIN_R, MID_RIM_R = 2.1, 3.8
DIST_TANG_R, DIST_TANG_W, DIST_BORE_R = 5.6, 7.8, 2.5

MCP_PIN_R = 2.6            # palm-owned; phalanx bore must clear it
RIM_T = 1.2


def _bored_xbarrel(r, w, bore_r):
    return xcyl(r, w) - xcyl(bore_r, w + 4.0)


def _bored_ybarrel(r, w, bore_r):
    return ycyl(r, w) - ycyl(bore_r, w + 4.0)


def _finger_fork(z, gap, cheek_t, lobe_r, pin_r, rim_r, body_d):
    """Distal clevis of a finger phalanx: cheeks + lobes (one solid, bored),
    rim washers, and the pivot pin."""
    half = gap / 2.0
    fork = None
    for sx in (1.0, -1.0):
        xc = sx * (half + cheek_t / 2.0)
        plate = Pos(xc, 0.2, z - 6.0) * Box(cheek_t, body_d, 12.0)
        lobe = Pos(xc, 0, z) * xcyl(lobe_r, cheek_t)
        cheek = plate + lobe
        fork = cheek if fork is None else fork + cheek
    fork = safe_chamfer(
        fork, [e for e in fork.edges().filter_by(Axis.X)], 0.8
    )
    fork -= Pos(0, 0, z) * xcyl(pin_r + 0.4, gap + 2 * cheek_t + 8.0)
    rims = []
    for sx in (1.0, -1.0):
        xr = sx * (half + cheek_t + RIM_T / 2.0)
        rim = Pos(xr, 0, z) * (
            xcyl(rim_r, RIM_T) - xcyl(pin_r + 0.4, RIM_T + 2.0)
        )
        rims.append(rim)
    pin_len = gap + 2 * cheek_t + 2 * RIM_T + 1.2
    pivot = Pos(0, 0, z) * pin("x", pin_r, pin_len)
    return fork, rims, pivot


def _finger_phalanx(
    label_prefix,
    pin_name,
    s,
    length,
    tang_r,
    tang_w,
    bore_r,
    fork_gap,
    cheek_t,
    lobe_r,
    pin_r,
    rim_r,
    parent_lobe_r,
    body_w,
    body_d,
    y_shift,
):
    """Pearl shell tube over an exposed graphite spine, plus fork hardware."""
    tube_z0 = parent_lobe_r + 0.4
    tube_z1 = length - 13.2 * s
    bar_w = 6.5 * s
    chan_w = bar_w + 0.5

    # Graphite spine: tang barrel + center bar + fork crossbar + clevis.
    core = _bored_xbarrel(tang_r, tang_w, bore_r)
    bar = Pos(0, y_shift, (4.5 * s + length - 9.0 * s) / 2.0) * Box(
        bar_w, bar_w, length - 9.0 * s - 4.5 * s
    )
    core += bar
    crossbar = Pos(0, 0.2, length - 11.0 * s) * Box(
        fork_gap + 2 * cheek_t, bar_w, 4.0 * s
    )
    core += crossbar
    fork, rims, pivot = _finger_fork(
        length, fork_gap, cheek_t, lobe_r, pin_r, rim_r, body_d
    )
    core += fork

    # Pearl composite shell tube around the spine.
    tube = Pos(0, y_shift, (tube_z0 + tube_z1) / 2.0) * Box(
        body_w, body_d, tube_z1 - tube_z0
    )
    tube = safe_fillet(tube, tube.edges().filter_by(Axis.Z), min(2.6, body_w / 4.5))
    tube -= Pos(0, y_shift, (tube_z0 + tube_z1) / 2.0) * Box(
        chan_w, chan_w, tube_z1 - tube_z0 + 4.0
    )
    tube = safe_chamfer(
        tube, [e for e in tube.edges().filter_by(Axis.X)], 0.7
    )

    # Soft-touch tactile strip on the palmar tube face.
    pad = Pos(0, y_shift + body_d / 2.0 + 0.5, (tube_z0 + tube_z1) / 2.0) * Box(
        body_w - 4.0 * s, 1.6, max((tube_z1 - tube_z0) * 0.72, 2.5)
    )
    pad = safe_fillet(pad, pad.edges().filter_by(Axis.Y), min(1.8 * s, 2.0))

    solids = [
        styled(core, f"{label_prefix}_spine", GRAPHITE_COLOR),
        styled(tube, f"{label_prefix}_shell", PEARL_COLOR),
        styled(pad, f"{label_prefix}_pad", PAD_COLOR),
        styled(pivot, f"{pin_name}_pin", ALU_COLOR),
    ]
    for i, rim in enumerate(rims):
        solids.append(styled(rim, f"{pin_name}_rim_{i}", ALU_COLOR))
    return solids


def build_finger_proximal(finger: str):
    s = FINGER_SCALE[finger]
    solids = _finger_phalanx(
        f"{finger}_proximal", f"{finger}_pip", s, SEGMENT_MM[finger][0],
        PROX_TANG_R * s, PROX_TANG_W * s, PROX_BORE_R * s,
        PROX_FORK_GAP * s, PROX_CHEEK_T * s, PROX_LOBE_R * s,
        PROX_PIN_R * s, PROX_RIM_R * s, PALM_LOBE_R * s,
        13.4 * s, 11.4 * s, 0.7 * s,
    )
    return part_compound(f"{finger}_proximal", solids)


def build_finger_middle(finger: str):
    s = FINGER_SCALE[finger]
    solids = _finger_phalanx(
        f"{finger}_middle", f"{finger}_dip", s, SEGMENT_MM[finger][1],
        MID_TANG_R * s, MID_TANG_W * s, MID_BORE_R * s,
        MID_FORK_GAP * s, MID_CHEEK_T * s, MID_LOBE_R * s,
        MID_PIN_R * s, MID_RIM_R * s, PROX_LOBE_R * s,
        12.2 * s, 10.6 * s, 0.6 * s,
    )
    return part_compound(f"{finger}_middle", solids)


def build_finger_distal(finger: str):
    s = FINGER_SCALE[finger]
    length = SEGMENT_MM[finger][2]
    tip_r = 4.4 * s
    cone_z0 = MID_LOBE_R * s + 0.4
    tip_c = length - tip_r

    # Tang + connection collar (graphite, one solid). The collar is
    # center-band only, so it clears the parent pin bore and never shares
    # an x band with the parent cheeks.
    tang = _bored_xbarrel(DIST_TANG_R * s, DIST_TANG_W * s, DIST_BORE_R * s)
    collar_r = 4.0 * s
    collar_len = cone_z0 + 0.5 - 4.4
    tang += Pos(0, 0.4 * s, 4.4 + collar_len / 2.0) * zcyl(collar_r, collar_len)

    cone_h = tip_c - cone_z0
    body = Pos(0, 0.4 * s, cone_z0 + cone_h / 2.0) * Cone(
        bottom_radius=5.3 * s, top_radius=tip_r, height=cone_h
    )
    body += Pos(0, 0.4 * s, tip_c) * Sphere(tip_r)
    # Seat the pearl body on the collar shoulder (face contact, no overlap).
    body -= Pos(0, 0.4 * s, (cone_z0 + 0.5) / 2.0) * zcyl(collar_r + 0.05, cone_z0 + 0.5)

    # Soft-touch fingertip pad: split a palmar cap off the body with a
    # boolean sphere so the seam is face-to-face with no overlap.
    # Palmar-only soft cap: the zone center sits palmar of the tip sphere so
    # the apex and dorsal face stay pearl.
    pad = None
    try:
        zone = Pos(0, 3.6 * s, tip_c + 0.2) * Sphere(4.7 * s)
        cap = body & zone
        if cap.volume > 1.0:
            body = body - zone
            pad = cap
    except Exception:
        pad = None

    solids = [
        styled(tang, f"{finger}_distal_tang", GRAPHITE_COLOR),
        styled(body, f"{finger}_distal_body", PEARL_COLOR),
    ]
    if pad is not None:
        solids.append(styled(pad, f"{finger}_tip_pad", PAD_COLOR))
    return part_compound(f"{finger}_distal", solids)


# ----------------------------------------------------------------- thumb

T_PROX_LOBE_R = 7.0    # thumb_base flex-fork lobe radius (palm relief uses it)
TB_TANG_R, TB_TANG_H, TB_BORE_R = 8.8, 9.5, 3.3
TM_TANG_R, TM_TANG_W, TM_BORE_R = 6.8, 9.8, 2.9
TM_FORK_GAP, TM_CHEEK_T, TM_LOBE_R = 9.8, 2.5, 6.4
TM_PIN_R, TM_RIM_R = 2.3, 4.2
TP_TANG_R, TP_TANG_W, TP_BORE_R = 6.2, 9.2, 2.7
TP_FORK_GAP, TP_CHEEK_T, TP_LOBE_R = 8.6, 2.4, 5.6
TP_PIN_R, TP_RIM_R = 2.1, 3.7
TD_TANG_R, TD_TANG_W, TD_BORE_R = 5.2, 8.0, 2.5
THUMB_TIP_R = 4.8
THUMB_TIP_TOTAL_MM = 24.0  # matches chain.THUMB_TIP_LEN_MM


def _thumb_fork(x, gap, cheek_t, lobe_r, pin_r, rim_r, body_d):
    """Distal clevis of a thumb segment: cheeks normal to Y."""
    half = gap / 2.0
    fork = None
    for sy in (1.0, -1.0):
        yc = sy * (half + cheek_t / 2.0)
        plate = Pos(x - 6.0, yc, 0.2) * Box(12.0, cheek_t, body_d)
        lobe = Pos(x, yc, 0) * ycyl(lobe_r, cheek_t)
        cheek = plate + lobe
        fork = cheek if fork is None else fork + cheek
    fork = safe_chamfer(
        fork, [e for e in fork.edges().filter_by(Axis.Y)], 0.8
    )
    fork -= Pos(x, 0, 0) * ycyl(pin_r + 0.4, gap + 2 * cheek_t + 8.0)
    rims = []
    for sy in (1.0, -1.0):
        yr = sy * (half + cheek_t + RIM_T / 2.0)
        rim = Pos(x, yr, 0) * (
            ycyl(rim_r, RIM_T) - ycyl(pin_r + 0.4, RIM_T + 2.0)
        )
        rims.append(rim)
    pin_len = gap + 2 * cheek_t + 2 * RIM_T + 1.2
    pivot = Pos(x, 0, 0) * pin("y", pin_r, pin_len)
    return fork, rims, pivot


def _thumb_phalanx(
    label_prefix,
    pin_name,
    length,
    tang_r,
    tang_w,
    bore_r,
    fork_gap,
    cheek_t,
    lobe_r,
    pin_r,
    rim_r,
    parent_lobe_r,
    body_w,
    body_d,
    z_shift,
):
    """Thumb segment along +X: pearl tube over graphite spine, Y-axis forks."""
    tube_x0 = parent_lobe_r + 0.4
    tube_x1 = length - 13.2
    bar_w = 6.5
    chan_w = bar_w + 0.5

    core = _bored_ybarrel(tang_r, tang_w, bore_r)
    bar = Pos((4.5 + length - 9.0) / 2.0, 0, z_shift) * Box(
        length - 9.0 - 4.5, bar_w, bar_w
    )
    core += bar
    # Fork cheeks are stacked in Y, so the crossbar spans the Y width.
    crossbar = Pos(length - 11.0, 0, 0.2) * Box(4.0, fork_gap + 2 * cheek_t, bar_w)
    core += crossbar
    fork, rims, pivot = _thumb_fork(
        length, fork_gap, cheek_t, lobe_r, pin_r, rim_r, body_d
    )
    core += fork

    tube = Pos((tube_x0 + tube_x1) / 2.0, 0, z_shift) * Box(
        tube_x1 - tube_x0, body_w, body_d
    )
    tube = safe_fillet(tube, tube.edges().filter_by(Axis.X), min(2.6, body_w / 4.5))
    tube -= Pos((tube_x0 + tube_x1) / 2.0, 0, z_shift) * Box(
        tube_x1 - tube_x0 + 4.0, chan_w, chan_w
    )
    tube = safe_chamfer(
        tube, [e for e in tube.edges().filter_by(Axis.Y)], 0.7
    )

    pad = Pos((tube_x0 + tube_x1) / 2.0, 0, z_shift + body_d / 2.0 + 0.5) * Box(
        max((tube_x1 - tube_x0) * 0.72, 2.5), body_w - 4.0, 1.6
    )
    pad = safe_fillet(pad, pad.edges().filter_by(Axis.Z), 1.8)

    solids = [
        styled(core, f"{label_prefix}_spine", GRAPHITE_COLOR),
        styled(tube, f"{label_prefix}_shell", PEARL_COLOR),
        styled(pad, f"{label_prefix}_pad", PAD_COLOR),
        styled(pivot, f"{pin_name}_pin", ALU_COLOR),
    ]
    for i, rim in enumerate(rims):
        solids.append(styled(rim, f"{pin_name}_rim_{i}", ALU_COLOR))
    return solids


def build_thumb_base():
    """CMC turret tang (spins about +Z on the palm spindle) + flex clevis."""
    disc = zcyl(TB_TANG_R, TB_TANG_H) - zcyl(TB_BORE_R, TB_TANG_H + 4.0)
    disc = safe_chamfer(disc, disc.edges(), 0.8)
    neck = Pos(8.6, 0, 0) * Box(8.6, 12.6, 9.0)
    neck = safe_fillet(neck, neck.edges().filter_by(Axis.Z), 2.0)
    core = disc + neck
    fork, rims, pivot = _thumb_fork(
        THUMB_BASE_LEN_MM, TM_TANG_W + 0.6, 2.6, T_PROX_LOBE_R, 2.5, 4.5, 11.0
    )
    core += fork
    solids = [
        styled(core, "thumb_base_link", GRAPHITE_COLOR),
        styled(pivot, "thumb_cmc_flex_pin", ALU_COLOR),
    ]
    for i, rim in enumerate(rims):
        solids.append(styled(rim, f"thumb_cmc_flex_rim_{i}", ALU_COLOR))
    return part_compound("thumb_base", solids)


def build_thumb_metacarpal():
    solids = _thumb_phalanx(
        "thumb_metacarpal", "thumb_mp", THUMB_METACARPAL_LEN_MM,
        TM_TANG_R, TM_TANG_W, TM_BORE_R,
        TM_FORK_GAP, TM_CHEEK_T, TM_LOBE_R, TM_PIN_R, TM_RIM_R,
        T_PROX_LOBE_R, 12.6, 13.0, 0.5,
    )
    return part_compound("thumb_metacarpal", solids)


def build_thumb_proximal():
    solids = _thumb_phalanx(
        "thumb_proximal", "thumb_ip", THUMB_PROXIMAL_LEN_MM,
        TP_TANG_R, TP_TANG_W, TP_BORE_R,
        TP_FORK_GAP, TP_CHEEK_T, TP_LOBE_R, TP_PIN_R, TP_RIM_R,
        TM_LOBE_R, 11.6, 11.8, 0.4,
    )
    return part_compound("thumb_proximal", solids)


def build_thumb_distal():
    length = THUMB_TIP_TOTAL_MM
    tip_r = THUMB_TIP_R
    cone_x0 = TP_LOBE_R + 0.4
    tip_c = length - tip_r

    tang = _bored_ybarrel(TD_TANG_R, TD_TANG_W, TD_BORE_R)
    collar_r = 4.0
    collar_len = cone_x0 + 0.5 - 4.4
    tang += Pos(4.4 + collar_len / 2.0, 0, 0.4) * xcyl(collar_r, collar_len)

    cone_h = tip_c - cone_x0
    body = Pos(cone_x0 + cone_h / 2.0, 0, 0.4) * Rot(0, 90, 0) * Cone(
        bottom_radius=5.4, top_radius=tip_r, height=cone_h
    )
    body += Pos(tip_c, 0, 0.4) * Sphere(tip_r)
    body -= Pos((cone_x0 + 0.5) / 2.0, 0, 0.4) * xcyl(collar_r + 0.05, cone_x0 + 0.5)

    pad = None
    try:
        zone = Pos(tip_c + 0.2, 0, 3.4) * Sphere(5.0)
        cap = body & zone
        if cap.volume > 1.0:
            body = body - zone
            pad = cap
    except Exception:
        pad = None

    solids = [
        styled(tang, "thumb_distal_tang", GRAPHITE_COLOR),
        styled(body, "thumb_distal_body", PEARL_COLOR),
    ]
    if pad is not None:
        solids.append(styled(pad, "thumb_tip_pad", PAD_COLOR))
    return part_compound("thumb_distal", solids)