Aislo/B05_Profile/logic/B05_Profile_Pipeline_Grade.ts

/* =============================================================================
 * B05_Profile_Pipeline_Grade.ts
 * 계산 묶음(PLAN 346-1) **follow · planline · profile 단계** + 바뀐 범위 — 계약 =
 * `A00_Common/design/logic/design_pipeline_types.ts`. 셈은 이미 있는 짝을 부르기만(어댑터):
 *
 *   follow   — 관 · 구조물 좌표 따라감(`common_util_route_follow`) · 계획고 편집 옮김(`Grade_Carry`
 *              `carryEdits` · 옛 노선 `before.route` 가 있을 때만 · 기준 = 마지막 종단 편집 때 한 벌 · 400) ·
 *              추가 측점 좌표 따라감(459 · `followPlusStations`).
 *   planline — 노선 초안이 없으면 저장 종단 기준 그대로 · 있으면 새 측점마다 같은 자리는 저장 꼭짓점
 *              높이 · 바뀐 자리만 새 지반 첫 계획선(`Grade_Ground` · `carryBase`) · 옮긴 시설 측점(바뀐 자리 ·
 *              사용자가 옮김)에 427 꼭짓점 다시 세움(459 · 짝 = 파이썬 `B05_Profile_Route_Save_Parts`
 *              `route_moved_stations` · `seat_route_moved` · 거울 시험 test_459_route_seat_mirror.py).
 *   profile  — `buildAlignment`(첫 계획선 + 계획고 편집) — 종단 보기가 쓰는 같은 함수.
 *
 * 화면 · fetch · 세션 없음(순수) — 저장 기준 · 저장 노선은 부르는 쪽이 넣음.
 * ========================================================================== */

import type {
  FollowPatch,
  PipelineInputs,
  PipelineStation,
  RangePart,
  RouteLine,
  StageFn,
  Vertex,
} from "../../A00_Common/design/logic/design_pipeline_types";
import {
  followPlusStations,
  followStructures,
  projectPipePoints,
  type FollowingPoint,
  type FollowingStructure,
} from "../../common_util/common_util_route_follow";
import { PLUS_OWNER_PREFIX, SAME_STATION_M } from "../../common_util/common_util_structure_station";
import {
  buildAlignment,
  emptyEdits,
  type AlignmentBase,
  type AlignmentEdits,
} from "./B05_Profile_UI_Profile_Alignment";
import {
  carryBase,
  carryEdits,
  changedSpan,
  lineMatcher,
  type XY,
} from "./B05_Profile_Grade_Carry";
import { seatBornNodes } from "./B05_Profile_Grade_Seat";
import { SECTION_STATION_INTERVAL_M } from "./B05_Profile_Sections_Stations";
import { groundFollowingBasePvi, groundProfile } from "./B05_Profile_Grade_Ground";
import { DEFAULT_CURVE_LENGTH_M } from "./B05_Profile_Profile_CurveLaw";

const xy = (line: ReadonlyArray<Vertex>): Array<{ x: number; y: number }> =>
  line.map(([x, y]) => ({ x, y }));

/** 서버 측점 id 꼴(`generate_sections`) — 종단 표 · 고르기가 이 id 로 측점을 짚음. */
export const stationIdOf = (chainageM: number): string =>
  `station_${String(Math.round(chainageM * 1000)).padStart(12, "0")}`;

/** 노선 바뀐 범위 — 처음 바뀐 접선점부터 끝(같으면 전 구간). */
export function routeRange(
  before: ReadonlyArray<Vertex> | null,
  after: ReadonlyArray<Vertex> | null,
): RangePart {
  const span = before && after ? changedSpan(xy(before), xy(after)) : null;
  return { fromM: span ? span.start_m : 0, toM: Infinity };
}

/** 계획고 바뀐 범위 — 바뀐 편집 키 앞뒤 이웃 꼭짓점 사이(`nodes` = 계획선 꼭짓점 누가거리). 같으면 null. */
export function gradeRange(
  before: AlignmentEdits | null,
  after: AlignmentEdits | null,
  nodes: ReadonlyArray<number>,
): RangePart | null {
  const changed: number[] = [];
  for (const field of ["station_offsets", "curve_radii"] as const) {
    const a = before?.[field] ?? {};
    const b = after?.[field] ?? {};
    for (const key of new Set([...Object.keys(a), ...Object.keys(b)]))
      if (a[key] !== b[key]) changed.push(Number(key));
  }
  if (!changed.length) return null;
  const low = Math.min(...changed);
  const high = Math.max(...changed);
  const ahead = nodes.filter((node) => node > high + 1e-6);
  return {
    fromM: Math.max(0, ...nodes.filter((node) => node < low - 1e-6)),
    toM: ahead.length ? Math.min(...ahead) : Infinity,
  };
}

/** 계획고 편집 기준 한 벌 — 그 편집이 놓인 선 · 자동 꼭짓점. */
interface GradeRef {
  line: XY[];
  basePvi: AlignmentBase["basePvi"];
  edits: AlignmentEdits;
}

/**
 * follow — 노선이 바뀐 차례에 한 번 · 관 · 구조물 좌표 따라감 · 계획고 편집 옮김. 편집 기준 = 마지막으로
 * 편집이 바뀐(종단 조작 · 되돌리기 · 열 때) 뒤 첫 노선 걸음의 옛 선 · 자동 꼭짓점 · 편집 — 노선 걸음이 여럿이어도
 * 그 한 벌에서 한 번에 옮김(걸음 수와 무관 · 서버 [저장] = 저장 노선에서 한 번 · 400). 첫 계산(옛 노선 없음)은
 * 저장 노선(`savedLine`)을 옛 노선으로 보고 좌표만 따라감(투영은 몇 번 해도 같음 · 계획고 옮김은 안 함 —
 * 열 때의 계획고 초안은 이미 그 노선 기준). 노선 초안이 없으면(열 때 · 초안 버림) `saved` 를 그대로 —
 * 저장 노선의 관 · 구조물 누가거리 · 계획고는 정본이라 다시 투영하지 않음(투영 오차 = 측점 목록 어긋남).
 */
export function createFollowStage(deps: {
  savedLine(): Vertex[] | null;
  saved?(): FollowPatch;
  /** 새 노선 측점 누가거리(stations 단계와 같은 셈) — 없으면 일반측점 격자. */
  stationsAt?(route: RouteLine, patch: FollowPatch, inputs: PipelineInputs): number[];
}): StageFn<"follow"> {
  let ref: GradeRef | null = null;
  let carried: unknown = null; // 마지막으로 낸 편집 — 입력이 이것이면 기준 그대로
  let moved = new Set<string>(); // 노선 초안 동안 사용자가 옮긴 · 놓은 시설 id(459 · 427 세움)
  return (ctx) => {
    if (!ctx.inputs.route) moved = new Set();
    if (!ctx.inputs.route && deps.saved) return deps.saved();
    const before = ctx.before.route?.line ?? deps.savedLine();
    const now = ctx.out.route;
    if (!before || !now) return {};
    const line = xy(now.line);
    const patch: FollowPatch = {};
    const { pipes, structures, alignment, plusStations } = ctx.inputs;
    if (ctx.before.follow) userMoved(ctx.inputs, ctx.before.follow).forEach((id) => moved.add(id));
    if (Array.isArray(pipes) && pipes.length)
      patch.pipes = projectPipePoints(pipes as FollowingPoint[], line);
    if (Array.isArray(structures) && structures.length)
      patch.structures = followStructures(
        structures as FollowingStructure[],
        line,
        undefined,
        SECTION_STATION_INTERVAL_M, // site = 새 노선 일반 측점(380-3)
      ).map((moved) => moved.item);
    // 추가 측점도 땅 위 자리 따라감(459 · 서버 `follow_plus_stations` 짝) — 가게는 부르는 쪽이 씀
    if (plusStations?.length)
      patch.plusStations = followPlusStations(plusStations, xy(before), line);
    movedIds.set(patch, new Set(moved));
    const planline = ctx.before.planline;
    if (alignment !== carried && JSON.stringify(alignment) !== JSON.stringify(carried))
      ref =
        alignment && planline
          ? { line: xy(before), basePvi: planline.basePvi, edits: alignment as AlignmentEdits }
          : null;
    if (ref && ctx.before.route) {
      const span = changedSpan(ref.line, line);
      const half = (planline?.policy.station_interval_m ?? SECTION_STATION_INTERVAL_M) / 2;
      const stations = span ? (deps.stationsAt?.(now, patch, ctx.inputs) ?? gridOf(now)) : [];
      carried = patch.alignment = span
        ? carryEdits(ref.line, line, ref.basePvi, ref.edits, stations, half)
        : ref.edits;
    }
    return patch;
  };
}

/** 같은 꼭짓점 자리(m) — `seatBornNodes` · 파이썬 `_SAME_STATION_M` 과 같은 0.006. */
const SEAT_SAME_M = 0.006;

/** follow 출력마다 그때까지 사용자가 옮긴 시설 id — planline 이 427 세움에 씀(459). */
const movedIds = new WeakMap<object, ReadonlySet<string>>();

type Facility = { id?: string | null; structure_id?: string | null; chainage_m?: number | null };

/** 입력 관 · 구조물 중 앞 follow 출력과 자리가 다른(사용자가 옮김) · 새로 놓은 것의 id. */
function userMoved(
  inputs: Pick<PipelineInputs, "pipes" | "structures">,
  followed: FollowPatch,
): string[] {
  const out: string[] = [];
  for (const key of ["pipes", "structures"] as const) {
    const now = inputs[key];
    const was = followed[key];
    if (!Array.isArray(now) || !Array.isArray(was)) continue;
    const idOf = (item: Facility) => (key === "pipes" ? item.id : item.structure_id) ?? null;
    const at = new Map((was as Facility[]).map((item) => [idOf(item), item.chainage_m ?? null]));
    for (const item of now as Facility[]) {
      const id = idOf(item);
      const old = at.get(id);
      if (id && (old == null || Math.abs((item.chainage_m ?? 0) - old) > SAME_STATION_M))
        out.push(id);
    }
  }
  return out;
}

/** 노선 바뀜으로 옮긴 시설 측점(459) — 관 · 구조물 측점 중 옛 선과 같은 자리가 아닌 것(`lineMatcher` 짝
 *  없음) · 사용자가 옮긴 시설(`moved` id). 추가 측점(`plus-`)은 뺌. 파이썬 `route_moved_stations` 짝(그쪽은
 *  사용자가 옮긴 것을 관 · 구조물 저장이 세움). */
export function routeMovedStations(
  stations: ReadonlyArray<Pick<PipelineStation, "chainageM" | "kind" | "id">>,
  oldXy: ReadonlyArray<XY>,
  newXy: ReadonlyArray<XY>,
  moved: ReadonlySet<string> = new Set(),
): number[] {
  const match = lineMatcher(oldXy, newXy);
  return stations
    .filter(
      (station) =>
        (station.kind === "pipe" || station.kind === "structure") &&
        !station.id?.startsWith(PLUS_OWNER_PREFIX) &&
        ((station.id !== null && moved.has(station.id)) || match(station.chainageM) === null),
    )
    .map((station) => station.chainageM)
    .sort((a, b) => a - b);
}

/** 옮긴 시설 측점(`born`)에 427 꼭짓점을 다시 세움 — 그 자리 꼭짓점을 걷고 `seatBornNodes`(원지반 지남 ·
 *  이웃 1 mm 맞춤 · 균형 종단이면 옮기기 전 계획선 높이). 파이썬 `seat_route_moved` 짝. */
export function seatRouteMoved(
  base: Pick<AlignmentBase, "chainage" | "ground" | "policy" | "basePvi">,
  born: ReadonlyArray<number>,
  held: ReadonlyArray<number> = [],
): AlignmentBase["basePvi"] {
  if (!born.length) return base.basePvi;
  const kept = base.basePvi.filter((node) =>
    born.every((value) => Math.abs(node.chainage_m - value) >= SEAT_SAME_M),
  );
  return seatBornNodes(base, kept, born, held);
}

/** 일반측점 격자 + 끝 — `stationsAt` 없을 때(시험 · 단독 묶음). */
const gridOf = (route: RouteLine): number[] => {
  const grid: number[] = [];
  for (let s = 0; s < route.lengthM; s += SECTION_STATION_INTERVAL_M) grid.push(s);
  return [...grid, route.lengthM];
};

export const followStage = createFollowStage({ savedLine: () => null });

export interface PlanlineDeps {
  /** 저장 노선의 종단 기준(측점 한 벌 = 지금 입력이 심는 측점 · 386-3) — 없으면 아직 못 셈. */
  savedBase(inputs: PipelineInputs): AlignmentBase | null;
  /** 저장 노선(그린 선) — 바뀐 구간을 가름. */
  savedLine(): Vertex[] | null;
  /** 노선 초안 첫 계획선 꼭짓점 = 서버 저장 종단 — 보기가 심은 측점(초안 자리 관 등)에 안 흔들림(365-5) · 없으면 `savedBase`. */
  storedPvi?(): AlignmentBase["basePvi"] | null;
}

export function createPlanlineStage(deps: PlanlineDeps): StageFn<"planline"> {
  return (ctx) => {
    const saved = deps.savedBase(ctx.inputs);
    if (!saved) throw new Error("저장 종단 기준이 아직 없습니다.");
    const ground = ctx.out.ground;
    const route = ctx.out.route;
    if (!ctx.inputs.route || !ground || !route) return saved;
    const { chainageM, z } = ground.longitudinal;
    const samples = chainageM.map((chainage, index) => ({
      chainage_m: chainage,
      elevation_m: z[index],
    }));
    const profile = groundProfile(samples);
    if (!profile) return saved; // 못 서는 땅 — 저장 기준 그대로(서버가 [저장] 때 다시 셈)
    // 바뀐 자리 새 꼭짓점 = 서버 새 지반 첫 계획선(기본 L = config 짝 · 초기값 직선화 · 438)
    const groundPvi =
      groundFollowingBasePvi({
        samples,
        stations: ground.stations.map((station) => station.chainageM),
        policy: { ...saved.policy, default_curve_length_m: DEFAULT_CURVE_LENGTH_M },
      }) ?? [];
    const savedLine = deps.savedLine();
    const span = savedLine ? changedSpan(xy(savedLine), xy(route.line)) : null;
    const savedPvi = deps.storedPvi?.() ?? saved.basePvi;
    const carried = span
      ? carryBase(xy(savedLine!), xy(route.line), savedPvi, groundPvi)
      : savedPvi;
    // 옮긴 시설 측점에 427 꼭짓점 다시 세움(459 · 서버 `_carry_profile` 짝 · 사용자가 옮긴 것은 즉시)
    const followed = ctx.out.follow;
    const moved = new Set(followed ? movedIds.get(followed) : []);
    if (followed) userMoved(ctx.inputs, followed).forEach((id) => moved.add(id));
    const born = savedLine
      ? routeMovedStations(ground.stations, xy(savedLine), xy(route.line), moved)
      : [];
    const held = Object.keys(ctx.inputs.alignment?.station_offsets ?? {}).map(Number);
    return {
      policy: saved.policy, // 옛 기본 L 이어받음(서버 `carry_policy` 짝)
      onlyExplicitCurves: saved.onlyExplicitCurves,
      basePvi: seatRouteMoved(
        {
          chainage: profile.chainage,
          ground: profile.ground,
          policy: saved.policy,
          basePvi: carried,
        },
        born,
        held,
      ),
      chainage: profile.chainage,
      ground: profile.ground,
      stations: ground.stations.map((station) => ({
        station_id: stationIdOf(station.chainageM),
        chainage_m: station.chainageM,
      })),
    };
  };
}

/** profile — 첫 계획선 + 계획고 편집 → 종단(종단 보기와 같은 `buildAlignment`). */
export const profileStage: StageFn<"profile"> = (ctx) => {
  const base = ctx.out.planline;
  if (!base) throw new Error("첫 계획선이 없습니다.");
  return buildAlignment(base, ctx.inputs.alignment ?? emptyEdits());
};