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

import { LEGRABOX_SIDE_HEIGHTS_MM, legraboxNicheHeightMm } from './blumLegrabox.js';

// ── 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
};

/**
 * Surcote sur-mesure (mm) ajoutée à la coupe brute en longueur ET en largeur de chaque pièce.
 * Marge de débit sur-mesure : la pièce est débitée plus grande puis ramenée à la cote finie.
 */
export const CUTTING_SURCOTE_MM = 10;

// ── 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
    /** Accès Inbus — sur le même panneau que le long perçage Ø8 en chant,
     * à `offsetFromAssemblyEdgeMm` du chant d’assemblage. */
    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) {
    const totalOuter = mWidths.reduce((sum, w) => sum + w, 0);
    // Column widths are wardrobe-outer; the horizontal panel is shorter by the
    // exterior montant insets (typically 19 mm per side). Shift interior
    // boundaries into the panel's left-origin so the right edge is not left
    // with a 19 mm "phantom" margin.
    const overhang = totalOuter - maxW;
    const leftShift =
      overhang > 0.5 && mWidths.length >= 2 ? Math.min(PANEL.structure, overhang) : 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 - leftShift)));
    }
    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];
}

// ── CNC / panel envelope (Bearbeitungsdimensionen) ──────────────────
/** Longest manufacturable panel edge (CNC Länge), mm. */
export const MAX_PANEL_DIMENSION_MM = 3250;
/** Shortest manufacturable panel edge on the machine bed (CNC Breite), mm. */
export const MAX_PANEL_SHORT_SIDE_MM = 1500;
/** Maximum panel thickness the CNC can machine (CNC Dicke), mm. */
export const MAX_PANEL_THICKNESS_MM = 125;

// ── Multi-column horizontal spans ───────────────────────────────────
export const HORIZONTAL_SPAN_TYPE = 'open';
export const HORIZONTAL_SPAN_DOOR_MODES = Object.freeze({
  none: 'none',
  perColumn: 'perColumn',
  single: 'single'
});
export const HORIZONTAL_SPAN_BLOCK_MM = Object.freeze({
  min: 300,
  max: MAX_PANEL_DIMENSION_MM,
  step: 50,
  initialUpper: 300
});
const SPAN_EPSILON_MM = 0.5;

/**
 * Ordered horizontal module extents, measured from the wardrobe's left edge.
 * Invalid/negative widths are represented as zero-width modules so ids and indexes remain stable.
 */
export function getModulePositionsMm(modules = []) {
  let leftMm = 0;
  return (Array.isArray(modules) ? modules : []).map((module, index) => {
    const widthMm = Math.max(0, Number(module?.widthMm) || 0);
    const position = {
      id: module?.id,
      index,
      module,
      leftMm,
      rightMm: leftMm + widthMm,
      widthMm
    };
    leftMm += widthMm;
    return position;
  });
}

/** Vertical block edges (including 0 and body top), measured from the carcass bottom. */
export function getModuleVerticalBoundariesMm(module, config = {}) {
  const bodyMm = Math.max(
    0,
    (Number(config?.heightMm) || 0) - (Number(config?.plinthHeightMm) || 0)
  );
  const raw = Array.isArray(module?.blockHeightsMm)
    ? module.blockHeightsMm.map(Number).filter((value) => Number.isFinite(value) && value > 0)
    : [];
  if (raw.length === 0) {
    const legacyBottom = Number(module?.stackBottomHeightMm ?? config?.stackBottomHeightMm);
    const stacked = module?.stacked === true || (module?.stacked == null && config?.stackEnabled === true);
    if (stacked && legacyBottom > 0 && legacyBottom < bodyMm) raw.push(legacyBottom, bodyMm - legacyBottom);
    else raw.push(bodyMm);
  }

  const boundaries = [0];
  let cursor = 0;
  for (const height of raw) {
    cursor += height;
    if (cursor > SPAN_EPSILON_MM && cursor < bodyMm - SPAN_EPSILON_MM) boundaries.push(cursor);
  }
  boundaries.push(bodyMm);
  return boundaries.map((value) => Math.round(value * 100) / 100);
}

function uniqueModuleIds(moduleIds) {
  const seen = new Set();
  return (Array.isArray(moduleIds) ? moduleIds : []).filter((id) => {
    if ((typeof id !== 'string' && typeof id !== 'number') || seen.has(String(id))) return false;
    seen.add(String(id));
    return true;
  });
}

/** Canonical state representation; validation should be run before accepting user input. */
export function normalizeHorizontalSpan(span = {}, modules = []) {
  const order = new Map(getModulePositionsMm(modules).map((position) => [String(position.id), position.index]));
  const moduleIds = uniqueModuleIds(span.moduleIds)
    .filter((id) => order.has(String(id)))
    .sort((a, b) => order.get(String(a)) - order.get(String(b)));
  const requestedDoorMode = String(span.doorMode || HORIZONTAL_SPAN_DOOR_MODES.none);
  const doorMode = Object.values(HORIZONTAL_SPAN_DOOR_MODES).includes(requestedDoorMode)
    ? requestedDoorMode
    : HORIZONTAL_SPAN_DOOR_MODES.none;
  const normalized = {
    id: span.id,
    moduleIds,
    bottomMm: Number(span.bottomMm),
    topMm: Number(span.topMm),
    hasBack: Boolean(span.hasBack),
    doorMode,
    type: HORIZONTAL_SPAN_TYPE
  };
  const upperBlockTopMm = Number(span.upperBlockTopMm);
  if (Number.isFinite(upperBlockTopMm)) normalized.upperBlockTopMm = upperBlockTopMm;
  return normalized;
}

/**
 * Resolve a span to current module indexes, extents and covered block indexes.
 * Returns null when it references missing modules.
 */
export function resolveHorizontalSpan(span, config = {}) {
  const modules = Array.isArray(config?.modules) ? config.modules : [];
  const positions = getModulePositionsMm(modules);
  const byId = new Map(positions.map((position) => [String(position.id), position]));
  const requestedIds = uniqueModuleIds(span?.moduleIds);
  const selected = requestedIds.map((id) => byId.get(String(id)));
  if (selected.some((position) => !position)) return null;
  selected.sort((a, b) => a.index - b.index);
  const bottomMm = Number(span?.bottomMm);
  const topMm = Number(span?.topMm);
  const coveredBlocks = selected.map((position) => {
    const boundariesMm = getModuleVerticalBoundariesMm(position.module, config);
    const blockIndexes = [];
    for (let index = 0; index < boundariesMm.length - 1; index++) {
      if (
        boundariesMm[index] >= bottomMm - SPAN_EPSILON_MM &&
        boundariesMm[index + 1] <= topMm + SPAN_EPSILON_MM
      ) blockIndexes.push(index);
    }
    return { moduleId: position.id, moduleIndex: position.index, boundariesMm, blockIndexes };
  });
  return {
    span,
    moduleIds: selected.map((position) => position.id),
    moduleIndexes: selected.map((position) => position.index),
    modules: selected.map((position) => position.module),
    leftMm: selected[0]?.leftMm ?? 0,
    rightMm: selected[selected.length - 1]?.rightMm ?? 0,
    widthMm: selected.length ? selected[selected.length - 1].rightMm - selected[0].leftMm : 0,
    bottomMm,
    topMm,
    coveredBlocks
  };
}

function hasBoundary(boundaries, value) {
  return boundaries.some((boundary) => Math.abs(boundary - value) <= SPAN_EPSILON_MM);
}

/**
 * Validate all horizontal spans. Returned issues have stable machine-readable `code` values.
 * Drawers are treated as occupying the bottom block; doors use `blockDoors` (legacy default: true).
 */
export function validateHorizontalSpans(config = {}, options = {}) {
  const spans = Array.isArray(config?.horizontalSpans) ? config.horizontalSpans : [];
  const maxPanelWidthMm = Number(options.maxPanelWidthMm) || MAX_PANEL_DIMENSION_MM;
  const bodyMm = Math.max(0, (Number(config?.heightMm) || 0) - (Number(config?.plinthHeightMm) || 0));
  const issues = [];
  const resolvedValidShape = [];
  const ids = new Set();

  spans.forEach((span, spanIndex) => {
    const field = `horizontalSpans[${spanIndex}]`;
    const spanId = span?.id;
    const add = (code, message) => issues.push({ code, field, spanId, message });
    if ((typeof spanId !== 'string' && typeof spanId !== 'number') || String(spanId).trim() === '') {
      add('missing_id', 'La traverse horizontale doit avoir un identifiant stable.');
    } else if (ids.has(String(spanId))) {
      add('duplicate_id', 'Identifiant de traverse horizontale dupliqué.');
    } else ids.add(String(spanId));
    if (span?.type !== HORIZONTAL_SPAN_TYPE) add('bad_type', `Type de traverse invalide (attendu : ${HORIZONTAL_SPAN_TYPE}).`);
    if (typeof span?.hasBack !== 'boolean') add('bad_has_back', 'Le dos de la traverse doit être un booléen.');
    const doorMode = span?.doorMode ?? HORIZONTAL_SPAN_DOOR_MODES.none;
    if (!Object.values(HORIZONTAL_SPAN_DOOR_MODES).includes(doorMode)) {
      add('bad_door_mode', 'Le choix de portes du block horizontal est invalide.');
    }
    if (!Array.isArray(span?.moduleIds) || uniqueModuleIds(span.moduleIds).length !== span.moduleIds.length) {
      add('bad_module_ids', 'La liste des colonnes est invalide ou contient des doublons.');
    }

    const resolved = resolveHorizontalSpan(span, config);
    if (!resolved) {
      add('stale_module', 'La traverse référence une colonne inexistante.');
      return;
    }
    if (resolved.moduleIds.length < 2) add('too_few_modules', 'Une traverse doit couvrir au moins deux colonnes.');
    const contiguous = resolved.moduleIndexes.every(
      (index, offset) => offset === 0 || index === resolved.moduleIndexes[offset - 1] + 1
    );
    if (!contiguous) add('noncontiguous_modules', 'Les colonnes couvertes doivent être contiguës.');
    if (
      !Number.isFinite(resolved.bottomMm) ||
      !Number.isFinite(resolved.topMm) ||
      resolved.bottomMm < 0 ||
      resolved.topMm <= resolved.bottomMm ||
      resolved.topMm > bodyMm + SPAN_EPSILON_MM
    ) add('bad_range', 'La plage verticale de la traverse est invalide.');
    if (resolved.widthMm > maxPanelWidthMm + SPAN_EPSILON_MM) {
      add('panel_too_wide', `La traverse dépasse la largeur de panneau maximale (${maxPanelWidthMm} mm).`);
    }

    let aligned = true;
    resolved.coveredBlocks.forEach(({ boundariesMm }) => {
      if (!hasBoundary(boundariesMm, resolved.bottomMm) || !hasBoundary(boundariesMm, resolved.topMm)) aligned = false;
    });
    if (!aligned) add('misaligned_boundaries', 'Les limites doivent coïncider avec les jonctions de blocks de chaque colonne.');

    resolved.coveredBlocks.forEach(({ moduleIndex, blockIndexes }) => {
      const module = config.modules[moduleIndex];
      const doors = Array.isArray(module?.blockDoors) ? module.blockDoors : null;
      if (blockIndexes.some((blockIndex) => doors ? doors[blockIndex] !== false : true)) {
        add('incompatible_door', `Une porte occupe la zone couverte dans la colonne ${moduleIndex + 1}.`);
      }
      if ((Number(module?.drawers) || 0) > 0 && blockIndexes.includes(0)) {
        add('incompatible_drawers', `Des tiroirs occupent la zone couverte dans la colonne ${moduleIndex + 1}.`);
      }
    });
    resolvedValidShape.push(resolved);
  });

  for (let leftIndex = 0; leftIndex < resolvedValidShape.length; leftIndex++) {
    for (let rightIndex = leftIndex + 1; rightIndex < resolvedValidShape.length; rightIndex++) {
      const left = resolvedValidShape[leftIndex];
      const right = resolvedValidShape[rightIndex];
      const sharesModule = left.moduleIds.some((id) => right.moduleIds.some((other) => String(other) === String(id)));
      const overlapsVertically =
        left.bottomMm < right.topMm - SPAN_EPSILON_MM &&
        right.bottomMm < left.topMm - SPAN_EPSILON_MM;
      if (sharesModule && overlapsVertically) {
        issues.push({
          code: 'overlap',
          field: `horizontalSpans[${rightIndex}]`,
          spanId: right.span?.id,
          message: 'Deux traverses horizontales se chevauchent.'
        });
      }
    }
  }
  return issues;
}

/** Keep only spans that remain structurally valid against the current module order/model. */
export function reconcileHorizontalSpans(spans = [], config = {}, options = {}) {
  const candidateConfig = { ...config, horizontalSpans: Array.isArray(spans) ? spans : [] };
  const invalidIds = new Set(validateHorizontalSpans(candidateConfig, options).map((issue) => String(issue.spanId)));
  return candidateConfig.horizontalSpans
    .filter((span) => !invalidIds.has(String(span?.id)))
    .map((span) => normalizeHorizontalSpan(span, candidateConfig.modules));
}

/**
 * Remaining physical segments for the separator between module N and N+1.
 * Span-covered ranges are removed; touching ranges are merged.
 */
export function getSeparatorVerticalSegments(config = {}, separatorIndex) {
  const modules = Array.isArray(config?.modules) ? config.modules : [];
  const left = modules[separatorIndex];
  const right = modules[separatorIndex + 1];
  if (!left || !right) return [];
  const bodyMm = Math.max(0, (Number(config.heightMm) || 0) - (Number(config.plinthHeightMm) || 0));
  const cuts = (Array.isArray(config.horizontalSpans) ? config.horizontalSpans : [])
    .map((span) => resolveHorizontalSpan(span, config))
    .filter((resolved) =>
      resolved &&
      resolved.moduleIndexes.includes(separatorIndex) &&
      resolved.moduleIndexes.includes(separatorIndex + 1)
    )
    .map(({ bottomMm, topMm }) => ({
      bottomMm: Math.max(0, bottomMm),
      topMm: Math.min(bodyMm, topMm)
    }))
    .filter((range) => range.topMm > range.bottomMm)
    .sort((a, b) => a.bottomMm - b.bottomMm);
  const merged = [];
  cuts.forEach((range) => {
    const previous = merged[merged.length - 1];
    if (previous && range.bottomMm <= previous.topMm + SPAN_EPSILON_MM) {
      previous.topMm = Math.max(previous.topMm, range.topMm);
    } else merged.push({ ...range });
  });
  const segments = [];
  let cursor = 0;
  merged.forEach((range) => {
    if (range.bottomMm > cursor + SPAN_EPSILON_MM) segments.push({ bottomMm: cursor, topMm: range.bottomMm });
    cursor = Math.max(cursor, range.topMm);
  });
  if (cursor < bodyMm - SPAN_EPSILON_MM) segments.push({ bottomMm: cursor, topMm: bodyMm });
  return segments;
}

/**
 * Insert selected horizontal limits into module block models while preserving each band's back/door flags.
 * This is intentionally a model operation; callers decide whether resulting short blocks are acceptable.
 */
export function synchronizeModuleSpanBoundaries(config = {}, moduleIds = [], bottomMm, topMm) {
  const selectedIds = new Set(uniqueModuleIds(moduleIds).map(String));
  const bodyMm = Math.max(0, (Number(config.heightMm) || 0) - (Number(config.plinthHeightMm) || 0));
  const requested = [Number(bottomMm), Number(topMm)]
    .filter((value) => Number.isFinite(value) && value > 0 && value < bodyMm)
    .sort((a, b) => a - b);
  const modules = (Array.isArray(config.modules) ? config.modules : []).map((module) => {
    if (!selectedIds.has(String(module?.id))) return module;
    const oldEdges = getModuleVerticalBoundariesMm(module, config);
    const edges = [...oldEdges];
    requested.forEach((value) => {
      if (!hasBoundary(edges, value)) edges.push(value);
    });
    edges.sort((a, b) => a - b);
    const sourceBacks = Array.isArray(module.blockBacks) ? module.blockBacks : [];
    const sourceDoors = Array.isArray(module.blockDoors) ? module.blockDoors : [];
    const sourceIndexAt = (midpoint) => Math.max(
      0,
      Math.min(oldEdges.length - 2, oldEdges.findIndex((edge, index) => index < oldEdges.length - 1 && midpoint >= edge && midpoint <= oldEdges[index + 1]))
    );
    const heights = edges.slice(1).map((edge, index) => Math.round((edge - edges[index]) * 100) / 100);
    const backs = heights.map((height, index) => {
      const sourceIndex = sourceIndexAt(edges[index] + height / 2);
      return typeof sourceBacks[sourceIndex] === 'boolean' ? sourceBacks[sourceIndex] : Boolean(module.hasBack);
    });
    const doors = heights.map((height, index) => {
      const sourceIndex = sourceIndexAt(edges[index] + height / 2);
      return typeof sourceDoors[sourceIndex] === 'boolean' ? sourceDoors[sourceIndex] : true;
    });
    return {
      ...module,
      blockHeightsMm: heights,
      blockBacks: backs,
      blockDoors: doors,
      stacked: heights.length >= 2,
      stackBottomHeightMm: heights[0],
      hasBack: backs[0],
      hasBackTop: backs[backs.length - 1]
    };
  });
  return { ...config, modules };
}

function horizontalSpanFailure(code, message) {
  return { ok: false, code, message };
}

function sourceBlockIndexAt(edges, midpoint) {
  const index = edges.findIndex((edge, current) => (
    current < edges.length - 1 &&
    midpoint >= edge - SPAN_EPSILON_MM &&
    midpoint <= edges[current + 1] + SPAN_EPSILON_MM
  ));
  return Math.max(0, Math.min(edges.length - 2, index < 0 ? edges.length - 2 : index));
}

function rebuildModuleWithSpanBoundary(module, config, oldBoundaryMm, newBoundaryMm, spanRange, upperRange) {
  const oldEdges = getModuleVerticalBoundariesMm(module, config);
  const edges = oldEdges
    .filter((edge) => (
      (!Number.isFinite(oldBoundaryMm) || Math.abs(edge - oldBoundaryMm) > SPAN_EPSILON_MM) &&
      !(edge > newBoundaryMm + SPAN_EPSILON_MM && edge < upperRange.topMm - SPAN_EPSILON_MM)
    ));
  if (!hasBoundary(edges, newBoundaryMm)) edges.push(newBoundaryMm);
  edges.sort((a, b) => a - b);

  const sourceBacks = Array.isArray(module.blockBacks) ? module.blockBacks : [];
  const sourceDoors = Array.isArray(module.blockDoors) ? module.blockDoors : [];
  const heights = edges.slice(1).map((edge, index) => Math.round((edge - edges[index]) * 100) / 100);
  const backs = heights.map((height, index) => {
    const sourceIndex = sourceBlockIndexAt(oldEdges, edges[index] + height / 2);
    return typeof sourceBacks[sourceIndex] === 'boolean' ? sourceBacks[sourceIndex] : Boolean(module.hasBack);
  });
  const doors = heights.map((height, index) => {
    const blockBottomMm = edges[index];
    const blockTopMm = edges[index + 1];
    if (
      blockBottomMm >= spanRange.bottomMm - SPAN_EPSILON_MM &&
      blockTopMm <= spanRange.topMm + SPAN_EPSILON_MM
    ) return false;
    if (
      blockBottomMm >= upperRange.bottomMm - SPAN_EPSILON_MM &&
      blockTopMm <= upperRange.topMm + SPAN_EPSILON_MM
    ) return true;
    const sourceIndex = sourceBlockIndexAt(oldEdges, blockBottomMm + height / 2);
    return typeof sourceDoors[sourceIndex] === 'boolean' ? sourceDoors[sourceIndex] : true;
  });

  return {
    ...module,
    blockHeightsMm: heights,
    blockBacks: backs,
    blockDoors: doors,
    stacked: heights.length >= 2,
    stackBottomHeightMm: heights[0],
    hasBack: backs[0],
    hasBackTop: backs[backs.length - 1]
  };
}

function findHorizontalSpan(config, spanId) {
  return (Array.isArray(config?.horizontalSpans) ? config.horizontalSpans : [])
    .find((span) => String(span?.id) === String(spanId));
}

/**
 * Describe the regular block explicitly created above a horizontal span.
 * The marker is stored on the span so an unrelated pre-existing upper block is never mistaken for it.
 */
export function getHorizontalSpanUpperBlockState(config = {}, spanId) {
  const span = findHorizontalSpan(config, spanId);
  if (!span) return horizontalSpanFailure('span_not_found', 'Le block horizontal sélectionné n’existe plus.');
  const resolved = resolveHorizontalSpan(span, config);
  if (!resolved) return horizontalSpanFailure('span_not_found', 'Les colonnes du block horizontal n’existent plus.');

  const upperBlockTopMm = Number(span.upperBlockTopMm);
  if (!Number.isFinite(upperBlockTopMm) || upperBlockTopMm <= resolved.topMm + SPAN_EPSILON_MM) {
    return { ok: true, exists: false, canAdd: resolved.topMm - resolved.bottomMm >= HORIZONTAL_SPAN_BLOCK_MM.min * 2 };
  }
  const commonBoundaries = resolved.coveredBlocks.every(({ boundariesMm }) => (
    hasBoundary(boundariesMm, resolved.topMm) && hasBoundary(boundariesMm, upperBlockTopMm)
  ));
  if (!commonBoundaries) {
    return horizontalSpanFailure(
      'missing_common_boundary',
      'Impossible : les colonnes couvertes n’ont plus de limite haute commune.'
    );
  }

  const heightMm = Math.round((upperBlockTopMm - resolved.topMm) * 100) / 100;
  const maxHeightMm = Math.floor(
    Math.min(
      HORIZONTAL_SPAN_BLOCK_MM.max,
      upperBlockTopMm - resolved.bottomMm - HORIZONTAL_SPAN_BLOCK_MM.min
    ) / HORIZONTAL_SPAN_BLOCK_MM.step
  ) * HORIZONTAL_SPAN_BLOCK_MM.step;
  return {
    ok: true,
    exists: true,
    heightMm,
    minHeightMm: HORIZONTAL_SPAN_BLOCK_MM.min,
    maxHeightMm,
    stepMm: HORIZONTAL_SPAN_BLOCK_MM.step,
    upperBlockTopMm
  };
}

/**
 * Atomically carve a 300 mm regular block from the top of a horizontal span.
 * Returns a new config or an error without mutating the input.
 */
export function addUpperBlockAboveHorizontalSpan(config = {}, spanId) {
  const span = findHorizontalSpan(config, spanId);
  if (!span) return horizontalSpanFailure('span_not_found', 'Le block horizontal sélectionné n’existe plus.');
  if (Number.isFinite(Number(span.upperBlockTopMm))) {
    return horizontalSpanFailure('upper_block_exists', 'Un block supérieur synchronisé existe déjà.');
  }
  const resolved = resolveHorizontalSpan(span, config);
  if (!resolved) return horizontalSpanFailure('span_not_found', 'Les colonnes du block horizontal n’existent plus.');
  const spanHeightMm = resolved.topMm - resolved.bottomMm;
  if (spanHeightMm < HORIZONTAL_SPAN_BLOCK_MM.min * 2 - SPAN_EPSILON_MM) {
    return horizontalSpanFailure(
      'span_too_short',
      'Le block horizontal doit mesurer au moins 600 mm pour ajouter un block supérieur.'
    );
  }
  if (!resolved.coveredBlocks.every(({ boundariesMm }) => hasBoundary(boundariesMm, resolved.topMm))) {
    return horizontalSpanFailure(
      'missing_common_boundary',
      'Impossible : les colonnes couvertes n’ont pas de limite haute commune.'
    );
  }

  const oldTopMm = resolved.topMm;
  const newTopMm = oldTopMm - HORIZONTAL_SPAN_BLOCK_MM.initialUpper;
  const selectedIds = new Set(resolved.moduleIds.map(String));
  const modules = config.modules.map((module) => (
    selectedIds.has(String(module?.id))
      ? rebuildModuleWithSpanBoundary(
        module,
        config,
        Number.NaN,
        newTopMm,
        { bottomMm: resolved.bottomMm, topMm: newTopMm },
        { bottomMm: newTopMm, topMm: oldTopMm }
      )
      : module
  ));
  const horizontalSpans = config.horizontalSpans.map((candidate) => (
    String(candidate?.id) === String(spanId)
      ? normalizeHorizontalSpan({ ...candidate, topMm: newTopMm, upperBlockTopMm: oldTopMm }, modules)
      : candidate
  ));
  const nextConfig = { ...config, modules, horizontalSpans };
  const issue = validateHorizontalSpans(nextConfig)[0];
  if (issue) {
    return horizontalSpanFailure(
      'span_conflict',
      `Impossible : cette modification invaliderait un block horizontal. ${issue.message}`
    );
  }
  return { ok: true, config: nextConfig, heightMm: HORIZONTAL_SPAN_BLOCK_MM.initialUpper };
}

/**
 * Move the shared boundary below an explicitly-created upper block in every covered column.
 */
export function resizeHorizontalSpanUpperBlock(config = {}, spanId, requestedHeightMm) {
  const state = getHorizontalSpanUpperBlockState(config, spanId);
  if (!state.ok) return state;
  if (!state.exists) {
    return horizontalSpanFailure('upper_block_missing', 'Ajoutez d’abord un block au-dessus du block horizontal.');
  }
  const heightMm = Number(requestedHeightMm);
  if (
    !Number.isFinite(heightMm) ||
    heightMm < state.minHeightMm - SPAN_EPSILON_MM ||
    heightMm > state.maxHeightMm + SPAN_EPSILON_MM ||
    Math.abs(heightMm / state.stepMm - Math.round(heightMm / state.stepMm)) > 0.001
  ) {
    return horizontalSpanFailure(
      'invalid_height',
      `Choisissez une hauteur de ${state.minHeightMm} à ${state.maxHeightMm} mm, par pas de ${state.stepMm} mm.`
    );
  }

  const span = findHorizontalSpan(config, spanId);
  const resolved = resolveHorizontalSpan(span, config);
  const newTopMm = state.upperBlockTopMm - heightMm;
  if (Math.abs(newTopMm - resolved.topMm) <= SPAN_EPSILON_MM) {
    return { ok: true, config, heightMm };
  }
  const selectedIds = new Set(resolved.moduleIds.map(String));
  const modules = config.modules.map((module) => (
    selectedIds.has(String(module?.id))
      ? rebuildModuleWithSpanBoundary(
        module,
        config,
        resolved.topMm,
        newTopMm,
        { bottomMm: resolved.bottomMm, topMm: newTopMm },
        { bottomMm: newTopMm, topMm: state.upperBlockTopMm }
      )
      : module
  ));
  const horizontalSpans = config.horizontalSpans.map((candidate) => (
    String(candidate?.id) === String(spanId)
      ? normalizeHorizontalSpan({ ...candidate, topMm: newTopMm }, modules)
      : candidate
  ));
  const nextConfig = { ...config, modules, horizontalSpans };
  const issue = validateHorizontalSpans(nextConfig)[0];
  if (issue) {
    return horizontalSpanFailure(
      'span_conflict',
      `Impossible : cette hauteur invaliderait un autre block horizontal. ${issue.message}`
    );
  }
  return { ok: true, config: nextConfig, heightMm };
}

// ── 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',
  /** Hauteurs cibles proposées dans le configurateur. */
  targetHeightsMm: [60, 80, 100, 125, 150, 180, 200],
  footHeight: 78,            // @deprecated — nom du système, pas une hauteur de coupe
  panelThicknessMm: 19,
  panelTopClearanceMm: 5,
  /** Recul de la face visible de plinthe par rapport au chant de caisse (avant et côtés libres). */
  frontSetbackMm: 20,
  mountingPlate: {
    articleNumber: '637.76.710',
    fixingMethod: 'press_fit',
    face: 'underside',
    frontCenterFromFrontMm: 19 + 40,
    rearCenterFromRearMm: 50,
    /**
     * Distance du trou AXILO le plus proche du chant latéral du fond.
     * Habillage : 15.5 mm. Sans habillage : 20.5 + plinthe 19 + recul 20.
     */
    lateralNearestHoleFromSideWithCladdingMm: 15.5,
    lateralNearestHoleFromSideWithPlinthMm: 20.5 + 19 + 20,
    holeDiameterMm: 10,
    holeDepthMm: 12,
    dowelDiameterMm: 10.4,
    dowelDepthMm: 11,
    holeOffsetsFromCenterMm: [
      { x: -32, y: 32 },
      { x: 32, y: 32 },
      { x: -32, y: -32 },
      { x: 32, y: -32 }
    ]
  },
  plinthSupport: {
    articleNumber: '637.47.490',
    quantityPerFrontFoot: 1,
    cncMachining: false
  },
  clipsPerMeter: 3,          // compatibilité des anciens devis
  /** Entraxe max entre axes de pieds (avant+arrière) sur la largeur de l'armoire. */
  maxFootSpacingMm: 600,
  // Reserved packing space for hardware kit
  packingReserved: true,
};

export function normalizeAxiloTargetHeightMm(value, fallbackMm = 100) {
  const requested = Number(value);
  const fallback = Number(fallbackMm);
  const reference = Number.isFinite(requested) ? requested : (Number.isFinite(fallback) ? fallback : 100);
  return PLINTH.targetHeightsMm.reduce(
    (best, candidate) =>
      Math.abs(candidate - reference) < Math.abs(best - reference) ? candidate : best,
    PLINTH.targetHeightsMm[0]
  );
}

/** Hauteur finie du panneau de plinthe (jeu supérieur fournisseur de 5 mm). */
export function getAxiloPlinthPanelHeightMm(targetHeightMm) {
  return Math.max(0, normalizeAxiloTargetHeightMm(targetHeightMm) - PLINTH.panelTopClearanceMm);
}

/** Habillage latéral jusqu'au sol (installation libre uniquement). */
export function hasSideHabillage(config = {}, side = 'left') {
  if (config?.installationType !== 'free') return false;
  if (config?.exteriorFinishesEnabled === false) return false;
  const sideDefaults = config?.sideFinishesEnabled !== false;
  const enabled = side === 'right'
    ? (config?.sideFinishRightEnabled ?? sideDefaults)
    : (config?.sideFinishLeftEnabled ?? sideDefaults);
  return !!enabled;
}

/**
 * Côté libre sans habillage : retour de plinthe AXILO à la place du panneau
 * de finition jusqu'au sol. Niche : pas de retour (côté contre le mur).
 */
export function hasSidePlinthReturn(config = {}, side = 'left') {
  return config?.installationType === 'free' && !hasSideHabillage(config, side);
}

/** Longueur d'un retour de plinthe le long de la profondeur (recul avant 20 mm). */
export function getAxiloPlinthReturnLengthMm(depthMm) {
  return Math.max(0, Number(depthMm) - PLINTH.frontSetbackMm);
}

/**
 * Déduction latérale de la plinthe avant : habillage 19 mm au nu extérieur,
 * ou recul 20 mm + épaisseur du retour (le retour n'est pas au nu du côté).
 */
export function getAxiloPlinthFrontSideDeductionMm(config = {}, side = 'left') {
  if (hasSideHabillage(config, side)) return PLINTH.panelThicknessMm;
  if (hasSidePlinthReturn(config, side)) return PLINTH.frontSetbackMm + PLINTH.panelThicknessMm;
  return 0;
}

/** Portée latérale des perçages AXILO depuis le centre de platine (32 mm). */
export function getAxiloHoleReachXMm() {
  return Math.max(
    0,
    ...PLINTH.mountingPlate.holeOffsetsFromCenterMm.map((p) => Math.abs(Number(p.x) || 0))
  );
}

/**
 * Centre de platine depuis le chant latéral du fond, pour que le trou le plus
 * proche respecte 15.5 mm (habillage) ou 20.5 + 19 + 20 (retour de plinthe).
 */
export function getAxiloLateralCenterInsetMm(hasSideCladding) {
  const holeInset = hasSideCladding
    ? PLINTH.mountingPlate.lateralNearestHoleFromSideWithCladdingMm
    : PLINTH.mountingPlate.lateralNearestHoleFromSideWithPlinthMm;
  return holeInset + getAxiloHoleReachXMm();
}

/**
 * Axes X des platines AXILO sur une largeur d'armoire : 2 axes d'extrémité
 * (4 pieds) + 1 axe intermédiaire (2 pieds) dès que l'entraxe dépasserait 600 mm.
 */
export function getAxiloFootXAxesMm(spanWidthMm, leftInsetMm, rightInsetMm) {
  const width = Math.max(0, Number(spanWidthMm) || 0);
  const holeReach = getAxiloHoleReachXMm();
  const leftInset = Math.max(holeReach, Number(leftInsetMm) || holeReach);
  const rightInset = Math.max(holeReach, Number(rightInsetMm) || holeReach);
  const minX = Math.min(leftInset, width / 2);
  const maxX = Math.max(minX, width - Math.min(rightInset, width / 2));
  const span = maxX - minX;
  const round2 = (v) => Math.round(v * 100) / 100;
  if (span < 0.5) return [round2(minX)];
  const intervals = Math.max(1, Math.ceil(span / PLINTH.maxFootSpacingMm));
  const axes = [];
  for (let i = 0; i <= intervals; i++) {
    const x = round2(minX + (span * i) / intervals);
    if (!axes.some((existing) => Math.abs(existing - x) < 0.5)) axes.push(x);
  }
  return axes;
}

/**
 * Centres des platines sous le fond.
 * 4 pieds aux extrémités de l'armoire + 2 pieds (avant/arrière) tous les 600 mm.
 * Si `spanWidthMm` / `panelOffsetMm` sont fournis, les axes sont calculés sur
 * toute l'armoire puis projetés sur ce panneau de fond.
 */
export function getAxiloPlateCentersMm(panelWidthMm, panelDepthMm, options = {}) {
  const width = Math.max(0, Number(panelWidthMm) || 0);
  const depth = Math.max(0, Number(panelDepthMm) || 0);
  const holeReach = getAxiloHoleReachXMm();
  const defaultInset = getAxiloLateralCenterInsetMm(true);
  const requestedLeftInset = Number(options.leftEdgeCenterInsetMm);
  const requestedRightInset = Number(options.rightEdgeCenterInsetMm);
  const leftInset = Math.max(
    holeReach,
    Number.isFinite(requestedLeftInset) ? requestedLeftInset : defaultInset
  );
  const rightInset = Math.max(
    holeReach,
    Number.isFinite(requestedRightInset) ? requestedRightInset : defaultInset
  );
  const spanWidth = Number(options.spanWidthMm);
  const layoutWidth = Number.isFinite(spanWidth) && spanWidth > 0 ? spanWidth : width;
  const offset = Number.isFinite(Number(options.panelOffsetMm))
    ? Number(options.panelOffsetMm)
    : 0;
  const assignMin = Number.isFinite(Number(options.assignMinMm))
    ? Number(options.assignMinMm)
    : offset;
  const assignMax = Number.isFinite(Number(options.assignMaxMm))
    ? Number(options.assignMaxMm)
    : offset + width;
  const assignMaxInclusive = options.assignMaxInclusive !== false;
  const globalAxes = getAxiloFootXAxesMm(layoutWidth, leftInset, rightInset);
  const xAxes = [];
  for (const gx of globalAxes) {
    const afterMin = gx >= assignMin - 0.05;
    const beforeMax = assignMaxInclusive
      ? gx <= assignMax + 0.05
      : gx < assignMax - 0.05;
    if (!afterMin || !beforeMax) continue;
    if (width < holeReach * 2) continue;
    const localX = Math.max(holeReach, Math.min(width - holeReach, gx - offset));
    const x = Math.round(localX * 100) / 100;
    if (!xAxes.some((existing) => Math.abs(existing - x) < 0.5)) xAxes.push(x);
  }
  const frontY = PLINTH.mountingPlate.frontCenterFromFrontMm;
  const requestedRearInset = Number(options.rearCenterFromRearMm);
  const rearCenterFromRearMm = Math.max(
    PLINTH.mountingPlate.rearCenterFromRearMm,
    Number.isFinite(requestedRearInset)
      ? requestedRearInset
      : PLINTH.mountingPlate.rearCenterFromRearMm
  );
  const rearY = depth - rearCenterFromRearMm;
  if (depth < frontY + rearCenterFromRearMm) return [];
  return xAxes.flatMap((xMm) => [
    { xMm, yMm: frontY, row: 'front' },
    { xMm, yMm: rearY, row: 'rear' }
  ]);
}

// ── 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 — Blum Legrabox pure) ─────────────────────────
export const DRAWERS = {
  maxColumnWidth: 1000,           // mm
  minDepth: 400,                  // mm
  maxDepth: 650,                  // mm
  depthStep: 50,                  // mm
  hiddenHandleDepthReduction: 40, // mm (assumption until final handle specs)
  /** Hauteurs de côté Legrabox (N/M/K/C/F). L'ancien 60 mm est remplacé par 66 mm (système N). */
  standardHeights: [...LEGRABOX_SIDE_HEIGHTS_MM],
};

/**
 * Hauteur de façade (encombrement niche SMS) pour une hauteur de côté Legrabox.
 * 66→80 · 90→106 · 128→144 · 177→193 · 240→257. Héritage : 60 mm ≡ système N (66).
 */
export function drawerFacadeHeightMm(sideHeightMm) {
  const h = Number(sideHeightMm) === 60 ? 66 : Number(sideHeightMm);
  return legraboxNicheHeightMm(h);
}

/**
 * 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, mm — norme SMS / Blum Legrabox :
 * chaque tiroir occupe sa hauteur de NICHE (encombrement façade min : 80/106/144/193/257),
 * le jeu entre façades est pris DANS la niche (façade = niche − jeu).
 * @param {number} drawerCount
 * @param {number[]} drawerHeightsMm — hauteurs de côté Legrabox (66/90/128/177/240)
 * @param {number} [drawerGapMm] — conservé pour compat ; le jeu est inclus dans la niche
 */
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 picked = [];
  for (let i = 0; i < n; i++) {
    const v = Number(heights[Math.min(i, heights.length - 1)]) || 0;
    picked.push(drawerFacadeHeightMm(v));
  }
  const sum = picked.reduce((s, v) => s + v, 0);
  return Math.max(0, Math.round(sum));
}

/** Hauteurs de niche par tiroir (mm), du bas vers le haut. */
export function drawerNicheHeightsMm(drawerCount, drawerHeightsMm) {
  const n = Math.max(0, Number(drawerCount) || 0);
  const heights = Array.isArray(drawerHeightsMm) && drawerHeightsMm.length ? drawerHeightsMm : DRAWERS.standardHeights;
  const out = [];
  for (let i = 0; i < n; i++) {
    const v = Number(heights[Math.min(i, heights.length - 1)]) || 0;
    out.push(drawerFacadeHeightMm(v));
  }
  return out;
}

// ── 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
  /** Jeu entre double montants (assemblage caisson↔caisson). */
  jointGapMm: 3
};

/** Colonne rayonnage (étagères) — caisson block même sans dos. */
export function isRayonnageModule(mod) {
  const t = String(mod?.type || mod?.moduleCode || '').toLowerCase();
  if (t === 'rayonnage') return true;
  const shelves = Number(mod?.shelves) || 0;
  if (t === 'mixte') return shelves > 0;
  // A penderie keeps a single top shelf; 2+ shelves is rayonnage construction.
  return shelves >= 2;
}

/**
 * Construction caisson (block) vs séparations, par zone.
 * Règle: dos → block ; sinon côté (montant extérieur) ou rayonnage → block.
 * Les côtés extérieurs sont toujours en construction block (jonction à l'angle).
 */
export function usesBlockConstruction(mod, hasDos) {
  if (hasDos) return true;
  return isRayonnageModule(mod);
}

/** Dos d'une zone (blockIndex: 0 = bas). Défaut aligné sur le configurateur (false si non renseigné). */
export function moduleZoneHasBack(mod, config = {}, blockIndex = 0) {
  const heights = Array.isArray(mod?.blockHeightsMm)
    ? mod.blockHeightsMm.map(Number).filter((v) => Number.isFinite(v) && v > 0)
    : [];
  const n = Math.max(1, heights.length);
  const i = Math.max(0, Math.min(n - 1, Number(blockIndex) || 0));
  const arr = Array.isArray(mod?.blockBacks) ? mod.blockBacks : null;
  if (arr && typeof arr[i] === 'boolean') return arr[i];
  if (i === n - 1 && n >= 2 && typeof mod?.hasBackTop === 'boolean') return mod.hasBackTop;
  if (typeof mod?.hasBack === 'boolean') return mod.hasBack;
  return config?.hasBack === true;
}

/**
 * Colonne en caisson block si une zone a un dos, ou si c'est un rayonnage.
 * Les côtés extérieurs restent des montants block même si la colonne est en séparations.
 */
export function columnUsesBlockConstruction(mod, config = {}, blockCount = null) {
  if (isRayonnageModule(mod)) return true;
  const n = Math.max(
    1,
    Number.isFinite(Number(blockCount)) && Number(blockCount) > 0
      ? Number(blockCount)
      : (Array.isArray(mod?.blockHeightsMm) ? mod.blockHeightsMm.filter((v) => Number(v) > 0).length : 1)
  );
  for (let k = 0; k < n; k++) {
    if (moduleZoneHasBack(mod, config, k)) return true;
  }
  return false;
}

/**
 * Segments dessus (`level: 'top'`) ou fond (`level: 'bottom'`):
 * 1 segment par caisson block, colonnes en séparations contiguës fusionnées.
 */
export function horizontalConstructionRuns(modules = [], config = {}, level = 'top') {
  const mods = Array.isArray(modules) ? modules.filter(Boolean) : [];
  const n = mods.length;
  const bodyMm = Math.max(
    0,
    (Number(config?.heightMm) || 0) - (Number(config?.plinthHeightMm) || 0)
  );
  const edgeSpansByStart = new Map(
    (Array.isArray(config?.horizontalSpans) ? config.horizontalSpans : [])
      .map((span) => resolveHorizontalSpan(span, { ...config, modules: mods }))
      .filter((resolved) => {
        if (!resolved || resolved.moduleIndexes.length < 2) return false;
        return level === 'bottom'
          ? Math.abs(resolved.bottomMm) <= SPAN_EPSILON_MM
          : Math.abs(resolved.topMm - bodyMm) <= SPAN_EPSILON_MM;
      })
      .map((resolved) => [resolved.moduleIndexes[0], resolved])
  );
  const blockIndexOf = (mod) => {
    const heights = Array.isArray(mod?.blockHeightsMm)
      ? mod.blockHeightsMm.map(Number).filter((v) => Number.isFinite(v) && v > 0)
      : [];
    const count = Math.max(1, heights.length);
    return level === 'bottom' ? 0 : count - 1;
  };
  const isBlockAt = (index) => columnUsesBlockConstruction(mods[index], config);
  const runs = [];
  let i = 0;
  while (i < n) {
    const edgeSpan = edgeSpansByStart.get(i);
    if (edgeSpan) {
      const end = edgeSpan.moduleIndexes[edgeSpan.moduleIndexes.length - 1];
      runs.push({
        start: i,
        end,
        isBlock: true,
        hasBack: Boolean(edgeSpan.span.hasBack),
        horizontalSpanId: edgeSpan.span.id
      });
      i = end + 1;
      continue;
    }
    if (isBlockAt(i)) {
      runs.push({
        start: i,
        end: i,
        isBlock: true,
        hasBack: moduleZoneHasBack(mods[i], config, blockIndexOf(mods[i]))
      });
      i += 1;
    } else {
      let j = i;
      while (j + 1 < n && !isBlockAt(j + 1) && !edgeSpansByStart.has(j + 1)) j += 1;
      runs.push({ start: i, end: j, isBlock: false, hasBack: false });
      i = j + 1;
    }
  }
  return runs;
}

// ── 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],
  /**
   * Décalage vers l'avant de la rangée arrière T–IX–T sur un fond avec rainure
   * et pieds AXILO. Un quart de l'entraxe 64 mm évite l'alignement des perçages.
   */
  axiloGrooveRearRowShiftMm: 16,
  /** 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,
};