/**
 * APEX 4.0 — Dossier Technique Maître
 * Single source of truth for all manufacturing specifications.
 * Every dimension in millimetres unless noted otherwise.
 */

// ── Panel thicknesses ────────────────────────────────────────────────
export const PANEL = {
  structure: 19,            // Côtés, dessus, fond, séparateurs, étagères
  reinforcement: 16,        // Renforts Forteresse
  back: 8,                  // Dos (panneau arrière)
  reinforcementWidth: 100,  // Largeur standard d'un renfort
};

// ── Reinforcement layout rules (Renforts Forteresse) ────────────────
export const REINFORCEMENT = {
  topBottomOffsetMm: 19,       // Renfort haut/bas à 19 mm
  thirdRequiredAboveHeightMm: 1500, // 3e renfort si armoire > 1.5 m
};

// ── Edge banding (Chants ABS) ────────────────────────────────────────
export const EDGE_BANDING = {
  abs: 2,                   // Chant ABS visible (2 mm)
  hidden: 0.5,              // Chant fin caché (0.5 mm)
  backPanelSides: 2,        // Dos: ABS sur 2 chants longs (haut + bas)
  topBottomSides: 2,        // Dessus/Fond: ABS faces avant ET arrière
  shelfSides: 1,            // Étagères: ABS face avant uniquement
};

// ── Groove for back panel (Rainure dos) ──────────────────────────────
export const GROOVE = {
  back: {
    width: 9,               // mm — largeur rainure
    depth: 10.5,            // mm — profondeur rainure
    axisFromPanelEdge: 16,  // mm — rainure à 16 mm du bord des côtés/fond/dessus
  },
};

/** Rainure dos — plans / CNC : même coupe que montant (vertical) vs dessus/fond/bandeau (horizontal). */
export const BACK_GROOVE_PLAN_VERTICAL_TYPES = ['cotes', 'fileur', 'cotesDoublage'];
export const BACK_GROOVE_PLAN_HORIZONTAL_TYPES = ['dessus', 'fond', 'bandeauHaut'];

/** @returns {'vertical' | 'horizontal' | null} */
export function getBackGroovePlanOrientation(elementType) {
  if (BACK_GROOVE_PLAN_VERTICAL_TYPES.includes(elementType)) return 'vertical';
  if (BACK_GROOVE_PLAN_HORIZONTAL_TYPES.includes(elementType)) return 'horizontal';
  return null;
}

/**
 * Séparateurs : plaqués contre le dos (sans rainure). Largeur = même entraxe profondeur que le montant,
 * diminuée du décalage d’axe et de la demi-largeur de rainure (côtés).
 * @param {number} carcassDepthMm — profondeur caisse / largeur en plan du panneau côté (mm)
 */
export function getSeparatorDepthMm(carcassDepthMm) {
  const d = Number(carcassDepthMm) || 0;
  return Math.round(d - GROOVE.back.axisFromPanelEdge - GROOVE.back.width / 2);
}

// ── Connectors (Häfele Ixconnect) ────────────────────────────────────
export const CONNECTORS = {
  // SC 8/60 — structural assembly (caisse: côtés ↔ dessus/fond)
  ixconnect: {
    model: 'SC 8/60',
    edgeHole: { diameter: 8, depth: 45 },    // mm — perçage en about
    faceHole: { diameter: 8, depth: 12 },     // mm — perçage en face
    /** Trou de serrage Inbus — face intérieure panneaux horizontaux (dessus/fond) uniquement */
    lockScrewInbus: {
      diameter: 6,
      depth: 9,
      /** mm — depuis le chant d’assemblage (axe du perçage Ø45), vers l’intérieur du panneau */
      offsetFromAssemblyEdgeMm: 25
    }
  },
  // SC 8/25 — finish panels (portes, finitions)
  ixconnectFinish: {
    model: 'SC 8/25',
    faceHole: { diameter: 8, depth: 12.5 },   // mm — face interne Ø8 × 12.5mm
    axes: { back: 30, front: 43 },             // mm — axes: 30mm (arrière) / 43mm (avant)
  },
  // Positioning per structural joint (axes mm depuis le bord avant de l’arête, le long de la profondeur)
  // — Arêtes d’extrémité (montants extérieurs): T → IX → T
  // — Jonctions internes (séparateurs): Ixconnect à l’axe médian profondeur, tourillons ±30 mm de cet axe
  jointPatternEdge: {
    tourillon1Axis: 20,
    ixconnectAxis: 50,
    tourillon2Axis: 80,
  },
  /** @deprecated use jointPatternEdge — alias pour compat. */
  jointPattern: {
    tourillon1Axis: 20,
    ixconnectAxis: 50,
    tourillon2Axis: 80,
  },
  /** Tourillons par rapport à l’axe Ixconnect sur jonction milieu (mm). */
  jointPatternMiddleTourillonOffsetFromIxMm: 30,
  tourillon: {
    diameter: 8,            // mm — Ø tourillon
    length: 30,             // mm — tourillon Ø8×30
  },
  tourillonDiameter: 8,     // mm — backward compat
};

/**
 * mm — depuis le bord physique panneau côté dos : axe rainure + largeur rainure (= fin utile côté dos, repère Ixconnect).
 * Évite chevauchement perçages / rainure dos sur dessus·fond.
 */
export function getBackGrooveInnerEndInsetFromBackEdgeMm() {
  return GROOVE.back.axisFromPanelEdge + GROOVE.back.width;
}

/**
 * Axes Ixconnect / tourillons le long de l’arête (profondeur caisse pour dessus·fond, largeur = profondeur pour côtés),
 * mesurés depuis le bord avant (face avant).
 * @param {'edge'|'middle'} variant — extrémité de caisse vs jonction entre modules (séparateur)
 * @param {{ horizontalPanel?: boolean }} [options] — si `horizontalPanel`, la profondeur utile exclut la zone rainure dos (16+9 mm depuis le bord arrière).
 */
export function getIxconnectJointPatternAlongDepthMm(depthMm, variant, options = {}) {
  const horizontalPanel = Boolean(options.horizontalPanel);
  const inset = horizontalPanel ? getBackGrooveInnerEndInsetFromBackEdgeMm() : 0;
  const d = Math.max(0, Number(depthMm) || 0);
  const dEff = horizontalPanel ? Math.max(0, d - inset) : d;
  const round1 = (v) => Math.round(v * 10) / 10;
  if (variant === 'edge') {
    const t1 = CONNECTORS.jointPatternEdge.tourillon1Axis;
    const ix = CONNECTORS.jointPatternEdge.ixconnectAxis;
    const t2 = CONNECTORS.jointPatternEdge.tourillon2Axis;
    if (!horizontalPanel || dEff <= 0) {
      return {
        role: 'edge',
        tourillon1Axis: t1,
        ixconnectAxis: ix,
        tourillon2Axis: t2
      };
    }
    if (dEff >= t2) {
      return {
        role: 'edge',
        tourillon1Axis: t1,
        ixconnectAxis: ix,
        tourillon2Axis: t2
      };
    }
    const s = dEff / t2;
    return {
      role: 'edge',
      tourillon1Axis: round1(t1 * s),
      ixconnectAxis: round1(ix * s),
      tourillon2Axis: round1(t2 * s)
    };
  }
  if (dEff <= 0) {
    return {
      role: 'middle',
      tourillon1Axis: 0,
      ixconnectAxis: 0,
      tourillon2Axis: 0
    };
  }
  const ixMid = round1(dEff / 2);
  const off = CONNECTORS.jointPatternMiddleTourillonOffsetFromIxMm;
  return {
    role: 'middle',
    tourillon1Axis: round1(Math.max(0, ixMid - off)),
    ixconnectAxis: ixMid,
    tourillon2Axis: round1(Math.min(dEff, ixMid + off))
  };
}

/**
 * Largeurs de colonnes (mm) pour placer les jonctions — ordre: modules API, puis blocks, puis config.modules.
 * Évite le cas « modules = [] » alors que `config.modules` contient les largeurs (une seule jonction / mauvais comptage).
 */
function getModuleWidthsForJunctions(modules = [], config = {}) {
  const fromArr = (arr) =>
    (Array.isArray(arr) ? arr : [])
      .map((m) => Number(m?.widthMm) || 0)
      .filter((v) => v > 0);
  let w = fromArr(modules);
  if (w.length === 0) w = fromArr(config.blocks);
  if (w.length === 0) w = fromArr(config.modules);
  return w;
}

/**
 * Positions X des jonctions verticales (côtés + séparateurs) sur un panneau horizontal — mm depuis le bord gauche.
 */
export function getJunctionAxesAcrossWidthMm(dimensionsWidthMm, modules = [], config = {}) {
  const maxW = Math.max(0, Number(dimensionsWidthMm) || 0);
  const mWidths = getModuleWidthsForJunctions(modules, config);
  if (mWidths.length > 0) {
    let acc = 0;
    const axes = [0];
    for (let i = 0; i < mWidths.length - 1; i++) {
      acc += mWidths[i];
      axes.push(Math.max(0, Math.min(maxW, acc)));
    }
    axes.push(maxW);
    const sorted = [...axes].sort((a, b) => a - b);
    const dedup = [];
    const eps = 0.5;
    for (const v of sorted) {
      if (dedup.length === 0 || Math.abs(v - dedup[dedup.length - 1]) > eps) {
        dedup.push(Math.round(v * 100) / 100);
      }
    }
    return dedup;
  }
  return [0, maxW];
}

// ── System 32 drilling ───────────────────────────────────────────────
export const SYSTEM32 = {
  firstHoleOffset: 51,      // mm — distance from panel top/bottom edge to first/last hole
  pitch: 32,                // mm — distance between consecutive holes
  holeDiameter: 5,          // mm — Ø 5 mm
  holeDepth: 12,            // mm — profondeur de perçage (borgne, côtés de caisse)
  throughHole: false,        // Côtés de caisse: perçages borgnes (non traversants)
};

// ── System 32 for vertical separators ────────────────────────────────
export const SYSTEM32_SEPARATORS = {
  firstHoleOffset: 32,      // mm — 51mm - 19mm (fond) = 32mm from bottom edge
  pitch: 32,                // mm — same pitch
  holeDiameter: 5,          // mm — Ø 5 mm
  throughHole: true,         // Séparations verticales: Ø5mm TRAVERSANTS
};

// ── Hinge positioning (Blum CLIP top) ────────────────────────────────
export const HINGE = {
  axisOffset: 103,          // mm — per APEX 4.0 reversibility rule
  axisFrom: 'top_and_bottom',
  perDoor: 3,               // default, real count uses matrix below
  reversible: true,          // Panels are reversible (symmetric S32 drilling)
  model: 'Blum CLIP top',
  /** Per hinge cup: two Ø8 bores (Blum drilling pattern), depth mm, spacing mm (center–center), offset mm from cup center toward door interior (⟂ hinge edge). */
  cupScrewDiameter: 8,
  cupScrewDepth: 13,
  cupScrewSpacing: 45,
  cupScrewOffsetFromCupCenter: 9.5,
};

// Height/weight matrix from APEX 4.0 section 6.B
export const HINGE_MATRIX = [
  { maxHeightMm: 900, maxWeightKg: 6, hinges: 2 },
  { maxHeightMm: 1600, maxWeightKg: 17, hinges: 3 },
  { maxHeightMm: 2000, maxWeightKg: 20, hinges: 4 },
  { maxHeightMm: 2400, maxWeightKg: 22, hinges: 5 },
  { maxHeightMm: 2600, maxWeightKg: Infinity, hinges: 6 }
];

export function getHingeCountForDoor({ heightMm, weightKg = null }) {
  const h = Number(heightMm) || 0;
  const hasWeight = weightKg !== null && weightKg !== undefined && weightKg !== '';
  const w = hasWeight && Number.isFinite(Number(weightKg)) ? Number(weightKg) : null;
  for (const row of HINGE_MATRIX) {
    const byHeight = h <= row.maxHeightMm;
    const byWeight = w == null ? false : w <= row.maxWeightKg;
    if (byHeight || byWeight) return row.hinges;
  }
  return HINGE_MATRIX[HINGE_MATRIX.length - 1].hinges;
}

export function getHingeCupPositions(doorHeightMm, hingeCount = null) {
  const height = Number(doorHeightMm) || 0;
  const count = Math.max(2, Number(hingeCount) || getHingeCountForDoor({ heightMm: height }));
  const first = HINGE.axisOffset;
  const last = Math.max(first, height - HINGE.axisOffset);

  if (count <= 2) return [first, last];

  const spaces = count - 1;
  const rawStep = (last - first) / spaces;
  const positions = [first];

  for (let i = 1; i < spaces; i++) {
    const rawPos = first + rawStep * i;
    // Rule: align intermediary hinges on System 32 grid.
    const snapped = Math.round(rawPos / 32) * 32;
    const minPos = positions[positions.length - 1] + 32;
    const maxPos = last - (spaces - i) * 32;
    positions.push(Math.min(Math.max(snapped, minPos), maxPos));
  }

  positions.push(last);
  return positions;
}

// ── Plinth system (AXILO™ 78) ───────────────────────────────────────
export const PLINTH = {
  model: 'AXILO 78',
  footHeight: 78,            // mm — hauteur pied réglable
  clipsPerMeter: 3,          // clips de plinthe par mètre linéaire
  // Reserved packing space for hardware kit
  packingReserved: true,
};

// ── Reinforcement machining (Renforts Forteresse) ────────────────────
export const REINFORCEMENT_MACHINING = {
  // Sur chaque petit chant d'extrémité: 1× Ixconnect SC 8/60 au centre + 2× tourillons à 20 mm des bords
  connectorModel: 'SC 8/60',
  connector: {
    model: 'SC 8/60',
    edgeHole: { diameter: 8, depth: 45 },
    faceHole: { diameter: 8, depth: 12 },
  },
  ixconnectCenter: true,
  tourillonCount: 2,
  tourillonEdgeOffset: 20, // mm — tourillons à 20 mm des bords (axe mesuré depuis le même repère que l’Ixconnect)
  tourillonDiameter: 8,
};

/**
 * Axes de perçage sur le petit chant d'extrémité (mm depuis le bord haut du renfort).
 * @param {number} reinforcementFaceHeightMm — hauteur de la face de renfort (généralement 100 mm)
 */
export function getReinforcementEndFixingAxesFromTopMm(reinforcementFaceHeightMm) {
  const h = Math.max(0, Number(reinforcementFaceHeightMm) || 0);
  const off = REINFORCEMENT_MACHINING.tourillonEdgeOffset;
  const round1 = (v) => Math.round(v * 10) / 10;
  return {
    // Deux tourillons proches des bords haut/bas de la face 100mm.
    tourillonAxesFromTopMm: [round1(off), round1(Math.max(off, h - off))],
    ixconnectAxisFromTopMm: round1(h / 2),
  };
}

// ── Niche and sanitary gaps ─────────────────────────────────────────────
export const NICHE = {
  sanitaryGapAround: 30, // mm — vide sanitaire de 3 cm tout autour
  drawerBackGap: 10,     // mm — vide sanitaire derrière tiroir
};

// ── Drawers (manufactured) ──────────────────────────────────────────────
export const DRAWERS = {
  maxColumnWidth: 1000,           // mm
  minDepth: 400,                  // mm
  maxDepth: 650,                  // mm
  depthStep: 50,                  // mm
  hiddenHandleDepthReduction: 40, // mm (assumption until final handle specs)
  standardHeights: [60, 90, 128, 177, 240],
};

/**
 * Renforts latéraux caisse (25 mm) — uniquement si tiroirs cachés derrière porte ;
 * un montant gauche + un droit par colonne à tiroirs, même profondeur (min. des deux parois).
 * Fixation sur la face intérieure des montants / séparateurs.
 */
export const DRAWER_REINFORCEMENT = {
  thicknessMm: 25,
  /** mm depuis le fond caisse (repère rainure côté ou fond séparateur) — début utile du renfort */
  backInsetFromRearMm: 25,
  /** mm réservés vers l’avant quand les tiroirs sont derrière une porte à charnières */
  hingeFrontClearanceMm: 77,
  /** mm — déduit de la hauteur pile : partie droite au-dessus du rayon façade tiroir du haut */
  topFrontRadiusMm: 3,
  /** Ixconnect « petit » — même famille que finitions SC 8/25 */
  ixconnectModel: 'SC 8/25',
  /** mm — retrait des axes depuis chaque bord (chaque coin : 50 mm des deux côtés) */
  ixconnectCornerInsetMm: 50,
  ixconnectHoleDiameterMm: 8,
  /** Perçage face côté renfort (vers montant / séparateur) */
  ixconnectDepthInReinforcementMm: 13,
  /** Perçage face intérieure montant ou séparateur (vis-à-vis) */
  ixconnectDepthInVerticalPanelMm: 12,
};

/**
 * Ixconnect SC 8/25 sur montants / séparateurs — zone tiroirs cachés + renfort.
 * Repère face intérieure : X depuis bord avant (profondeur), Y depuis bas du panneau (corps).
 */
export const DRAWER_RENFORT_PANEL_IXCONNECT = {
  model: 'SC 8/25',
  /** 77 + 50 mm depuis le devant (axe avant) */
  frontAxesFromFrontMm: 77 + 50,
  /** Côté caisse : 19 + 9 + 50 mm depuis le fond */
  backAxesFromRearCoteMm: 19 + 9 + 50,
  /** Séparateur : 50 mm depuis le fond */
  backAxesFromRearSeparatorMm: 50,
  /** 50 mm du haut / bas de la zone renfort */
  verticalInsetMm: 50,
  faceHoleDiameterMm: 8,
  faceHoleDepthMm: 12
};

/**
 * 4 trous (rectangle) sur une face intérieure montant/séparateur pour renfort tiroir caché.
 * @param {number} panelDepthMm — largeur du panneau en plan (= profondeur caisse ou prof. séparateur)
 * @param {boolean} isCote — true = montant extérieur, false = séparateur
 * @param {number} zoneBottomFromPanelBottomMm — bas de la zone tiroirs depuis bas du panneau
 * @param {number} renfortHeightMm — hauteur utile renfort (= pile tiroirs − R)
 */
export function buildDrawerRenfortPanelIxconnectCornersMm(
  panelDepthMm,
  isCote,
  zoneBottomFromPanelBottomMm,
  renfortHeightMm
) {
  const P = DRAWER_RENFORT_PANEL_IXCONNECT;
  const D = Math.max(0, Number(panelDepthMm) || 0);
  const z0 = Math.max(0, Number(zoneBottomFromPanelBottomMm) || 0);
  const h = Math.max(0, Number(renfortHeightMm) || 0);
  const backInset = isCote ? P.backAxesFromRearCoteMm : P.backAxesFromRearSeparatorMm;
  const xf = P.frontAxesFromFrontMm;
  const xb = Math.max(xf + 1, D - backInset);
  const y1 = z0 + P.verticalInsetMm;
  const y2 = z0 + h - P.verticalInsetMm;
  if (h < 2 * P.verticalInsetMm + 5 || D < xf + backInset + 5 || y2 <= y1) return [];
  return [
    { xMm: xf, yMm: y1, role: 'avant_bas' },
    { xMm: xf, yMm: y2, role: 'avant_haut' },
    { xMm: xb, yMm: y1, role: 'fond_bas' },
    { xMm: xb, yMm: y2, role: 'fond_haut' }
  ];
}

/**
 * 4 trous d’angle pour Ixconnect SC 8/25 — repère plan face : X depuis bord gauche, Y depuis bord haut (mm).
 * @returns {{ xMm: number, yMm: number, role: string }[]}
 */
export function getDrawerReinforcementIxconnectHolePositionsMm(widthMm, heightMm, insetMm = DRAWER_REINFORCEMENT.ixconnectCornerInsetMm) {
  const w = Math.max(0, Number(widthMm) || 0);
  const h = Math.max(0, Number(heightMm) || 0);
  const ins = Math.max(8, Math.min(Number(insetMm) || 50, Math.min(w, h) / 2 - 0.5));
  if (w < 2 * ins || h < 2 * ins) return [];
  return [
    { xMm: ins, yMm: ins, role: 'nw' },
    { xMm: w - ins, yMm: ins, role: 'ne' },
    { xMm: ins, yMm: h - ins, role: 'sw' },
    { xMm: w - ins, yMm: h - ins, role: 'se' }
  ];
}

/**
 * Hauteur totale du bloc tiroirs (façades + jeux), mm.
 * @param {number} drawerCount
 * @param {number[]} drawerHeightsMm
 * @param {number} [drawerGapMm]
 */
export function drawerStackHeightMm(drawerCount, drawerHeightsMm, drawerGapMm = 8) {
  const n = Math.max(0, Number(drawerCount) || 0);
  if (n <= 0) return 0;
  const heights = Array.isArray(drawerHeightsMm) && drawerHeightsMm.length ? drawerHeightsMm : DRAWERS.standardHeights;
  const gap = Number.isFinite(Number(drawerGapMm)) ? Number(drawerGapMm) : 8;
  const sum = heights
    .slice(0, Math.min(n, heights.length))
    .reduce((s, v) => s + (Number(v) || 0), 0);
  return Math.max(0, Math.round(sum + Math.max(0, n - 1) * gap));
}

// ── Full-height handle assumptions ──────────────────────────────────────
export const HANDLE = {
  /** Retrait mécanique rainure poignée (haut + bas) */
  fullHeightTopBottomOffset: 2, // mm from top and bottom
  /** Déduction largeur panneau porte (vs poignée standard) — même valeur liste de débitage / plans */
  fullHeightWidthDeductionMm: 18,
  /** Rainure usinée sur le montant côté poignée (profil type dos, à confirmer au profilé) */
  fullHeightGroove: {
    width: GROOVE.back.width,
    depth: GROOVE.back.depth,
  },
};

/**
 * Côté charnières en élévation pour la porte d’index `doorIndex` :
 * vantail extérieur gauche → charnières gauche ; droit → droite ; portes centrales → réglage utilisateur.
 */
export function getDoorHingeSide(doorIndex, doorCount, hardware = {}) {
  const hw = hardware || {};
  const n = Math.max(1, Number(doorCount) || 1);
  const i = Math.max(0, Number(doorIndex) || 0);
  if (n <= 1) return hw.doorHingeSide === 'right' ? 'right' : 'left';
  if (i === 0) return 'left';
  if (i === n - 1) return 'right';
  return hw.centerDoorHingeSide === 'right' ? 'right' : 'left';
}

// ── Block assembly drilling ─────────────────────────────────────────────
export const BLOCK_ASSEMBLY = {
  sideOffsetFromFace: 30,   // mm
  sideOffsetFromBack: 30,   // mm
  topBottomOffset: 100,     // mm
  middleCount: 3,           // per joint
};

// ── Carcass assembly ferrures ───────────────────────────────────────────
export const CARCASS_FASTENERS = {
  /** Ferrure d'assemblage utilisée pour les jonctions de caisse (côtés/séparateurs ↔ dessus/fond). */
  model: 'Häfele Rasant-Tab',
  /** Référence produit (Ferrures d’assemblage Rasant-Tab, Ø trou 3 ou 5 mm). */
  productUrl: 'https://www.haefele.ch/fr/produkt/ferrures-d-assemblage-rasant-tab-visser-dans-trou-de-per-age-3-ou-5-mm/26236520/?MasterSKU=P-00861456',
  piecesPerJoint: 3,
  /** Retrait des ferrures d’extrémité (mm) */
  endInsetMm: 50,
  edgeOffsets: [50, 'middle', 50],
  /** Perçage ferrure: profondeur sur longueur de la pièce (mm) */
  ferrureDepthAlongLengthMm: 46,
  /** Perçage ferrure: profondeur sur l’épaisseur de la pièce (mm) */
  ferrureDepthInThicknessMm: 12,
  dowel: {
    diameter: 8,
    /** Longueur nominale tourillon (réf. atelier) */
    depth: 40,
    /** Perçage borgne en face (dans l’épaisseur du panneau), mm — toujours 12 pour dessus/fond */
    faceDrillDepthMm: 12,
    /** 2× tourillons par ferrure : axes à ±sideOffset du centre de chaque ferrure (mm) */
    sideOffset: 30,
  },
};

/** Profondeur effective perçage tourillon en face (ne dépasse pas l’épaisseur). */
export function tourillonFaceDrillDepthMm(thicknessMm) {
  const cap = CARCASS_FASTENERS.dowel.faceDrillDepthMm;
  const t = Math.max(1, Number(thicknessMm) || PANEL.structure);
  return Math.min(cap, Math.max(6, t - 2));
}

/** Longueur mini. d’arête (mm) pour placer une ferrure au milieu (en plus des 50 mm d’extrémité). */
export const CARCASS_MIDDLE_FERRURE_MIN_EDGE_MM = 500;

/**
 * Centres des ferrures le long d’une arête de jonction.
 * Règle: 50 mm des extrémités ; ferrure centrale seulement si l’arête dépasse {@link CARCASS_MIDDLE_FERRURE_MIN_EDGE_MM}.
 * @param {number} edgeLengthMm — longueur de l’arête (mm), ici hauteur utile de la jonction
 * @returns {number[]} distances depuis le début de l’arête (mm)
 */
export function getCarcassJointPositions(edgeLengthMm) {
  const L = Math.max(0, Number(edgeLengthMm) || 0);
  if (L <= 0) return [];
  const inset = Math.min(CARCASS_FASTENERS.endInsetMm, Math.max(20, L * 0.1));
  const tail = L - inset;
  const minMid = CARCASS_MIDDLE_FERRURE_MIN_EDGE_MM;

  if (tail <= inset + 20) {
    if (L > minMid) {
      const u = L / 4;
      return [u, L / 2, L - u].map((v) => Math.round(Math.min(L, Math.max(0, v)) * 10) / 10);
    }
    const u = L / 4;
    return [u, L - u].map((v) => Math.round(Math.min(L, Math.max(0, v)) * 10) / 10);
  }

  if (L > minMid) {
    return [inset, L / 2, tail].map((v) => Math.round(v * 10) / 10);
  }
  return [inset, tail].map((v) => Math.round(v * 10) / 10);
}

/**
 * Chaque ferrure: 3 perçages alignés sur la longueur:
 * - 1 perçage ferrure au centre
 * - 2 perçages tourillons à ±sideOffset du centre
 * @returns {{ centerMm: number, holesAlongMm: [number, number, number] }[]}
 */
export function getCarcassFerrureDowelDrillings(centerPositionsMm, edgeLengthMm, sideOffsetMm = CARCASS_FASTENERS.dowel.sideOffset) {
  const L = Math.max(0, Number(edgeLengthMm) || 0);
  const off = Math.max(0, Number(sideOffsetMm) || 0);
  const centers = centerPositionsMm || [];
  const clamp = (v) => Math.round(Math.min(L, Math.max(0, v)) * 10) / 10;
  return centers.map((c0) => {
    const c = Number(c0);
    return { centerMm: c, holesAlongMm: [clamp(c - off), clamp(c), clamp(c + off)] };
  });
}

// ── Shelf machining ─────────────────────────────────────────────────
export const SHELF_MACHINING = {
  // Tourillons Ø8 front + back for shelf pin alignment
  tourillonDiameter: 8,      // mm
  tourillonCount: 4,          // 2 front + 2 back per shelf
  // "2 rayons sur une même strate de 19mm" — 2 shelves can share same S32 row
  shelvesPerStratum: 2,
};

// ── Packing ──────────────────────────────────────────────────────────
export const PACKING = {
  maxWeightKg: 28,
  // Approximate density for weight estimation (kg per m³)
  densityKgM3: {
    melamine19: 680,        // Panneau mélaminé 19 mm
    melamine16: 660,        // Panneau mélaminé 16 mm (renforts)
    melamine25: 670,        // Panneau mélaminé 25 mm (renforts tiroir)
    melamine8: 640,         // Panneau mélaminé 8 mm (dos)
  },
  // Layer-based packing strategy (per APEX 4.0 spec):
  layers: {
    level1: 'sides',          // Niveau 1: Côtés empilés
    level2: 'topAndBottom',   // Niveau 2: Dessus + fond côte à côte
    level3: 'shelvesAndRenforts', // Niveau 3: Étagères + renforts groupés par épaisseur
  },
  // Hardware kit reservation (AXILO™ pieds + clips de plinthe)
  hardwareKitReserved: true,  // Espace réservé dans le colisage
};

// ── Convenience: convert mm constants to metres (for Three.js) ──────
export const PANEL_M = {
  structure: PANEL.structure / 1000,
  reinforcement: PANEL.reinforcement / 1000,
  back: PANEL.back / 1000,
  reinforcementWidth: PANEL.reinforcementWidth / 1000,
};