Aislo/B06_Section/B06_Section_Section_Store.ts

/* =============================================================================
 * B06_Section_Section_Store.ts
 * 종횡단 상세(SectionDetailResponse)의 **프론트 공유 캐시** — B05·B06이 같은 객체를 본다.
 *
 * ── 왜 필요한가 (2026-08-03 사용자 확정) ─────────────────────────────
 * B05(노선·계획선)와 B06(종횡단 설계)은 같은 영구저장소 데이터의 두 창이다. 페이지마다
 * 따로 fetch해 제각각 들고 있으면, B06에서 지반유형·암 경계를 고친 뒤 B05로 넘어갔을 때
 * 횡단 기준 유토곡선이 옛 값으로 그려진다(사용자가 실제로 겪은 문제). 여기서 한 번 받아
 * **같은 객체 참조**를 두 페이지에 주면, B06이 측점 설계를 제자리 갱신하는 순간 B05가
 * 다음 그리기에서 그대로 본다 — 별도 동기화 코드가 필요 없다.
 *
 * ── 수명 규칙 ─────────────────────────────────────────────────────
 * 키는 `projectId:routeId`. SPA 모듈 싱글턴이라 페이지를 오가도 살아 있다. 새로고침이면
 * 메모리가 비므로 **세션에도 한 벌 얹어 둔다**(④ 계산 결과, 2026-09-06 캐시·세션 일원화)
 * — 새로고침 뒤 첫 화면이 서버를 기다리지 않는다. 세션 용량을 넘으면 조용히 건너뛰고
 * 예전처럼 영구저장소에서 다시 받는다(영구저장소가 항상 정본). 서버가 파일을 통째로 다시
 * 쓰는 조작(재생성·계획선 편집 저장·확정)은 그 응답/재조회로 `replace`·`invalidate`한다.
 * ========================================================================== */

import { clearState, readState, writeState } from "../A00_Common/b_page_state";
import { PIPE_MATCH_M } from "../A00_Common/design/design_selection";
import { setGeneralStations, setPlusStations } from "../common_util/common_util_structure_station";
import { loadSavedPlusStations, plusStationsOf } from "../B05_Profile/B05_Profile_Api_PlusStations";
import {
  forgetDraftStations,
  withDraftShapes,
  withDraftStations,
} from "./B06_Section_Section_Drafts";
import { applyStructureAreaRows, structureAreaRows } from "./B06_Section_Structure_Layouts";
import { withDraftAdjusts, withPipeOptions } from "./B06_Section_Section_Adjusts";
import type { CrossSectionPatch, SectionDetailResponse } from "./B06_Section_Api_Fetch";
import { forgetCanon, keepCanon, sessionDetail } from "./B06_Section_Section_Canon";
import { fetchSectionDetail, saveSections } from "./B06_Section_Api_Fetch";
import { USER_TOUCHED_KEYS } from "./B06_Section_Cross_Refresh";
import { kindChangedChainages, STRUCTURE_ADJUST_KEYS } from "./B06_Section_Api_Culvert_Options";
import type { PipelineStation } from "../A00_Common/design/logic/design_pipeline_types";
import {
  carryStationKeys,
  KEYED_STATES,
  registeredKeys,
  stationIntervalOf,
  useStationKeyList,
  type Keyed,
  type KeyedState,
} from "./B06_Section_Station_Keys";
import { sameStationList, swapCrossSections } from "./logic/B06_Section_Station_Swap";
import { emitSwap, type DetailListener } from "./B06_Section_Swap_Bus";

export { onAnySwap } from "./B06_Section_Swap_Bus";

const cache = new Map<string, SectionDetailResponse>();
const pending = new Map<string, Promise<SectionDetailResponse>>();

function keyOf(projectId: string, routeId: number): string {
  return `${projectId}:${routeId}`;
}

/**
 * 초안(관 · 구조물)을 상세에 얹는다 — **여기가 유일한 자리**다.
 *
 * 서버는 저장분만 얹어 준다. 초안이 있으면 그것이 화면의 정본이므로, 캐시·세션·새 요청 어느 길로
 * 들어오든 이 함수를 지나 같은 상태가 된다(2026-09-06 실측). 측점 = 측점 계획 한 벌(`withDraftStations`) ·
 * 그림 자료 = 형상 얹기 한 벌(`withDraftShapes` · 서버 `attach_shapes` 짝 · 323-4).
 */
async function withDraftWalls(
  detail: SectionDetailResponse,
  projectId: string,
  routeId: number,
): Promise<SectionDetailResponse> {
  setGeneralStations(detail.longitudinal?.stations); // 구조물 기준 측점이 붙을 일반 측점(234-1)
  setPlusStations(() => plusStationsOf(projectId)); // 측점 계획이 읽을 추가 측점(368-2)
  await loadSavedPlusStations(projectId);
  await withDraftStations(detail, projectId, routeId); // 옛 자리 숨김 · 새 자리 미리 뜬 횡단(273-2)
  await withDraftShapes(detail, projectId);
  withDraftAdjusts(detail, projectId, routeId); // 저장 안 한 조정창 4축 · 구간 · 형식(387-4 · B05 만 열어도)
  await withPipeOptions(detail, projectId); // 관 옵션 벽 높이 · 형태 · 흙막이 단(387-4b)
  return withStructureAreas(detail);
}

/**
 * 구조물이 선 측점의 절·성토 면적을 **읽어 오는 자리에서 한 번** 다시 얹는다.
 *
 * 카드는 자기 그림에서 면적을 고쳐 들지만 유토곡선은 카드보다 먼저 계산된다 — 여기서
 * 얹지 않으면 새로고침 직후 곡선만 옛 면적으로 남는다(2026-09-06 실측 553.4 vs 546.4).
 * 순수 계산(6ms/67측점)이라 읽기 경로에 두어도 규칙에 어긋나지 않는다.
 */
function withStructureAreas(detail: SectionDetailResponse): SectionDetailResponse {
  applyStructureAreaRows(detail.cross_sections, structureAreaRows(detail.cross_sections));
  return detail;
}

/**
 * 상세를 가져온다 — 캐시가 있으면 **같은 객체**를 즉시 돌려주고, 없으면 한 번만 fetch한다
 * (동시 호출은 같은 Promise를 공유). `force`면 캐시를 버리고 다시 받는다.
 */
export async function loadSectionDetail(
  projectId: string,
  routeId: number,
  options?: { force?: boolean },
): Promise<SectionDetailResponse> {
  const key = keyOf(projectId, routeId);
  if (!options?.force) {
    const cached = cache.get(key);
    if (cached) return withDraftWalls(cached, projectId, routeId);
    const inFlight = pending.get(key);
    if (inFlight) return inFlight;
    // 새로고침으로 메모리가 빈 경우 — 세션에 얹어 둔 한 벌로 바로 선다.
    const stored = sessionDetail(projectId, routeId); // 세션 글 = 한 번만 풂(387-7)
    if (stored) {
      cache.set(key, stored);
      return withDraftWalls(stored, projectId, routeId);
    }
  }
  const request = fetchSectionDetail(projectId, routeId)
    .then(async (detail) => {
      cache.set(key, detail);
      writeState("section-detail", detail, projectId, routeId);
      keepCanon(projectId, routeId, detail);
      return withDraftWalls(detail, projectId, routeId);
    })
    .finally(() => {
      pending.delete(key);
    });
  pending.set(key, request);
  return request;
}

const listeners = new Map<string, Set<DetailListener>>();

/** 상세 객체가 갈아끼워짐(측점 수가 바뀜 · 346-2 4파) — 쥔 옛 객체를 버리고 새것으로 다시 그릴 것. */
export function subscribeSectionDetail(
  projectId: string,
  routeId: number,
  fn: DetailListener,
): () => void {
  const key = keyOf(projectId, routeId);
  const set = listeners.get(key) ?? new Set<DetailListener>();
  set.add(fn);
  listeners.set(key, set);
  return () => set.delete(fn);
}

/**
 * 계산 묶음 측점(가게 `stations`)이 측점 목록을 바꿨으면 상세를 **갈아끼움** — 같은 목록이면 그대로(제자리
 * 갱신 길이 맡음 · null). 앞 횡단은 측점 열쇠로 이어 받고, 노선 모양이 바뀐 차례면 세션 고침도 열쇠로 넘김
 * (사라진 측점 = 「노선 밖 고침 N 건」). 새 상세 = 캐시 · 세션 · 듣는 쪽(횡단 · 종단 보기 · 3D).
 */
export async function swapSectionStations(
  projectId: string,
  routeId: number,
  stations: ReadonlyArray<PipelineStation>,
): Promise<{ detail: SectionDetailResponse; moves: Map<string, string> } | null> {
  const key = keyOf(projectId, routeId);
  const current = cache.get(key);
  if (!current || !stations.length) return null;
  const interval = stationIntervalOf(current);
  const oldKeys = registeredKeys(projectId, routeId, current.cross_sections, interval);
  if (sameStationList(current.cross_sections, oldKeys, stations)) return null;
  const swap = swapCrossSections(current, stations, oldKeys, interval);
  // 설계는 사본 — 면적 얹기 · 다시 셈이 앞 상세(초안 전 상세 등)의 설계를 제자리로 안 고침(349-0o)
  for (const section of swap.detail.cross_sections)
    if (section.design) section.design = { ...section.design };
  // 새 목록 열쇠 = 묶음 측점이 정한 것 그대로(규칙 한 벌 · 다시 셈하지 않음)
  const nextKeys = stations.map((station) => ({ key: station.key, chainageM: station.chainageM }));
  if (swap.moved) carryStationKeys(projectId, routeId, nextKeys);
  else useStationKeyList(projectId, routeId, nextKeys);
  // 메모리만 — 세션 상세 = 저장 정본만(387-7 · 새로고침 · B06 바로 열기 = 묶음이 다시 갈아끼움 · 365-1)
  cache.set(key, swap.detail);
  await withDraftShapes(swap.detail, projectId); // 새 측점에도 구조물 그림 자료(323-4)
  withStructureAreas(swap.detail);
  if (cache.get(key) !== swap.detail) return null; // 그 사이 다른 갈아끼움 · 새로 받음
  emitSwap(swap.detail, swap.moves); // 세션 값 옮김 · 다시 그림(어느 보기든)
  listeners.get(key)?.forEach((fn) => fn(swap.detail, swap.moves));
  recrossSaved(projectId, key, swap.detail);
  return { detail: swap.detail, moves: swap.moves };
}

/** 저장 노선 측점을 갈아끼움 — 그 차례 cross 는 옛 상세를 봐서 새 상세 설계 · 면적이 안 셈 → 묶음이 다 돈 뒤(새 측점
 *  종단 · 화면 선이 선 뒤 · 그 전에 세면 계획고 0.5 mm 갈림) cross 한 번 더(387-4b · B05 만 연 면적 = B06). 노선 초안
 *  동안은 묶음 새 노선 상세가 맡음. 묶음은 늦게 불러옴(가게 ↔ 묶음 순환 없음). */
function recrossSaved(projectId: string, key: string, detail: SectionDetailResponse): void {
  void Promise.all([
    import("../A00_Common/design/design_pipeline_cross"),
    import("../A00_Common/design/design_pipeline_page"),
  ])
    .then(async ([cross, page]) => {
      await page.reconcilePagePipeline(projectId);
      // 그 사이 다른 상세 · 다시 셈 창구 없음(묶음만 · 시험) · 노선 초안 = 안 부탁
      if (cache.get(key) !== detail) return;
      if (!page.pipelineOwnsCross(projectId) || page.pagePipeline(projectId)?.input("route"))
        return;
      cross.forceCross();
      page.pipelineCross(projectId);
    })
    .catch(() => undefined);
}

/** 노선 초안 전 상태(349-0o) — 상세(초안 전 객체 그대로 · 되돌리면 캐시) · 측점 열쇠 · 측점 열쇠 칸 다섯(횡단 초안). */
export interface SectionHold {
  detail: SectionDetailResponse;
  keys: Keyed[];
  cells: Array<[KeyedState, unknown]>;
}

/** 노선 초안 시작 — 초안 전 상세(`detail` · 객체 그대로 — 갈아끼움은 설계를 사본으로 씀) · 지금 측점 열쇠 · 횡단 초안 칸을 떠 둠. */
export function holdSectionDetail(
  projectId: string,
  routeId: number,
  detail: SectionDetailResponse,
): SectionHold {
  const sections = detail.cross_sections;
  const keys = registeredKeys(projectId, routeId, sections, stationIntervalOf(detail));
  return {
    detail,
    keys: sections.map((section, i) => ({ key: keys[i], chainageM: section.chainage_m })),
    cells: KEYED_STATES.map((name) => [name, readState(name, projectId, routeId)]),
  };
}

/**
 * 노선 초안을 버림(PLAN 349-0k · 349-0o) — 갈아끼운 상세를 초안 전 상태(`hold`)로 되돌림 · 다시 셈 없음.
 * 상세 = 초안 전 객체 · 측점 열쇠 · 횡단 초안 칸 = 그때 값(초안 동안 넘김이 버린 고침도) · 누가거리
 * 열쇠 조작값 맵은 열쇠로 옮김. 묶음 측점(`stations`)이 달라도 초안 전 상세 — `same` = 측점 목록이 같음(1 mm).
 * 캐시가 없으면 null.
 */
export async function restoreSectionDetail(
  projectId: string,
  routeId: number,
  hold: SectionHold,
  stations: ReadonlyArray<PipelineStation>,
): Promise<{ detail: SectionDetailResponse; same: boolean } | null> {
  const key = keyOf(projectId, routeId);
  const current = cache.get(key);
  if (!current) return null;
  const saved = hold.detail;
  const sections = saved.cross_sections;
  const same =
    sections.length === stations.length &&
    stations.every((station, i) => Math.abs(station.chainageM - sections[i].chainage_m) < 1e-3);
  const oldKeys = registeredKeys(
    projectId,
    routeId,
    current.cross_sections,
    stationIntervalOf(current),
  );
  const text = (chainageM: number) => chainageM.toFixed(2);
  const moves = new Map<string, string>();
  current.cross_sections.forEach((section, i) => {
    const to = hold.keys.find((entry) => entry.key === oldKeys[i]);
    if (to && text(to.chainageM) !== text(section.chainage_m))
      moves.set(text(section.chainage_m), text(to.chainageM));
  });
  for (const [name, value] of hold.cells) writeState(name, value ?? null, projectId, routeId);
  useStationKeyList(projectId, routeId, hold.keys);
  cache.set(key, saved); // 세션 상세는 정본 그대로(387-7)
  await withDraftShapes(saved, projectId);
  withStructureAreas(saved);
  if (cache.get(key) !== saved) return null; // 그 사이 다른 갈아끼움 · 새로 받음
  emitSwap(saved, moves);
  listeners.get(key)?.forEach((fn) => fn(saved, moves));
  return { detail: saved, same };
}

/**
 * 캐시를 비운다. routeId를 생략하면 그 프로젝트 전부 —
 * 서버 쪽 정본이 바뀌었는데 새 상세를 손에 못 쥔 조작(계획선 편집 저장 등) 뒤에 쓴다.
 */
export function invalidateSectionDetail(projectId: string, routeId?: number): void {
  forgetDraftStations(projectId);
  if (routeId !== undefined) {
    cache.delete(keyOf(projectId, routeId));
    forgetCanon(projectId, routeId);
    clearState("section-detail", projectId, routeId);
    return;
  }
  const prefix = `${projectId}:`;
  for (const key of [...cache.keys()]) {
    if (!key.startsWith(prefix)) continue;
    cache.delete(key);
    forgetCanon(projectId, Number(key.slice(prefix.length)));
    clearState("section-detail", projectId, Number(key.slice(prefix.length)));
  }
}

/** 받아 둔 상세 중 노선 번호가 가장 큰 것(최신) — 노선 번호를 모르는 쪽(B05 평면 횡단 판 · 393-2). */
export function peekSectionDetail(projectId: string): SectionDetailResponse | null {
  const prefix = `${projectId}:`;
  let best: { routeId: number; detail: SectionDetailResponse } | null = null;
  for (const [key, detail] of cache) {
    const routeId = Number(key.slice(prefix.length));
    if (key.startsWith(prefix) && (!best || routeId > best.routeId)) best = { routeId, detail };
  }
  return best?.detail ?? null;
}

/**
 * 캐시에 얹힌 **사용자 수정분**을 저장 payload로 뽑는다(2026-08-24 사용자 확정 흐름).
 *
 * 초기 계산값은 원복용으로 서버에 그대로 있고, 사용자가 만진 값은 이 캐시 한 세트가
 * 최종본이다. B05 [임시저장]도 이 세트를 함께 보내야 B06에서 만진 구조물 조정이
 * 영구저장소에 남는다 — 안 보내면 캐시만 비워져 편집이 사라진다.
 *
 * 초기 계산값에는 없는 키(사용자가 만져야 생기는 키)만 싣는다.
 */
export function crossPatchesFromCache(
  detail: SectionDetailResponse,
  kindChanged: readonly number[] = [],
): CrossSectionPatch[] {
  const patches: CrossSectionPatch[] = [];
  // 관 종류를 바꾼 측점(318-4) — 옛 종류 조정값은 서버가 비움 · 캐시에 남은 옛 값을 다시 안 실음
  const structureKeys: readonly string[] = STRUCTURE_ADJUST_KEYS;
  const reset = (at: number) => kindChanged.some((c) => Math.abs(c - at) < PIPE_MATCH_M);
  for (const at of kindChanged) patches.push({ chainage_m: at, structure_reset: true });
  for (const section of detail.cross_sections) {
    const design = section.design;
    if (!design) continue;
    const patch: CrossSectionPatch = { chainage_m: section.chainage_m };
    const skip = reset(section.chainage_m);
    let touched = false;
    // 필드를 손으로 나열하지 않는다(2026-09-07) — 목록은 `USER_TOUCHED_KEYS` 한 벌뿐이고
    // 서버 목록과 짝이다. 나열이 흩어져 있던 탓에 새 값을 더할 때 한 곳이 빠져 그 값이
    // 조용히 사라졌다(`extra_spans` 실사고 `b6941bd2`).
    const source = design as unknown as Record<string, unknown>;
    const target = patch as unknown as Record<string, unknown>;
    for (const key of USER_TOUCHED_KEYS) {
      const value = source[key];
      if (value === undefined || value === null || (skip && structureKeys.includes(key))) continue;
      target[key] = value;
      touched = true;
    }
    if (touched) patches.push(patch);
  }
  return patches;
}

/**
 * 캐시에 얹힌 사용자 수정분을 영구저장소에 남긴다(임시저장용). 캐시가 없거나 수정분이
 * 없으면 아무것도 보내지 않는다. 저장 실패는 호출자가 처리한다.
 */
export async function saveCachedCrossPatches(projectId: string, routeId: number): Promise<number> {
  const detail = cache.get(keyOf(projectId, routeId));
  if (!detail) return 0;
  const patches = crossPatchesFromCache(detail, kindChangedChainages(projectId));
  if (!patches.length) return 0;
  await saveSections(projectId, routeId, undefined, patches);
  clearState("kindreset", projectId); // 비울 자리를 보냈음(318-4)
  return patches.length;
}