// [2240 KERAB-OFFSET-SURGICAL 2026-05-27] 케라바 forward/revert 시 出幅(offset) 변경분만
//   target 의 matchingRoofLine + 인접 2 corner roof.points + corner 에 닿은 inner line 끝점
//   + lengthText 라벨을 surgical 갱신. SK 재실행 없이 다른 벽의 케라바 패턴 보존.
//
//   고객 회귀 검증을 위해 본 로직 전체를 useEavesGableEdit.js 에서 분리.
//   호출 ON/OFF 는 useEavesGableEdit.js 상단 `ENABLE_KERAB_OFFSET_SURGICAL` 상수로 토글한다.

import { fabric } from 'fabric'
import { POLYGON_TYPE } from '@/common/common'
import { calcLinePlaneSize } from '@/util/qpolygon-utils'
import { logger } from '@/util/logger'

const lineLineIntersection = (p1, p2, p3, p4) => {
  const d = (p1.x - p2.x) * (p3.y - p4.y) - (p1.y - p2.y) * (p3.x - p4.x)
  if (Math.abs(d) < 1e-6) return null
  const t = ((p1.x - p3.x) * (p3.y - p4.y) - (p1.y - p3.y) * (p3.x - p4.x)) / d
  return { x: p1.x + t * (p2.x - p1.x), y: p1.y + t * (p2.y - p1.y) }
}

/**
 * @param canvas    fabric canvas
 * @param target    outerLine fabric 객체 (target.attributes 는 OLD 상태로 호출되어야 함)
 * @param newOffset 새 출폭 (canvas 단위)
 * @param options   { skipInnerLines?: boolean }
 *   skipInnerLines=true 면 innerLines 루프(CORNER-SHORTCUT / SHRINK-TRIM / KERAB-PATTERN-CORNER-SNAP) 전체 skip.
 *   [KERAB-REVERT-EXTEND-45 2026-06-05] 룰: 출폭 변경 시 wallbaseLine 안의 내부라인 끝점은 절대 이동 X.
 *     roofLine 코너로 스냅(CORNER-SHORTCUT)·__shrinkOrig 로 복원(SHRINK-TRIM) 둘 다 룰 위반.
 *     호출자(revert)가 별도 ray-cast 로 hip 의 outer endpoint 만 새 rL 변까지 45° 확장한다.
 * @returns true=적용됨 / false=조건 미달 또는 변경 없음
 */
export const applyKerabOffsetSurgical = (canvas, target, newOffset, options = {}) => {
  const { skipInnerLines = false, skipKerabHips = false } = options
  const roof = canvas
    .getObjects()
    .find((o) => o.name === POLYGON_TYPE.ROOF && !o.isFixed && o.id === target.attributes?.roofId)
  if (!roof || !Array.isArray(roof.lines) || !Array.isArray(roof.points)) return false
  const idx = roof.lines.findIndex((rl) => rl && rl.attributes?.wallLine === target.id)
  if (idx < 0) return false
  const matchingRL = roof.lines[idx]
  const oldOffset = matchingRL.attributes?.offset ?? 0
  if (Math.abs(newOffset - oldOffset) < 1e-3) return false

  // [RIDGE-DIAG 2026-06-10] 자연 마루(ridge) 길이 간헐 변동 추적 — surgical 진입 전 before 스냅샷,
  //   함수 종료 직전 길이 비교. 처마/케라바/revert(skipInnerLines 포함) 모든 경로 감시.
  //   출폭 변경 시 자연 마루 끝점(apex)은 wallLine 안쪽이라 불변이 룰 → 길이 변동은 버그.
  //   kerabPatternRidge(kLine)/kerabPatternExtRidge 는 출폭에 따라 정상적으로 신축 → 감시 제외.
  const isRidgeDiagLine = (il) => il && il.lineName === 'ridge'
  const ridgeDiagBefore = new Map()
  for (const il of roof.innerLines || []) {
    if (isRidgeDiagLine(il)) {
      ridgeDiagBefore.set(il, { x1: il.x1, y1: il.y1, x2: il.x2, y2: il.y2, len: Math.hypot(il.x2 - il.x1, il.y2 - il.y1) })
    }
  }

  const N = roof.lines.length
  const prevRL = roof.lines[(idx - 1 + N) % N]
  const nextRL = roof.lines[(idx + 1) % N]

  // target wall edge 의 outward unit normal — matchingRL 현재 위치로 sign 추정 (oldOffset=0 시 centroid 폴백).
  const tdx = target.x2 - target.x1
  const tdy = target.y2 - target.y1
  const tL = Math.hypot(tdx, tdy) || 1
  let nx = -tdy / tL
  let ny = tdx / tL
  const tMid = { x: (target.x1 + target.x2) / 2, y: (target.y1 + target.y2) / 2 }
  if (Math.abs(oldOffset) > 1e-6) {
    const mMid = { x: (matchingRL.x1 + matchingRL.x2) / 2, y: (matchingRL.y1 + matchingRL.y2) / 2 }
    if ((mMid.x - tMid.x) * nx + (mMid.y - tMid.y) * ny < 0) {
      nx = -nx
      ny = -ny
    }
  } else {
    let cx = 0
    let cy = 0
    for (const p of roof.points) {
      cx += p.x
      cy += p.y
    }
    cx /= roof.points.length
    cy /= roof.points.length
    if ((tMid.x - cx) * nx + (tMid.y - cy) * ny < 0) {
      nx = -nx
      ny = -ny
    }
  }

  // 새 matchingRL axis 와 prev/nextRL 무한확장 교점.
  const newAxisP1 = { x: target.x1 + nx * newOffset, y: target.y1 + ny * newOffset }
  const newAxisP2 = { x: target.x2 + nx * newOffset, y: target.y2 + ny * newOffset }
  const newCorner1 = lineLineIntersection(
    { x: prevRL.x1, y: prevRL.y1 },
    { x: prevRL.x2, y: prevRL.y2 },
    newAxisP1,
    newAxisP2,
  )
  const newCorner2 = lineLineIntersection(
    newAxisP1,
    newAxisP2,
    { x: nextRL.x1, y: nextRL.y1 },
    { x: nextRL.x2, y: nextRL.y2 },
  )
  if (!newCorner1 || !newCorner2) {
    logger.log('[KERAB-OFFSET-SURGICAL] intersect failed — skip surgical update')
    return false
  }

  const oldCorner1 = { x: roof.points[idx].x, y: roof.points[idx].y }
  const oldCorner2 = { x: roof.points[(idx + 1) % N].x, y: roof.points[(idx + 1) % N].y }

  matchingRL.set({ x1: newCorner1.x, y1: newCorner1.y, x2: newCorner2.x, y2: newCorner2.y })
  prevRL.set({ x2: newCorner1.x, y2: newCorner1.y })
  nextRL.set({ x1: newCorner2.x, y1: newCorner2.y })

  const newSize = calcLinePlaneSize({ x1: newCorner1.x, y1: newCorner1.y, x2: newCorner2.x, y2: newCorner2.y })
  matchingRL.attributes = {
    ...matchingRL.attributes,
    offset: newOffset,
    planeSize: newSize,
    actualSize: newSize,
  }
  const prevSize = calcLinePlaneSize({ x1: prevRL.x1, y1: prevRL.y1, x2: prevRL.x2, y2: prevRL.y2 })
  prevRL.attributes = { ...prevRL.attributes, planeSize: prevSize, actualSize: prevSize }
  const nextSize = calcLinePlaneSize({ x1: nextRL.x1, y1: nextRL.y1, x2: nextRL.x2, y2: nextRL.y2 })
  nextRL.attributes = { ...nextRL.attributes, planeSize: nextSize, actualSize: nextSize }

  // [KERAB-OFFSET-SHRINK-TRIM 2026-06-01] 도메인 룰:
  //   - 기본: skLine + ext 원본 좌표 보존.
  //   - 원본 끝점이 새 roofLine 변 바깥(wall 쪽)에 있으면 새 roofLine 변과의 교점으로 절삭.
  //   - 원본 끝점이 새 roofLine 변 안쪽으로 복귀하면 원본 좌표로 복원 (출폭 다시 늘린 케이스).
  //   원본 좌표는 il.__shrinkOrig 에 보관 — 첫 절삭 시점에 백업, 양 끝 모두 안쪽으로 복귀 시 삭제.
  //   매 surgical 호출마다 원본 기반으로 재계산하므로 출폭 증감 무관 idempotent.
  if (!skipInnerLines) {
    // [KERAB-PATTERN-CORNER-SNAP 2026-06-01] 케라바 패턴 라인(kLine/ExtRidge/Hip/ExtHip)은
    //   roofLine corner 변경에 따라 끝점도 같이 이동. corner 일치뿐 아니라 옛 segment 위의
    //   중간 점(예: kLine 끝점이 옛 roofLine 변 위)도 새 segment 의 동일 t 비율 점으로 매핑.
    const isKerabPatternLine = (il) =>
      il &&
      (il.lineName === 'kerabPatternRidge' ||
        il.lineName === 'kerabPatternExtRidge' ||
        il.lineName === 'kerabPatternHip' ||
        il.lineName === 'kerabPatternExtHip' ||
        il.lineName === 'kerabPatternValleyExt' ||
        il.lineName === 'kerabValleyOverlapLine')
    const oldSegDx = oldCorner2.x - oldCorner1.x
    const oldSegDy = oldCorner2.y - oldCorner1.y
    const oldSegLen2 = oldSegDx * oldSegDx + oldSegDy * oldSegDy || 1
    const newSegDx = newCorner2.x - newCorner1.x
    const newSegDy = newCorner2.y - newCorner1.y
    const mapToNewSeg = (pt) => {
      const dx = pt.x - oldCorner1.x
      const dy = pt.y - oldCorner1.y
      const t = (dx * oldSegDx + dy * oldSegDy) / oldSegLen2
      const projX = oldCorner1.x + t * oldSegDx
      const projY = oldCorner1.y + t * oldSegDy
      const perpD = Math.hypot(pt.x - projX, pt.y - projY)
      if (perpD > 0.5) return null
      if (t < -0.05 || t > 1.05) return null
      return { x: newCorner1.x + t * newSegDx, y: newCorner1.y + t * newSegDy }
    }
    // [KERAB-APEX-INVARIANT 2026-06-10] skeleton 교점(junction) 판별식(기하, lineName 아님).
    //   한 점이 다른 내부선 ≥1개의 끝점과 공유되면 그 점은 라인끼리 만나는 junction 이다.
    //   junction 은 wallLine 이 정하는 고정점이라 出幅 변경과 무관 → CORNER-SNAP/CASCADE 가 끌면 안 됨.
    //   degree≥1 임계: Y 형 apex(ridge·2hip, degree 2)뿐 아니라 케라바 병합 후 콜리니어 ridge 하나만
    //   남은 junction(degree 1)도 잡아야 한다. (degree≥2 였을 때 병합 apex 를 놓쳐 kLine 의 apex 끝을
    //   끌고 자연 ridge 까지 cascade → 마루 길이 증가 + revert R1-dangling 발생.) vExt 는 !isVExt 로 제외.
    const APEX_SHARE_TOL = 2.0
    const skeletonApexDegree = (pt, selfLine) => {
      let deg = 0
      for (const o of roof.innerLines || []) {
        if (!o || o === selfLine || o.visible === false) continue
        if (
          Math.hypot(o.x1 - pt.x, o.y1 - pt.y) < APEX_SHARE_TOL ||
          Math.hypot(o.x2 - pt.x, o.y2 - pt.y) < APEX_SHARE_TOL
        )
          deg++
      }
      return deg
    }
    // [KERAB-OFFSET-FUNCTIONIZE 2026-06-10] 라인 성격별 독립 핸들러.
    //   두 핸들러는 공유 가변상태 없이 각자 il 만 갱신 → 골짜기↔일반 상호 간섭(whack-a-mole) 차단.
    //   케라바 패턴 라인: 옛 roofLine segment 위 끝점 → 새 segment 의 동일 t 점.
    //   한 끝만 segment 위(vExt 등 self-extension)일 때는 다른 끝도 같은 변위로 평행 이동 →
    //   직각/형상 보존. 절삭/복원 흐름 skip.
    const recomputeKerabPatternLine = (il) => {
        const oldX1 = il.x1
        const oldY1 = il.y1
        const oldX2 = il.x2
        const oldY2 = il.y2
        const np1 = mapToNewSeg({ x: il.x1, y: il.y1 })
        const np2 = mapToNewSeg({ x: il.x2, y: il.y2 })
        // [KERAB-APEX-INVARIANT 2026-06-10] 한 끝만 roofLine 에 매핑될 때:
        //   매핑 안 된 끝점이 junction(다른 내부선 ≥1 공유)이면 出幅 무관 고정점 →
        //   이동 금지(junction 중심 pivot). vExt(수직 self-extension)는 우선순위상 평행이동 유지.
        //   그 외(free 끝점, degree 0)만 같은 변위 평행이동(직각/형상 보존).
        const isVExt = il.lineName === 'kerabPatternValleyExt'
        let apexPivot = false
        if (np1 && np2) {
          il.set({ x1: np1.x, y1: np1.y, x2: np2.x, y2: np2.y })
        } else if (np1 && !np2) {
          if (!isVExt && skeletonApexDegree({ x: il.x2, y: il.y2 }, il) >= 1) {
            il.set({ x1: np1.x, y1: np1.y })
            apexPivot = true
          } else {
            const dx = np1.x - il.x1
            const dy = np1.y - il.y1
            il.set({ x1: np1.x, y1: np1.y, x2: il.x2 + dx, y2: il.y2 + dy })
          }
        } else if (!np1 && np2) {
          if (!isVExt && skeletonApexDegree({ x: il.x1, y: il.y1 }, il) >= 1) {
            il.set({ x2: np2.x, y2: np2.y })
            apexPivot = true
          } else {
            const dx = np2.x - il.x2
            const dy = np2.y - il.y2
            il.set({ x1: il.x1 + dx, y1: il.y1 + dy, x2: np2.x, y2: np2.y })
          }
        }
        if (typeof il.setCoords === 'function') il.setCoords()
        if (isRidgeDiagLine(il)) il.__ridgeDiagBranch = `PATTERN-MAP np1=${!!np1} np2=${!!np2}`
        if (np1 || np2) {
          logger.log(
            '[KERAB-PATTERN-CORNER-SNAP] mapped ' +
              JSON.stringify({ lineName: il.lineName, np1, np2, newPts: { x1: il.x1, y1: il.y1, x2: il.x2, y2: il.y2 } }),
          )
          // [KERAB-PATTERN-CASCADE 2026-06-01] vExt 등 평행 이동 시 옛 끝점에 닿아있던
          //   다른 innerLine 끝점도 같은 변위로 평행 이동. RG-1 의 valley-trim 결과 끝점이
          //   vExt 끝점과 분리되어 split graph 의 closed path 안 만들어지는 문제 해소.
          // cascade: vExt 옛 segment 위에 끝점이 있는 다른 innerLine 도 같은 변위로 평행 이동.
          //   끝점-끝점 일치 외에 segment 위 중간 점(예: kLine 끝점이 vExt segment 위)도 매칭.
          //   케라바 패턴 라인 가드 제거 — 자체 매핑된 라인은 이미 새 좌표라 옛 segment 위 X → 자동 skip.
          const dxVExt = il.x1 - oldX1
          const dyVExt = il.y1 - oldY1
          const pointOnOldSeg = (px, py) => {
            const sdx = oldX2 - oldX1
            const sdy = oldY2 - oldY1
            const slen2 = sdx * sdx + sdy * sdy
            if (slen2 < 1e-6) return Math.hypot(px - oldX1, py - oldY1) < 1.0
            const t = ((px - oldX1) * sdx + (py - oldY1) * sdy) / slen2
            if (t < -0.02 || t > 1.02) return false
            const projX = oldX1 + t * sdx
            const projY = oldY1 + t * sdy
            return Math.hypot(px - projX, py - projY) < 1.0
          }
          // [KERAB-APEX-INVARIANT 2026-06-10] apex pivot(매핑 안 된 끝점이 apex 라 고정)인 경우는
          //   라인이 평행이동이 아니라 apex 중심 회전이므로 cascade 금지 — apex 공유 ridge/hip 끌림 방지.
          //   vExt 등 실제 평행이동(양 끝 같은 변위)일 때만 옛 segment 위 끝점 전파.
          if (!apexPivot && Math.hypot(dxVExt, dyVExt) > 0.01) {
            // cascade 대상: roof.innerLines + canvas 의 kerabValleyOverlapLine (innerLines 미포함).
            //   overlap 보조선들은 vExt 의 끝점과 90도로 만나므로 vExt 이동에 같이 따라가야 정합.
            const overlapInCanvas = (canvas.getObjects() || []).filter(
              (o) =>
                o &&
                o.lineName === 'kerabValleyOverlapLine' &&
                (o.roofId === roof.id || o.attributes?.roofId === roof.id),
            )
            const cascadeTargets = [...(roof.innerLines || []), ...overlapInCanvas]
            for (const other of cascadeTargets) {
              if (!other || other === il) continue
              let moved = false
              const hit1 = pointOnOldSeg(other.x1, other.y1)
              const hit2 = pointOnOldSeg(other.x2, other.y2)
              // [KERAB-VALLEY-EXT-PARALLEL 2026-06-05] vExt(골짜기 확장라인)는 self-extension
              //   수직/수평 라인이라 한 끝만 cascade 로 끌면 대각선이 된다 (사용자 룰: 대각선은 hip뿐).
              //   split 된 vExt 세그먼트는 한 끝만 옛 segment 에 닿아도 양 끝을 같은 변위로 평행이동.
              if (other.lineName === 'kerabPatternValleyExt' && (hit1 || hit2)) {
                other.set({
                  x1: other.x1 + dxVExt,
                  y1: other.y1 + dyVExt,
                  x2: other.x2 + dxVExt,
                  y2: other.y2 + dyVExt,
                })
                moved = true
              } else {
                if (hit1) {
                  other.set({ x1: other.x1 + dxVExt, y1: other.y1 + dyVExt })
                  moved = true
                }
                if (hit2) {
                  other.set({ x2: other.x2 + dxVExt, y2: other.y2 + dyVExt })
                  moved = true
                }
              }
              if (moved) {
                if (typeof other.setCoords === 'function') other.setCoords()
                logger.log(
                  '[KERAB-PATTERN-CASCADE] moved ' +
                    JSON.stringify({
                      lineName: other.lineName,
                      name: other.name,
                      dx: dxVExt,
                      dy: dyVExt,
                      newPts: { x1: other.x1, y1: other.y1, x2: other.x2, y2: other.y2 },
                    }),
                )
              }
            }
          }
        }
    }

    const recomputeNormalLine = (il) => {
      // [KERAB-OFFSET-NORMAL-ABS 2026-06-10] 일반 라인(힙/마루/골짜기) 절대 재계산.
      //   도메인: 모든 끝점은 둘 중 하나 —
      //     (a) anchor = apex(wallLine 이 정하는 skeleton 교점) 또는 변경 무관한 다른 roofLine 변 위 점 → 出幅 불변, 고정.
      //     (b) hit = 변경된 roofLine 변(oldCorner1→oldCorner2) 위의 처마 끝 → 새 변으로 다시 그린다.
      //   변경 변과 무관한 라인(양 끝 모두 hit 아님)은 그대로. 증감·복원 분기 불필요(절대값이라 idempotent).
      //   __shrinkOrig snapshot 제거 — apex 가 이미 불변(현재값=원본)이라 스냅샷 없이 매번 절대 재계산.
      //   hit 재계산 규칙:
      //     - 끝점이 옛 corner 와 일치 → 새 corner 로 snap. (코너는 인접 변끼리의 교점이라
      //       라인 자기 방향 교점과 위치가 다르다 → 반드시 코너로 보정. 구 CORNER-SHORTCUT 의 기하 근거.)
      //     - 끝점이 변 중간(mid-edge) → anchor→hit 라인 방향 보존하며 새 변과의 교점. 방향은 평행
      //       出幅 변경에 불변(skeleton 각이등분선)이라 교점이 곧 새 처마 끝. 증가=확장/감소=절삭 동일식.
      const CORNER_TOL = 0.5
      const atCorner = (px, py) => {
        if (Math.hypot(px - oldCorner1.x, py - oldCorner1.y) < CORNER_TOL) return newCorner1
        if (Math.hypot(px - oldCorner2.x, py - oldCorner2.y) < CORNER_TOL) return newCorner2
        return null
      }
      const e1 = { x: il.x1, y: il.y1 }
      const e2 = { x: il.x2, y: il.y2 }
      const m1 = mapToNewSeg(e1)
      const m2 = mapToNewSeg(e2)
      // 변경 변에 닿지 않는 라인(마루 등) → 무동작.
      if (!m1 && !m2) return
      const c1 = atCorner(e1.x, e1.y)
      const c2 = atCorner(e2.x, e2.y)
      let n1 = e1
      let n2 = e2
      let branch = ''
      if (m1 && m2 && !c1 && !c2) {
        // 양 끝 모두 변 중간 → 변 위에 누운 라인(드묾). t 비율로 매핑.
        n1 = m1
        n2 = m2
        branch = 'BOTH-MID'
      } else {
        if (c1) {
          n1 = c1
        } else if (m1) {
          // [KERAB-OFFSET-COLLINEAR 2026-06-11] 라인 방향이 변과 평행(변 위에 누운 면경계 세그먼트)이면
          //   교점이 없어 ip=null → 옛날엔 return 으로 라인 통째 포기(=옛 위치 ghost). 이때는 변이
          //   평행이동했으므로 mapToNewSeg(m1) 의 t-비율 투영이 곧 새 변 위 대응점 → 그걸로 폴백.
          const ip = lineLineIntersection(e2, e1, newCorner1, newCorner2)
          n1 = ip || m1
        }
        if (c2) {
          n2 = c2
        } else if (m2) {
          const ip = lineLineIntersection(e1, e2, newCorner1, newCorner2)
          n2 = ip || m2
        }
        branch = `c1=${!!c1} c2=${!!c2} m1=${!!m1} m2=${!!m2}`
      }
      il.set({ x1: n1.x, y1: n1.y, x2: n2.x, y2: n2.y })
      if (typeof il.setCoords === 'function') il.setCoords()
      if (isRidgeDiagLine(il)) il.__ridgeDiagBranch = `NORMAL-ABS ${branch}`
      logger.log(
        '[KERAB-OFFSET-NORMAL-ABS] ' +
          JSON.stringify({ lineName: il.lineName, branch, newPts: { x1: il.x1, y1: il.y1, x2: il.x2, y2: il.y2 } }),
      )
    }

    // [KERAB-OFFSET-FUNCTIONIZE 2026-06-10] dispatch — 라인 성격으로만 분기.
    //   골짜기(케라바 패턴) 라인과 일반 라인은 각자 독립 핸들러로 처리되어 서로 간섭하지 않는다.
    for (const il of roof.innerLines || []) {
      if (!il) continue
      // [KERAB-HIP-45-PROTECT 2026-06-15] 케라바 hip(확장라인)은 CORNER-SNAP 금지 —
      //   호출자(reclick 45° 블록)가 wall 코너에서 45° ray-cast 로 roofLine 까지 뻗는다.
      //   여기서 recomputeKerabPatternLine 의 t-ratio 매핑을 타면 roofLine 코너로 스냅돼 룰 위반.
      if (skipKerabHips && il.lineName === 'kerabPatternHip') continue
      if (isKerabPatternLine(il)) recomputeKerabPatternLine(il)
      else recomputeNormalLine(il)
    }
  }

  // points 는 새 배열로 set 해야 fabric 의 dirty 감지가 동작.
  // [KERAB-OFFSET-SURGICAL 2026-05-29] 출폭 증가 시 새 corner 가 polygon bbox 밖에 있으면
  //   외곽선이 안 그려짐. _setPositionDimensions 로 width/height/pathOffset 재계산 + 앵커
  //   절대좌표 보존(setPositionByOrigin) 으로 polygon path 가 새 영역까지 다시 그려지게 강제.
  const newPoints = roof.points.map((p, i) => {
    if (i === idx) return { x: newCorner1.x, y: newCorner1.y }
    if (i === (idx + 1) % N) return { x: newCorner2.x, y: newCorner2.y }
    return { x: p.x, y: p.y }
  })
  let absolutePoint = null
  let anchorIdx = 0
  // 변경 대상이 아닌 첫 인덱스를 앵커로 — pathOffset 갱신 후 그 점 절대 좌표 보존.
  for (let i = 0; i < roof.points.length; i++) {
    if (i !== idx && i !== (idx + 1) % N) {
      anchorIdx = i
      break
    }
  }
  try {
    if (typeof roof.calcTransformMatrix === 'function' && roof.pathOffset) {
      const oldLocal = {
        x: roof.points[anchorIdx].x - roof.pathOffset.x,
        y: roof.points[anchorIdx].y - roof.pathOffset.y,
      }
      absolutePoint = fabric.util.transformPoint(oldLocal, roof.calcTransformMatrix())
    }
  } catch (e) {
    absolutePoint = null
  }

  roof.points = newPoints
  roof.set({ points: newPoints, dirty: true })
  if (typeof roof._setPositionDimensions === 'function') roof._setPositionDimensions({})
  if (absolutePoint && typeof roof.setPositionByOrigin === 'function') {
    const strokeW = roof.strokeUniform ? roof.strokeWidth / Math.max(roof.scaleX || 1, 1e-9) : roof.strokeWidth
    const baseW = (roof.width || 0) + strokeW
    const baseH = (roof.height || 0) + (roof.strokeUniform ? roof.strokeWidth / Math.max(roof.scaleY || 1, 1e-9) : roof.strokeWidth)
    const newX = (roof.points[anchorIdx].x - roof.pathOffset.x) / Math.max(baseW, 1e-9)
    const newY = (roof.points[anchorIdx].y - roof.pathOffset.y) / Math.max(baseH, 1e-9)
    roof.setPositionByOrigin(absolutePoint, newX + 0.5, newY + 0.5)
  }
  if (typeof roof.setCoords === 'function') roof.setCoords()

  // canvas 에 add 된 동일 wallLine 매칭의 eaves(외곽 roofLine) fabric 객체도 같이 갱신.
  // [KERAB-OFFSET-SURGICAL 2026-05-29] outerLine 은 wall 좌표(출폭 0 기준) 유지가 원칙.
  //   corner 좌표(=wall + offset*normal) 로 set 하면 출폭 증가 시 외곽 처마라인이 통째로 이동해
  //   화면상 roofLine 이 안 그려진 듯 보임. outerLine 은 attributes 만 갱신, 좌표는 보존.
  const canvasEdgeObjs = canvas
    .getObjects()
    .filter(
      (o) =>
        o.parentId === roof.id &&
        (o.name === 'eaves' || o.lineName === 'roofLine' || o.name === 'outerLine') &&
        o.attributes?.wallLine === target.id,
    )
  for (const eo of canvasEdgeObjs) {
    if (eo.name !== 'outerLine') {
      eo.set({ x1: newCorner1.x, y1: newCorner1.y, x2: newCorner2.x, y2: newCorner2.y, dirty: true })
    }
    eo.attributes = { ...eo.attributes, offset: newOffset, planeSize: newSize, actualSize: newSize }
    if (typeof eo.setCoords === 'function') eo.setCoords()
  }
  if (typeof roof.addLengthText === 'function') roof.addLengthText()

  // [RIDGE-DIAG 2026-06-10] 마루 길이 변동 검사 — 0.5mm 넘게 변하면 어느 분기(branch)에서
  //   끌렸는지 + before/after 좌표를 warn 으로 남긴다. 우연 재발 시 콘솔에서 즉시 원인 특정.
  for (const [il, before] of ridgeDiagBefore) {
    const afterLen = Math.hypot(il.x2 - il.x1, il.y2 - il.y1)
    const delta = afterLen - before.len
    if (Math.abs(delta) > 0.5) {
      logger.warn(
        '[RIDGE-DIAG] 마루 길이 변동 ' +
          JSON.stringify({
            lineName: il.lineName,
            branch: il.__ridgeDiagBranch || '(no-branch/skipInnerLines?)',
            beforeLen: Math.round(before.len * 100) / 100,
            afterLen: Math.round(afterLen * 100) / 100,
            delta: Math.round(delta * 100) / 100,
            oldOffset,
            newOffset,
            before: { x1: before.x1, y1: before.y1, x2: before.x2, y2: before.y2 },
            after: { x1: il.x1, y1: il.y1, x2: il.x2, y2: il.y2 },
          }),
      )
    }
    delete il.__ridgeDiagBranch
  }

  canvas.renderAll()
  logger.log(
    '[KERAB-OFFSET-SURGICAL] applied ' +
      JSON.stringify({ idx, oldOffset, newOffset, oldCorner1, newCorner1, oldCorner2, newCorner2 }),
  )
  return true
}