Aislo/B05_Profile/logic/B05_Profile_RouteEdit_StationFit.ts

/* =============================================================================
 * B05_Profile/logic/B05_Profile_RouteEdit_StationFit.ts
 * 측점 스냅 켬 = 곡선 가운데(MC)를 일반측점에(366-3 · 요구 240-11) — 손 편집 평면.
 *
 * 추천 노선 맞춤(`B05_Profile_Engine_RouteInitial_Station.py` `_try` · `_solve`)을 줄인 꼴:
 *   · `from`(`fitStart` = 고친 자리 앞)부터 끝까지 차례로 — 고정 아닌 교각점(IP)을 들어오는 접선 따라 ±간격 안에서
 *     밀어 MC(BC · EC 누가거리 가운데)를 일반측점(앞 MC 측점 + 간격 이상 · No.1 이상)에 둠 — 내림 · 올림 후보 중 뒤 곡선도 서는 쪽(454).
 *   · 곡선 하한을 새로 깨거나(`shortfallCrossed`) 앞 곡선 MC 를 흔들면 버림 → 그 곡선은 그대로.
 *   · 반지름 · 켬끔은 안 바꿈 — IP 자리만. 합치기 · 곡선 끄기 · 되돌아가기 없음.
 *   · 간격 = 스냅 간격(390-2 · 0.1 · 1 · 10 m · 측점 No.) · 허용 오차도 간격 따라(`mcTolM`).
 *   · 끄는 동안 · 방향키 걸음마다 미리보기(`fitDrag` · 390-5) = 누르기 전 노선 + 옮긴 IP 하나로 매번 새로
 *     맞춤(앞 프레임 맞춤이 쌓이지 않음) · 놓을 때 `fitCurveStations` 정본 맞춤이 같은 값.
 * 파이썬 짝 아님 — [저장] 때 서버가 저장된 IP 로 선을 다시 짬(`buildEditedPolyline` 짝)이라 MC 그대로.
 * 순수 계산 — 화면 · fetch · sessionStorage 없음. 부르는 쪽은 `B05_Profile_UI_RouteEdit`.
 * ========================================================================== */

import type { EditedCurve, EditedPolyline, Vertex } from "./B05_Profile_UI_RouteEdit_Curve";
import {
  curveShortfalls,
  rebuildLine,
  shortfallCrossed,
  type NodeColumns,
} from "./B05_Profile_UI_RouteEdit_Edits";
import { curveSpans } from "./B05_Profile_UI_RouteEdit_Frame";

/** MC 가 측점에서 이만큼 안이면 「위」(m) — 파이썬 `MC_TOL_M` 과 같은 값. */
export const MC_TOL_M = 0.05;

/** 간격별 허용 오차 — 0.1 m 간격도 실제로 맞게 간격의 1/20 이하(390-2 · 1 m 이상은 `MC_TOL_M`). */
export const mcTolM = (intervalM: number): number => Math.min(MC_TOL_M, intervalM / 20);

/** 선을 짜는 값 — 편집 창이 쥔 하한 · 간격. */
export interface FitLimits {
  minRadiusM: number;
  limitRadiusM: number;
  limitArcM: number;
  intervalM: number;
}

type Columns = Pick<NodeColumns, "curveOn" | "curveRadius" | "curveLock" | "curveArc" | "apexLock">;

/** 편집 창 `markEdited` 와 같은 길(길이 고정 R · 하한 끌어올림 → 선) — 값은 사본에. */
function build(cols: Columns, planned: Vertex[], limits: FitLimits): EditedPolyline {
  return rebuildLine({ ...cols, planned, curveRadius: [...cols.curveRadius] }, limits);
}

/** 꺾임점 `k` 곡선의 MC 누가거리 — 곡선이 없으면 null. */
function mcOf(built: EditedPolyline, k: number): number | null {
  const curve = built.curves.find((item) => item.node_first === k);
  const span = curve ? curveSpans(built.vertices, [curve])[0] : undefined;
  return span ? (span[0] + span[1]) / 2 : null;
}

/** 측점 밖 곡선 수 — MC 가 일반측점(No.1 이상) 위가 아닌 곡선 · 한 측점에 둘이면 하나만 위. */
export function offStationCount(
  line: ReadonlyArray<Vertex>,
  curves: ReadonlyArray<EditedCurve>,
  intervalM: number,
): number {
  return offStationMcs(line, curves, intervalM).length;
}

/** 측점 밖 곡선의 MC 누가거리(408-1 · 상태줄 「못 맞춘 곡선」) — `offStationCount` 와 같은 판정. */
export function offStationMcs(
  line: ReadonlyArray<Vertex>,
  curves: ReadonlyArray<EditedCurve>,
  intervalM: number,
): number[] {
  if (!(intervalM > 0)) return [];
  const hits = new Set<number>();
  const off: number[] = [];
  for (const [start, end] of curveSpans(line, curves)) {
    const mc = (start + end) / 2;
    const n = Math.round(mc / intervalM);
    if (n >= 1 && Math.abs(mc - n * intervalM) <= mcTolM(intervalM) && !hits.has(n)) hits.add(n);
    else off.push(mc);
  }
  return off;
}

/** 맞춤을 시작할 꺾임점 — 지난 걸음과 처음 다른 자리 바로 앞(그 곡선 끝 접선도 바뀜) · 같으면 1. */
export function fitStart(
  before: (Columns & Pick<NodeColumns, "planned">) | null | undefined,
  now: Columns & Pick<NodeColumns, "planned">,
): number {
  if (!before) return 1;
  const keys = ["curveOn", "curveRadius", "curveLock", "curveArc", "apexLock"] as const;
  const at = now.planned.findIndex(
    (vertex, i) =>
      vertex[0] !== before.planned[i]?.[0] ||
      vertex[1] !== before.planned[i]?.[1] ||
      keys.some((key) => now[key][i] !== before[key][i]),
  );
  const changed =
    at < 0 && now.planned.length !== before.planned.length ? now.planned.length - 1 : at;
  return Math.max(1, changed - 1);
}

const round4 = (value: number): number => Math.round(value * 1e4) / 1e4;

/** 곡선 하나 맞춤 — IP `k` 를 들어오는 접선 따라 d 밀어 MC = target(할선법 · 기울기 ≈ 1). */
function solve(
  cols: Columns,
  limits: FitLimits,
  planned: Vertex[],
  k: number,
  target: number,
  mc: number,
): { planned: Vertex[]; built: EditedPolyline; mc: number } | null {
  const base = planned[k];
  const before = planned[k - 1];
  const length = Math.hypot(base[0] - before[0], base[1] - before[1]);
  if (!(length > 1e-9)) return null;
  const ux = (base[0] - before[0]) / length;
  const uy = (base[1] - before[1]) / length;
  const reach = limits.intervalM; // 한가운데(18+9 ~ 19+1)도 가까운 측점까지(441 · 반 간격이면 못 닿음)
  const clamp = (d: number): number => Math.max(-reach, Math.min(reach, d));
  const at = (d: number) => {
    const next = planned.slice();
    next[k] = [round4(base[0] + ux * d), round4(base[1] + uy * d)];
    const built = build(cols, next, limits);
    const found = mcOf(built, k);
    return found === null ? null : { planned: next, built, mc: found };
  };
  let d0 = 0;
  let f0 = mc - target;
  let d1 = clamp(-f0);
  for (let step = 0; step < 10; step += 1) {
    const tried = at(d1);
    if (!tried || d1 === d0) return null;
    const f1 = tried.mc - target;
    if (Math.abs(f1) <= mcTolM(limits.intervalM) / 5) return tried;
    const slope = (f1 - f0) / (d1 - d0);
    if (Math.abs(slope) < 0.2) return null;
    d0 = d1;
    f0 = f1;
    d1 = clamp(d1 - f1 / slope);
  }
  return null;
}

/** `from` 꺾임점부터 끝까지 곡선 MC 를 일반측점에 — 새 IP 목록(못 놓은 곡선 IP 는 그대로).
 *  곡선마다 후보 측점 둘(내림 · 올림 · 가까운 차례) · 뒤 곡선 하나를 미리 맞춰 보고 둘 다 서는 쪽(433-21 ②)
 *  — 가까운 쪽만 고르면 뒤 곡선이 「앞 측점 + 1」에 몰려 R 이 눌리고 앞 MC 가 흔들려 버려짐. */
export function fitCurveStations(
  cols: Columns & Pick<NodeColumns, "planned">,
  limits: FitLimits,
  from: number,
): Vertex[] {
  let planned = cols.planned.map((vertex): Vertex => [vertex[0], vertex[1]]);
  const interval = limits.intervalM;
  if (!(interval > 0) || planned.length < 3) return planned;
  let built = build(cols, planned, limits);
  const floor = curveShortfalls(built.nodes, limits.limitRadiusM, limits.limitArcM);
  const tol = mcTolM(interval);
  type Fit = { planned: Vertex[]; built: EditedPolyline };
  /** 곡선을 놓을 측점 — 내림 · 올림 중 앞 측점 + 1 이상 · 가까운 차례. */
  const near = (mc: number, last: number): number[] => {
    const lo = Math.floor(mc / interval);
    return [lo, lo + 1]
      .filter((n) => n > last)
      .sort((a, b) => Math.abs(a * interval - mc) - Math.abs(b * interval - mc));
  };
  const onAt = (mc: number, last: number) =>
    near(mc, last).find((n) => Math.abs(mc - n * interval) <= tol);
  /** 곡선 `k` 를 측점 `n` 에 — 하한을 새로 깨거나 앞 곡선(`previous`) MC 를 흔들면 null. */
  const attempt = (at: Fit, k: number, mc: number, n: number, previous: number): Fit | null => {
    const fitted = solve(cols, limits, at.planned, k, n * interval, mc);
    if (
      !fitted ||
      shortfallCrossed(
        floor,
        curveShortfalls(fitted.built.nodes, limits.limitRadiusM, limits.limitArcM),
      )
    )
      return null;
    if (previous < 0) return fitted;
    const moved = Math.abs(
      (mcOf(fitted.built, previous) ?? Infinity) - (mcOf(at.built, previous) ?? 0),
    );
    return moved <= tol / 5 ? fitted : null;
  };
  /** `k` 뒤 첫 곡선이 측점 위이거나 맞춰지나(앞보기 한 걸음). */
  const nextSettles = (at: Fit, k: number, last: number): boolean => {
    for (let j = k + 1; j < at.planned.length - 1; j += 1) {
      const mc = mcOf(at.built, j);
      if (mc === null) continue;
      if (onAt(mc, last) !== undefined) return true;
      return !cols.apexLock[j] && near(mc, last).some((n) => attempt(at, j, mc, n, k) !== null);
    }
    return true;
  };
  let lastStation = 0; // 앞 곡선이 놓인 측점 번호(없으면 0 = 시점)
  let previous = -1; // 앞 곡선 꺾임점
  for (let k = 1; k < planned.length - 1; k += 1) {
    const mc = mcOf(built, k);
    if (mc === null) continue;
    const on = onAt(mc, lastStation);
    if (on !== undefined) lastStation = on;
    else if (k >= from && !cols.apexLock[k]) {
      let pick: { fit: Fit; n: number } | null = null;
      for (const n of near(mc, lastStation)) {
        const fit = attempt({ planned, built }, k, mc, n, previous);
        if (!fit) continue;
        pick ??= { fit, n };
        if (nextSettles(fit, k, n)) {
          pick = { fit, n };
          break;
        }
      }
      if (pick) (({ planned, built } = pick.fit), (lastStation = pick.n));
    }
    previous = k;
  }
  return planned;
}

/** 끄는 중 미리보기(390-5) — `base`(누르기 전 IP) 에 IP `k` 만 지금 자리(`cols.planned[k]`)로 두고
 *  `k` 앞 곡선부터 맞춤(`fitStart` 와 같은 시작). */
export function fitDrag(
  cols: Columns & Pick<NodeColumns, "planned">,
  base: ReadonlyArray<Vertex>,
  k: number,
  limits: FitLimits,
): Vertex[] {
  if (base.length !== cols.planned.length)
    return fitCurveStations(cols, limits, Math.max(1, k - 1));
  const planned = base.map((vertex, i): Vertex => (i === k ? cols.planned[k] : vertex));
  return fitCurveStations({ ...cols, planned }, limits, Math.max(1, k - 1));
}