Aislo/B06_Section/B06_Section_UI_Cross_Ford_Geom.ts

/* =============================================================================
 * B06_Section_UI_Cross_Ford_Geom.ts
 * 세월교 구체 **기하 계산** — 그리기(`_Cross_Ford.ts`)와 분리(700줄 제한).
 * 백엔드 `section.ford` 제원을 좌표로 옮긴다(치수 결정 금지).
 *
 * 구성(2026-08-25 사용자 확정):
 *   · 양측 **측벽** = ㄴ형 집수정을 그대로 재사용한다(`buildBasin`) — 전면 1:0.3
 *     기움·좌우·상하(대각) 이동·계류측 성토부선이 집수정과 같은 규칙으로 따라온다.
 *   · **바닥판** = 두 측벽 사이를 잇는 판 + 각 측 바깥으로 **날개벽 투영**(길이×cos각)
 *     만큼 뻗은 판. 집수정 내공 폭 자리에 그 연장량을 넣어 같은 기하로 만든다.
 *   · **관**은 바닥판 상면(측벽 바깥면)에 안히고, 관 위 ~ 노면 아래는 **성토(노체)** 다.
 *   · 구체는 월류 폭만큼 도로 방향으로 이어져 기준 측점 전후로 절반씩 걸친다
 *     (붙는 측점 판정은 백엔드 `attach_culvert_sets`).
 * 성토측이라도 기슭막이 세트(다단·재질)와는 연계하지 않는다.
 * ========================================================================== */

import type { CrossSection, FordSet, SectionSample } from "./B06_Section_Api_Fetch";
import { pipeWallThicknessM } from "./B06_Section_UI_Cross_Culvert_Const";
import type {
  BasinLayout,
  CulvertDesignTrim,
  OffsetPoint,
  OutletFillSegment,
} from "./B06_Section_UI_Cross_Culvert_Types";
import { basinApproachPoints, buildBasin } from "./B06_Section_UI_Cross_Culvert_Basin";
import { buildExtrasAt } from "./B06_Section_UI_Cross_Culvert_Extra";
import { designInterpolator, groundInterpolator } from "./B06_Section_UI_Cross_Culvert_Solve";

/** 측벽 한 매의 조작값 — 집수정 9키와 같은 축(높이·좌우·상하 대각). */
export interface FordWallAdjust {
  /** 벽 높이(m, 노견 상단 ~ 바닥판 상면). null = 자동(바닥판이 계류 하상에 놓임). */
  heightM: number | null;
  /** 좌우(m, + = 노견 바깥). 안쪽으로는 못 간다. */
  lateralM: number;
  /** 상하(m, 수평 성분, + = 사면 아래) — 집수정과 같이 1:1.2 대각으로 내려간다. */
  slopeM: number;
}

/** 측점별 세월교 조정값 — 유입·유출 측벽을 따로 잡는다. */
export interface FordAdjust {
  inlet: FordWallAdjust;
  outlet: FordWallAdjust;
}

export const DEFAULT_FORD_WALL_ADJUST: FordWallAdjust = {
  heightM: null,
  lateralM: 0,
  slopeM: 0,
};

export const DEFAULT_FORD_ADJUST: FordAdjust = {
  inlet: DEFAULT_FORD_WALL_ADJUST,
  outlet: DEFAULT_FORD_WALL_ADJUST,
};

export type FordWallRole = "inlet" | "outlet";

export interface FordSideLayout {
  role: FordWallRole;
  /** 계류측 방향 부호(+ = 좌). */
  outward: number;
  /** 벽·바닥판 폴리곤(집수정 ㄴ형과 같은 부재 구성). */
  parts: BasinLayout["parts"];
  /** 벽 상단 도로측 꼭짓점 = 설계선 트림 경계. */
  top: OffsetPoint;
  heightM: number;
  /** 바닥판 상면 표고(이동 반영) = 이쪽 관 끝의 invert. */
  slabTopElevation: number;
  /** 관 끝점(벽 바깥면 × 바닥판 상면). */
  pipeEnd: OffsetPoint;
  /** 바닥판 안쪽 변(위·아래) — 두 측벽 사이를 잇는 판이 여기서 시작한다. */
  slabInner: [OffsetPoint, OffsetPoint];
  /** 구조물 계류측 끝이 원지반 위일 때의 성토부선(집수정과 같은 체계). */
  fillSegments: OutletFillSegment[];
  /** 원지반 안으로 박힐 때의 절토선. */
  cutLine: BasinLayout["cutLine"];
  /**
   * 노견 → 벽 상단 접근선(2026-08-25 사용자) — **좌우 이동은 노견이 수평으로
   * 확장**되고, 상하(대각) 이동분만 성토선이 된다(집수정과 같은 규칙).
   * 이동이 없으면 null.
   */
  approach: OffsetPoint[] | null;
  /** 한계에 걸려 실제 적용된 조작값. */
  adjust: FordWallAdjust;
}

export interface FordLayout {
  ford: FordSet;
  sides: FordSideLayout[];
  /** 두 측벽 사이를 잇는 바닥판. */
  slabBridge: OffsetPoint[];
  /** 바닥판 전체 길이(m) — 날개벽 연장 포함. */
  slabLengthM: number;
  /** 관 외곽·내경 사각형(양 끝은 각 측 바닥판 상면). */
  pipe: { outer: OffsetPoint[]; inner: OffsetPoint[] };
  label: { at: OffsetPoint; text: string };
  designTrim: CulvertDesignTrim;
  adjust: FordAdjust;
}

/** 측벽 높이 하한 = 관경 + 최소 토피. 관이 노면 위로 솟지 않게 막는다. */
function minWallHeight(ford: FordSet): number {
  return ford.diameter_m + ford.min_cover_m;
}

/** 성토 채움 윗면을 만들 노면 표고 — 설계선이 있으면 그 곡선, 없으면 노견 직선. */
function roadTopFactory(
  section: CrossSection,
  left: { offset_m: number; elevation_m: number },
  right: { offset_m: number; elevation_m: number },
): (offset: number) => number {
  const designAt = designInterpolator(section.design?.design_line);
  if (designAt) return designAt;
  const span = left.offset_m - right.offset_m;
  return (offset: number): number => {
    if (Math.abs(span) < 1e-6) return left.elevation_m;
    const t = (offset - right.offset_m) / span;
    return right.elevation_m + (left.elevation_m - right.elevation_m) * t;
  };
}

/**
 * 세월교 구체 기하. 제원·설계선·지반이 부족하면 null (그리기와 분리 — 설계선 트림이
 * 먼저 쓴다).
 */
export function computeFordLayout(
  section: CrossSection,
  groundSamples: SectionSample[],
  adjust: FordAdjust = DEFAULT_FORD_ADJUST,
): FordLayout | null {
  const ford = section.ford;
  if (!ford) return null;
  const edges = section.design?.road_edges;
  if (!edges) return null;
  const groundAt = groundInterpolator(groundSamples);
  if (!groundAt) return null;
  const sampleOffsets = groundSamples.map((sample) => sample.offset_m ?? 0);
  const minSample = Math.min(...sampleOffsets);
  const maxSample = Math.max(...sampleOffsets);
  if (!(maxSample > minSample)) return null;

  // 좌표 규약: +offset = 좌측. 유입 = 상단측(미상이면 좌측 폴백).
  const uphill = section.uphill_side ?? "left";
  const inletOnLeft = uphill === "left";
  const roadTopAt = roadTopFactory(section, edges.left, edges.right);
  const cutSlopeRatio = section.design?.cut_slope_ratio ?? 1.0;

  // 바닥판이 놓일 계류 하상 — 두 노견 사이 원지반 최저점.
  const bedElevation = (() => {
    let low = Math.min(groundAt(edges.left.offset_m), groundAt(edges.right.offset_m));
    for (let offset = edges.right.offset_m; offset <= edges.left.offset_m; offset += 0.25) {
      low = Math.min(low, groundAt(offset));
    }
    return low;
  })();

  const buildSide = (role: FordWallRole): FordSideLayout | null => {
    const onLeft = role === "inlet" ? inletOnLeft : !inletOnLeft;
    const edge = onLeft ? edges.left : edges.right;
    const outward = onLeft ? 1 : -1;
    const limitOffset = onLeft ? maxSample : minSample;
    const wing = role === "inlet" ? ford.wing_in : ford.wing_out;
    const wanted = role === "inlet" ? adjust.inlet : adjust.outlet;
    const lateralM = Math.max(wanted.lateralM, 0);
    const autoHeight = roadTopAt(edge.offset_m) - (bedElevation + ford.slab_thickness_m);
    const heightM = Math.max(wanted.heightM ?? autoHeight, minWallHeight(ford));
    // 벽 상단이 노견에 붙도록 바닥판 상면을 역산한다. 상하 이동은 buildBasin이 얹는다.
    const anchor: OffsetPoint = {
      offset: edge.offset_m,
      elevation: roadTopAt(edge.offset_m) - heightM,
    };
    const built = buildBasin({
      anchor,
      outward,
      shape: "L",
      reason: "manual",
      diameterM: ford.diameter_m,
      edge: { offset_m: edge.offset_m, elevation_m: roadTopAt(edge.offset_m) },
      groundAt,
      cutSlopeRatio,
      // 내공 폭 자리에 날개벽 투영 연장을 넣는다 — 바닥판이 그만큼 계류측으로 뻗는다.
      adjust: {
        innerWidthM: Math.max(wing.slab_extend_m, 0),
        innerHeightM: heightM,
        lateralM,
        slopeM: wanted.slopeM,
      },
      memberThicknessM: ford.wall_thickness_m,
      floorThicknessM: ford.slab_thickness_m,
    });
    const wall = built.basin.parts.find((part) => part.kind === "wall");
    const floor = built.basin.parts.find((part) => part.kind === "floor");
    if (!wall || !floor) return null;
    const extras = buildExtrasAt(built.fillStart, {
      startBottomElevation: built.fillBottomElevation,
      outward,
      groundAt,
      limitOffset,
      adjusts: [],
      equalize: false,
    });
    // 접근선 — 좌우 이동분은 노견 표고 그대로 수평, 상하 이동분만 대각(1:1.2).
    const approach = basinApproachPoints(
      { offset_m: edge.offset_m, elevation_m: roadTopAt(edge.offset_m) },
      outward,
      { innerWidthM: 0, innerHeightM: 0, lateralM, slopeM: wanted.slopeM },
      { offset: built.trimOffset, elevation: built.trimElevation },
    );
    return {
      role,
      outward,
      parts: built.basin.parts,
      top: { offset: built.trimOffset, elevation: built.trimElevation },
      approach,
      heightM,
      slabTopElevation: built.pipeEnd.elevation,
      pipeEnd: built.pipeEnd,
      slabInner: [floor.points[0], floor.points[3]],
      fillSegments: extras.segments,
      cutLine: built.basin.cutLine,
      adjust: {
        heightM: wanted.heightM === null ? null : heightM,
        lateralM,
        slopeM: wanted.slopeM,
      },
    };
  };

  const inlet = buildSide("inlet");
  const outlet = buildSide("outlet");
  if (!inlet || !outlet) return null;
  const sides = [inlet, outlet];
  const left = inlet.outward > 0 ? inlet : outlet;
  const right = inlet.outward > 0 ? outlet : inlet;

  // 두 측벽 사이를 잇는 바닥판 — 각 측 바닥판 안쪽 변을 그대로 잇는다.
  const slabBridge: OffsetPoint[] = [
    left.slabInner[0],
    right.slabInner[0],
    right.slabInner[1],
    left.slabInner[1],
  ];
  const slabLengthM = Math.abs(
    Math.max(...sides.map((side) => side.parts[1].points[1].offset)) -
      Math.min(...sides.map((side) => side.parts[1].points[1].offset)),
  );

  // 관 — 각 측 바닥판 상면(벽 바깥면)에 안힌다. 양측 표고가 다르면 그만큼 기운다.
  const pipeWall = pipeWallThicknessM(ford.pipe_kind, ford.diameter_m);
  const leftInvert = left.pipeEnd;
  const rightInvert = right.pipeEnd;
  const rise = (point: OffsetPoint, dz: number): OffsetPoint => ({
    offset: point.offset,
    elevation: point.elevation + dz,
  });
  const pipe = {
    outer: [
      rise(leftInvert, ford.diameter_m),
      rise(rightInvert, ford.diameter_m),
      rightInvert,
      leftInvert,
    ],
    inner: [
      rise(leftInvert, ford.diameter_m - pipeWall),
      rise(rightInvert, ford.diameter_m - pipeWall),
      rise(rightInvert, pipeWall),
      rise(leftInvert, pipeWall),
    ],
  };

  const countText = ford.pipe_count > 1 ? ` ${ford.pipe_count}련` : "";
  return {
    ford,
    sides,
    slabBridge,
    slabLengthM,
    pipe,
    label: {
      at: {
        offset: (leftInvert.offset + rightInvert.offset) / 2,
        elevation: (leftInvert.elevation + rightInvert.elevation) / 2 + ford.diameter_m / 2,
      },
      text: `${ford.pipe_kind ?? "관"} Ø${Math.round(ford.diameter_m * 1000)}${countText}`,
    },
    // 노견 밖 설계선은 측벽이 대신한다 — 벽 상단 도로측 꼭짓점에서 끊는다.
    // 이동이 있으면 접근선(노견 수평 연장 → 대각)을 실어 설계선이 그 경로로 온다.
    designTrim: {
      minOffset: right.top.offset,
      maxOffset: left.top.offset,
      minElevation: right.top.elevation,
      maxElevation: left.top.elevation,
      minSlope: right.approach ? { points: right.approach } : undefined,
      maxSlope: left.approach ? { points: left.approach } : undefined,
    },
    adjust: { inlet: inlet.adjust, outlet: outlet.adjust },
  };
}