/* PLAN 349-0q sub7 헬퍼 — 소수 자리 구조물 측점 · 저장 상세에 없는 세월교 측점(묶음 측점 ≠ 상세 측점) 노선에서
 * 열기 → 끌기 → 되돌리기 → 목록 다시 맞춤(가게 구조물 · 관 메아리 — 같은 목록 다른 꼴) = 열기 값(B05 그대로 ·
 * B06 안 다녀와도). 되돌리기 · 다시 하기 = 진짜 페이지 사진첩(종단도 편집 가게 다시 읽음 → 다리 알림). 되돌린 상세 = 열 때 객체 그대로 · 같은 측점 목록은 가게에 다시 안 냄(갈아끼움 없음).
 * 나머지 = `helper_349_0o_redo_same.cjs` 그대로(진짜 종단도 · 묶음 · 상세 가게 · Design_Sync 판정).
 * 입력 argv[2] JSON · argv[3] 격자 이진. 결과 = 표준출력 JSON. 짝 = `test_349_0q_undo_echo.py`. */
const fs = require("fs");
const path = require("path");
const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript"));
const CATALOG = require("./helper_322_catalog_module.cjs");

const ROOT = path.join(__dirname, "..", "..");
const job = JSON.parse(fs.readFileSync(process.argv[2], "utf8"));

function memoryStorage() {
  const map = new Map();
  return {
    getItem: (key) => (map.has(key) ? map.get(key) : null),
    setItem: (key, value) => map.set(key, String(value)),
    removeItem: (key) => map.delete(key),
    key: (index) => [...map.keys()][index] ?? null,
    get length() {
      return map.size;
    },
  };
}
const winListeners = {};
const windowBase = {
  sessionStorage: memoryStorage(),
  localStorage: memoryStorage(),
  setTimeout,
  clearTimeout,
  addEventListener: (type, fn) => (winListeners[type] ??= []).push(fn),
  removeEventListener: () => undefined,
};
globalThis.window = new Proxy(windowBase, {
  get: (t, key) => (key in t ? t[key] : undefined),
  set: (t, key, value) => ((t[key] = value), true),
});

// 흙 배분 서버 — 늦게 답함 · 끊기면 버림
globalThis.fetch = (url, init) =>
  new Promise((resolve, reject) => {
    const timer = setTimeout(
      () => resolve({ ok: true, json: async () => ({ haul_plan: { blocks: [], url } }) }),
      20,
    );
    init.signal.addEventListener("abort", () => {
      clearTimeout(timer);
      reject(new Error("aborted"));
    });
  });

const STUBS = {};
const cache = new Map();
function loadTs(full) {
  if (cache.has(full)) return cache.get(full);
  const js = ts.transpileModule(fs.readFileSync(full, "utf8"), {
    compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
  }).outputText;
  const box = { exports: {} };
  cache.set(full, box.exports);
  const localRequire = (request) => {
    if (CATALOG.isCatalogRequest(request)) return CATALOG;
    const key = Object.keys(STUBS).find((name) => request.endsWith(name));
    if (key) return STUBS[key];
    if (request.startsWith("@config/")) return { API_BASE_URL: "http://fake" };
    if (request.startsWith("@ui/")) return anyModule();
    if (request.endsWith(".css")) return {};
    if (request.endsWith(".json")) return require(path.join(path.dirname(full), request));
    if (request.startsWith("@util/"))
      return loadTs(path.join(ROOT, "common_util", `${request.slice(6)}.ts`));
    if (request.startsWith(".")) return loadTs(path.join(path.dirname(full), `${request}.ts`));
    return require(request);
  };
  new Function("exports", "module", "require", js)(box.exports, box, localRequire);
  return box.exports;
}
const load = (...parts) => loadTs(path.join(ROOT, ...parts));

const sampler = load("common_util", "common_util_surface_sampler.ts");
const bytes = fs.readFileSync(process.argv[3]);
const grid = sampler.parseDtmGrid(
  bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.length),
);
const local = { grid, design: "las" };

/** 아무 화면 부품 — 무엇을 읽든 · 부르든 또 그것(DOM · 오버레이 · 도구줄 흉내). */
function anyNode() {
  const box = { dataset: {}, style: {}, classList: { add() {}, remove() {}, toggle() {} } };
  return new Proxy(function node() {}, {
    get: (_t, key) => {
      if (key in box) return box[key];
      if (key === "then" || typeof key === "symbol") return undefined;
      return (box[key] = anyNode());
    },
    set: (_t, key, value) => ((box[key] = value), true),
    apply: () => anyNode(),
  });
}
const anyModule = (own = {}) =>
  new Proxy(own, {
    get: (t, key) =>
      key in t
        ? t[key]
        : key === "__esModule"
          ? true
          : typeof key === "symbol"
            ? undefined
            : anyNode(),
  });
globalThis.document = anyNode();
globalThis.HTMLElement = function HTMLElement() {};

STUBS["B05_Profile_Api_Replan"] = {
  analysisTerrain: () => "las",
  fetchRoutePlan: async () => ({
    planned: job.line,
    curves: job.curves,
    min_radius_m: job.minRadius,
    station_snap: job.stationSnap,
  }),
};
STUBS["B05_Profile_Api_Structures"] = anyModule({
  fetchStructures: async () => ({ structures: job.structures }),
  fetchStructureTypes: async () => job.types,
  readPendingStructures: () => null,
});
STUBS["B05_Profile_Api_TerrainGrid"] = {
  loadDesignTerrainGrid: async () => local,
  groundStageDeps: () => ({ grid: () => local, remote: async () => [] }),
};
STUBS["B04_PreProcess_Api_Fetch"] = {
  fetchDetailPipePoints: async () => ({
    pipe_points: job.pipes.map((pipe) => ({ ...pipe, lonlat: [0, 0] })),
  }),
};
STUBS["B06_Section_UI_Standard_Panel"] = {
  effectiveStandardCross: () => job.standard,
  readRockBoundaryDefault: () => -0.5,
};
// 구조물 초안 얹기(측점 계획 · 형상) — 이 시험 밖 · 아무 일 없음
STUBS["B06_Section_Section_Drafts"] = {
  withDraftStations: async () => undefined,
  withDraftShapes: async () => undefined,
  forgetDraftStations: () => undefined,
};
STUBS["B06_Section_Api_Fetch"] = {
  fetchSectionDetail: async () => JSON.parse(JSON.stringify(job.detail)),
  saveSections: async () => undefined,
};
// 횡단 다시 셈(브라우저 · B05 crossPreview · B06 카드 같은 창구) — 부른 횟수 · 면적은 서버와 달라짐(두 배)
let refreshCalls = 0;
const doubled = (detail) =>
  detail.cross_sections.forEach((section) => {
    if (!section.design) return;
    const design = { ...section.design };
    for (const [key, value] of Object.entries(design))
      if (key.endsWith("_m2") && typeof value === "number") design[key] = value * 2;
    section.design = design;
  });
STUBS["B06_Section_Cross_Refresh"] = {
  refreshCrossDesigns: async ({ detail }) => {
    refreshCalls += 1;
    doubled(detail);
    return detail.cross_sections.map((s) => s.chainage_m);
  },
  // 화면 선 맡김 · 낡음 판정 = 진짜 `staleAgainstScreen` 그대로(화면 선 → 없으면 상세 자기 선)
  holdScreenAlignment: (line) => {
    screenLine = line;
    return () => undefined;
  },
  staleAgainstScreen: (detail, routeId) => {
    const screen = screenLine?.(routeId);
    if (!screen) return common.hasStaleDesigns(detail);
    return common.hasStaleDesigns({
      longitudinal: {
        design_profiles: [
          profileData.toDesignProfile(screen, detail.longitudinal.design_profiles?.[0]),
        ],
      },
      cross_sections: detail.cross_sections,
    });
  },
  USER_TOUCHED_KEYS: [],
};
let screenLine = null;
STUBS["B06_Section_UI_Cross_Detail"] = anyModule();
STUBS["B06_Section_UI_Page_Common"] = anyModule({ L: (key) => key });
// 그리기 — 진짜 `renderProfile` 의 낡음 판정 줄만(같은 함수 · 같은 인자) · SVG 는 안 그림
const draws = [];
let opened = null;
STUBS["B05_Profile_UI_Profile_Render"] = {
  renderProfile: (ctx) => {
    const detail = ctx.detail();
    if (!detail) return;
    const alignment = ctx.alignment();
    const longitudinal = detail.longitudinal;
    const designProfiles = alignment
      ? [profileData.toDesignProfile(alignment, longitudinal.design_profiles?.[0])]
      : (longitudinal.design_profiles ?? []);
    const key = common.staleKey({
      longitudinal: { design_profiles: designProfiles },
      cross_sections: detail.cross_sections,
    });
    // 저장 상세를 그림 = 묶음 새 노선 상세(preview)가 아님 · 그린 객체(가게 것인지 견줌)
    draws.push({ key, saved: !detail.cross_sections.some((s) => s.preview), ref: detail });
    ctx.onStaleDesigns?.(key);
  },
};
STUBS["B05_Profile_UI_Profile_Tools"] = anyModule();
STUBS["design_profile_free_view"] = anyModule();
STUBS["B06_Section_UI_Cross_Panel_Base"] = anyModule();
globalThis.sessionStorage = window.sessionStorage;
STUBS["common_util_view_window"] = { frameOf: (_root, fn) => fn() };
for (const name of [
  "B05_Profile_UI_Profile_Balance",
  "B05_Profile_UI_Profile_Heights",
  "B05_Profile_UI_Profile_Zoom",
  "B05_Profile_UI_Profile_Drag",
  "B05_Profile_UI_Profile_MassHaul",
  "design_profile_overlays",
  "design_profile_viewport",
  "design_save",
  "B05_Profile_Api_Fetch",
  "common_util_mass_haul_balance_view",
])
  STUBS[name] = anyModule();

const pageMod = load("A00_Common", "design", "design_pipeline_page.ts");
const storeMod = load("A00_Common", "design", "design_store.ts");
const sectionStore = load("B06_Section", "B06_Section_Section_Store.ts");
const common = load("B06_Section", "B06_Section_UI_Section_Common.ts");
const layouts = load("B06_Section", "B06_Section_Structure_Layouts.ts");
const profileData = load("B05_Profile", "logic", "B05_Profile_UI_Profile_Data.ts");
const alignmentMod = load("B05_Profile", "logic", "B05_Profile_UI_Profile_Alignment.ts");
const baseMod = load("A00_Common", "design", "design_profile_base.ts");
const pageState = load("A00_Common", "b_page_state.ts");
const massHaul = load("common_util", "common_util_mass_haul.ts");
const historyMod = load("B05_Profile", "B05_Profile_UI_Profile_History.ts");
const profileMod = load("A00_Common", "design", "design_profile.ts");
const designSync = load("B06_Section", "B06_Section_UI_Page_Design_Sync.ts");
const designSession = load("B06_Section", "B06_Section_Cross_Design_Session.ts");
const stationKeys = load("B06_Section", "B06_Section_Station_Keys.ts");
// 진짜 다시 셈 창구(묶음 새 노선 상세를 안 고치는지만 봄 · 다른 곳은 위 가짜를 부름)
const realRefresh = loadTs(path.join(ROOT, "B06_Section", "B06_Section_Cross_Refresh.ts"));

const tick = (ms = 0) => new Promise((resolve) => setTimeout(resolve, ms));
const runs = () => globalThis.__aisloPipeline?.runs ?? [];
/** 묶음 · 상세 가게 · 다시 셈이 조용해질 때까지. */
async function quiet() {
  let seen = -1;
  for (let i = 0; i < 400; i += 1) {
    await tick(30);
    const last = runs()[runs().length - 1];
    const count = runs().length + refreshCalls * 1000 + draws.length * 1e6;
    if (count === seen && (!last || last.outcome !== "running")) return;
    seen = count;
  }
  throw new Error("묶음이 조용해지지 않음");
}
const n = job.nodes.length;
const draftOf = (nodes) => ({
  nodes,
  curveOn: Array(n).fill(true),
  curveRadius: Array(n).fill(null),
  curveLock: Array(n).fill(null),
  curveArc: Array(n).fill(null),
  stationSnap: job.stationSnap,
});
const shift = (index, dx, dy) =>
  job.nodes.map((node, i) => (i === index ? [node[0] + dx, node[1] + dy] : node));
const sliceRuns = (mark) =>
  runs()
    .slice(mark)
    .map((r) => ({
      sources: r.sources,
      outcome: r.outcome,
      restored: r.restored ?? null,
      why: r.restoreWhy ?? null,
    }));
const finalOf = (detail) => {
  const [series] = massHaul.computeMassHaulSeries(
    detail.longitudinal,
    detail.cross_sections,
    job.conversion,
    undefined,
    ["cross"],
  );
  const points = series?.result.points ?? [];
  return points.length ? points[points.length - 1].cumulative_volume_m3 : null;
};
const crossOf = (detail) =>
  JSON.stringify(detail.cross_sections.map((s) => [s.chainage_m, s.design, s.samples]));
/** 서버 정본 흉내 — 저장 횡단 계획고 = 열 때 종단도 계획선(낡음 0 · 서버가 낸 상세와 같음). */
function settleDesigns(detail) {
  const pa = detail.longitudinal.profile_alignment;
  const base = baseMod.listedBase(alignmentMod.toAlignmentBase(pa), detail, []);
  const samples = alignmentMod.buildAlignment(base, pa.edits).samples;
  const at = (c) => {
    const i = samples.findIndex((s) => s.chainage_m >= c);
    if (i < 0) return samples[samples.length - 1].elevation_m;
    if (i === 0) return samples[0].elevation_m;
    const a = samples[i - 1];
    const b = samples[i];
    return (
      a.elevation_m +
      ((b.elevation_m - a.elevation_m) * (c - a.chainage_m)) / (b.chainage_m - a.chainage_m)
    );
  };
  detail.cross_sections.forEach((s) => (s.design.design_elevation_m = at(s.chainage_m)));
}

async function run() {
  const P = "proj-349q";
  const R = 7;
  window.localStorage.setItem("frd_current_project_id", P);
  opened = await sectionStore.loadSectionDetail(P, R);
  settleDesigns(opened);
  stationKeys.useStationKeys(P, R, opened); // 상세가 측점을 얹은 뒤(Section_Drafts 몫 · 여기선 가짜)
  // 횡단 초안 칸 — 열기 전에 고친 카드 선택(단면 유형은 노선이 바뀌면 안 넘김 · 349-0o)
  for (const [chainage, value] of Object.entries(job.touched))
    designSession.writeCrossDesignChoice(P, R, Number(chainage), value);
  const profile = profileMod.createDesignProfile({
    projectId: P,
    view: "profile",
    onSelectStation: () => undefined,
  });
  const live = () => sectionStore.loadSectionDetail(P, R);
  pageMod.routeDraftBridge(P, profile, {
    stationIntervalM: job.interval,
    structureAreas: ({ cross_sections: rows }) =>
      layouts.applyStructureAreaRows(rows, layouts.structureAreaRows(rows)),
    // `design_view_profile` 의 holdDraft 그대로
    holdDraft: (routeId, saved) => {
      const hold = saved && sectionStore.holdSectionDetail(P, routeId, saved);
      return async (stations) => {
        if (!hold) {
          await sectionStore.swapSectionStations(P, routeId, stations);
          return "no-saved";
        }
        const back = await sectionStore.restoreSectionDetail(P, routeId, hold, stations);
        return !back ? "no-cache" : back.same ? "saved" : "saved-diff";
      };
    },
  });
  // 종단 보기 `renderSections` · followSwap 그대로 — 새 상세 → render · 비정규 측점 · 가게 stations → 갈아끼움
  const show = (detail) => {
    profile.render(detail, job.interval, R);
    profile.setIrregularStations([]);
  };
  const stopListen = sectionStore.subscribeSectionDetail(P, R, (next) => show(next));
  const stopStore = storeMod.useDesignStore(P, null).subscribe("stations", (stations) => {
    if (stations?.length) void sectionStore.swapSectionStations(P, R, stations);
  });
  // 횡단 보기 다시 셈 — 진짜 `B06_Section_UI_Page_Design_Sync`(낡음 · 계획고 초안이면 다시 셈) · 카드 = 그 상세
  const cards = () => pageMod.pipelineDetail(P) ?? cached;
  let cached = opened;
  const sync = designSync.createDesignSync({
    projectId: P,
    routeId: () => R,
    detail: () => cards(),
    view: () => ({ refreshCards: () => undefined }),
  });
  show(opened);
  profile.setEarthworkContext({ conversion: job.conversion });
  await quiet();

  const measure = async (mark, refreshMark) => {
    const detail = await live();
    const drawn = pageMod.pipelineDetail(P) ?? detail; // 종단도가 그리는 상세(초안 동안 묶음 새 상세)
    return {
      runs: sliceRuns(mark),
      refresh: refreshCalls - refreshMark,
      lastKey: draws[draws.length - 1]?.key ?? null,
      drawnSaved: draws[draws.length - 1]?.saved ?? null,
      drawnLive: draws[draws.length - 1]?.ref === detail,
      stations: detail.cross_sections.map((s) => s.chainage_m),
      final: finalOf(drawn),
      cross: crossOf(drawn),
      edits: JSON.stringify(profile.pipelineSource().edits),
      cells: JSON.stringify(
        ["crossdesign", "rockb"].map((name) => pageState.readState(name, P, R) ?? null),
      ),
    };
  };
  const open = await measure(0, 0);

  // 페이지 사진첩(진짜 `B05_Profile_UI_Profile_History` · 종단도 패널이 세움) — 되돌리기 · 다시 하기 = 세션 되씀 →
  // 종단도 편집 가게 다시 읽음(ctx.restore) → 노선 편집기가 다리에 알림(두 번 · 349-0m)
  const album = () => historyMod.pageHistory();
  const drag = async (redo = false) => {
    const mark = runs().length;
    const refreshMark = refreshCalls;
    const bridge = pageMod.routeDraftBridge(P, profile);
    const redone = redo ? album().redo() : null;
    if (!redo) (winListeners.keydown ?? []).forEach((fn) => fn({})); // 손길 — 사진첩 「열 때」 지남
    bridge.edited(draftOf(shift(1, 6, -4)));
    bridge.edited(draftOf(shift(1, 6, -4)));
    await quiet();
    if (!redo) album().record(); // 놓은 뒤 한 걸음
    // 초안 동안 횡단 카드가 갈아끼운 상세를 다시 셈(흉내 · 저장 상세 사본엔 안 닿아야)
    doubled(await live());
    // 횡단 보기 다시 셈 창구(진짜 `refreshCrossDesigns`)가 묶음 새 노선 상세를 부르면 — 안 고침(묶음 결과 그대로)
    const shown = pageMod.pipelineDetail(P);
    const before = crossOf(shown);
    const updated = await realRefresh.refreshCrossDesigns({
      projectId: P,
      routeId: R,
      detail: shown,
      edits: { station_offsets: {}, curve_radii: {} },
    });
    return {
      ...(await measure(mark, refreshMark)),
      draftRefresh: { updated, same: crossOf(shown) === before },
      redone,
    };
  };
  const undo = async () => {
    const mark = runs().length;
    const refreshMark = refreshCalls;
    const bridge = pageMod.routeDraftBridge(P, profile);
    const undone = album().undo();
    bridge.edited(null);
    bridge.edited(null);
    await quiet();
    return { ...(await measure(mark, refreshMark)), undone };
  };
  const first = await drag();
  const back1 = await undo();
  const back1Same = (await live()) === opened;
  // 되돌린 뒤 목록 · 알약 다시 맞춤이 가게 관 · 구조물을 다시 씀(같은 목록 · 꼴만 다름) — 묶음이 한 차례 돎
  const echoMark = runs().length;
  const echoRefresh = refreshCalls;
  const designStore = storeMod.useDesignStore(P, null);
  designStore.set(
    "structures",
    job.structures.map((s) => ({ ...s, memo: "" })),
  );
  designStore.set(
    "pipes",
    job.pipes.map((p) => ({ ...p, memo: "" })),
  );
  await quiet();
  const echo = { ...(await measure(echoMark, echoRefresh)), sameObject: (await live()) === opened };
  const redo = await drag(true);
  const back2 = await undo();

  // 횡단 보기(B06) — 카드 상세 다시 받음 · 진입 다시 셈 판정 · 종단도는 횡단 보기 자리
  let mark = runs().length;
  let refreshMark = refreshCalls;
  cached = await live();
  profile.setView("cross");
  show(cards());
  profile.setEarthworkContext({ conversion: job.conversion });
  await sync.reconcileStaleDesigns();
  await quiet();
  const cross = await measure(mark, refreshMark);
  // 종단 보기(B05)로
  mark = runs().length;
  refreshMark = refreshCalls;
  profile.setView("profile");
  profile.setActive(true);
  await quiet();
  const back = await measure(mark, refreshMark);
  const blocked = pageMod.pagePipeline(P).blockedWrites;
  const restoreDiffs = runs()
    .filter((r) => r.restoreDiff)
    .map((r) => r.restoreDiff);
  stopListen();
  stopStore();
  pageMod.disposePagePipeline(P);
  return { open, first, back1, echo, redo, back2, cross, back, blocked, restoreDiffs, back1Same };
}

run()
  .then((out) => {
    process.stdout.write(JSON.stringify(out));
    process.exit(0);
  })
  .catch((error) => {
    process.stderr.write(String(error && error.stack ? error.stack : error));
    process.exit(1);
  });