import type { BoundingBox, ModelingCmd } from '@kittycad/lib'
import { getBodiesFromArtifactGraph } from '@src/lang/std/artifactGraph'
import { humanDisplayNumber, type VariableMap } from '@src/lang/wasm'
import { useSingletons } from '@src/lib/boot'
import { isModelingResponse } from '@src/lib/kcSdkGuards'
import { engineStreamZoomToFit, engineViewIsometric } from '@src/lib/utils'
import { uuidv4 } from '@src/lib/utils'
import { useEffect, useMemo, useRef, useState } from 'react'
import toast from 'react-hot-toast'
import {
  buildExplodeOffsets,
  createSnapshotDataUrl,
  createBomCsv,
  createEngineeringSheetHtml,
  detectPanelHoles,
  filterManufacturingBodies,
  getOverallBounds,
  groupBodiesIntoBom,
  parseManufacturingLengthInMillimeters,
  reconcileManufacturingDimensions,
  type BodyMeasurement,
  type BomRow,
  type CircularEdgeSample,
  type ExplodeOffset,
  type ManufacturingLengthParameter,
} from './manufacturing'

type ModelingResponse = {
  type: string
  data?: unknown
}

type BomOverrides = Record<
  string,
  {
    name?: string
    material?: string
    process?: string
  }
>

type BrandSettings = {
  name: string
  logoUrl: string
}

function collectManufacturingLengthParameters(
  variables: VariableMap,
  wasmInstance: Parameters<typeof humanDisplayNumber>[2]
): ManufacturingLengthParameter[] {
  return Object.entries(variables).flatMap(([name, value]) => {
    if (!value || value.type !== 'Number') return []
    const displayValue = humanDisplayNumber(value.value, value.ty, wasmInstance)
    if (displayValue instanceof Error) return []
    const valueMm = parseManufacturingLengthInMillimeters(displayValue)
    return valueMm === undefined ? [] : [{ name, valueMm }]
  })
}

async function settleInBatches<T, Result>(
  values: T[],
  batchSize: number,
  worker: (value: T, index: number) => Promise<Result>
) {
  const results: Array<PromiseSettledResult<Result>> = []
  for (let offset = 0; offset < values.length; offset += batchSize) {
    const batch = values.slice(offset, offset + batchSize)
    results.push(
      ...(await Promise.allSettled(
        batch.map((value, index) => worker(value, offset + index))
      ))
    )
  }
  return results
}

function isTransientEngineFailure(message: string) {
  return /(?:not ready|not initialized|initializ|temporar|timeout|timed out|busy|pending|connection|disconnected|stream|try again|retry|尚未就绪|初始化|连接|繁忙|稍后重试)/i.test(
    message
  )
}

function downloadText(filename: string, text: string, type: string) {
  const blob = new Blob([text], { type })
  const url = URL.createObjectURL(blob)
  const anchor = document.createElement('a')
  anchor.href = url
  anchor.download = filename
  anchor.click()
  URL.revokeObjectURL(url)
}

function collectArtifactIds(
  value: unknown,
  ids: Set<string>,
  seen = new WeakSet<object>(),
  depth = 0
) {
  if (depth > 8 || value === null || typeof value !== 'object') return
  if (seen.has(value)) return
  seen.add(value)

  if ('artifactId' in value && typeof value.artifactId === 'string') {
    ids.add(value.artifactId)
  }
  if ('artifact_id' in value && typeof value.artifact_id === 'string') {
    ids.add(value.artifact_id)
  }
  if ('id' in value && typeof value.id === 'string') {
    ids.add(value.id)
  }

  for (const nested of Object.values(value)) {
    collectArtifactIds(nested, ids, seen, depth + 1)
  }
}

function resolveBodyName(
  bodyId: string,
  variables: Record<string, unknown>,
  fallbackIndex: number
) {
  for (const [name, value] of Object.entries(variables)) {
    const ids = new Set<string>()
    collectArtifactIds(value, ids)
    if (ids.has(bodyId)) return name
  }
  return `零件 ${String(fallbackIndex + 1).padStart(2, '0')}`
}

function modelingResponseData(response: unknown): ModelingResponse {
  const normalized = Array.isArray(response) ? response[0] : response
  if (!isModelingResponse(normalized)) {
    throw new Error(engineFailureMessage(response))
  }
  return normalized.resp.data.modeling_response as ModelingResponse
}

function engineFailureMessage(response: unknown) {
  const responses = Array.isArray(response) ? response : [response]
  const messages = responses.flatMap((item) => {
    if (item instanceof Error) return [item.message]
    if (typeof item !== 'object' || item === null || !('errors' in item)) {
      return []
    }
    const errors = (item as { errors?: unknown }).errors
    if (!Array.isArray(errors)) return []
    return errors.flatMap((error) => {
      if (typeof error === 'string') return [error]
      if (
        typeof error === 'object' &&
        error !== null &&
        'message' in error &&
        typeof error.message === 'string'
      ) {
        return [error.message]
      }
      return []
    })
  })

  return messages.find((message) => message.trim()) ?? 'HiCAD 引擎未返回有效结果'
}

function numberValue(data: unknown, key: string) {
  if (typeof data !== 'object' || data === null) return undefined
  const value = (data as Record<string, unknown>)[key]
  return typeof value === 'number' ? value : undefined
}

function formatNumber(value: number | undefined) {
  if (value === undefined) return '-'
  return Math.round(value * 100) / 100
}

export function HicadManufacturingPanel({
  hideTrigger = false,
  initialOpen = false,
  onRequestClose,
  projectName,
}: {
  hideTrigger?: boolean
  initialOpen?: boolean
  onRequestClose?: () => void
  projectName: string
}) {
  const { kclManager } = useSingletons()
  const [open, setOpen] = useState(initialOpen)
  const [busy, setBusy] = useState(false)
  const [bodies, setBodies] = useState<BodyMeasurement[]>([])
  const [snapshot, setSnapshot] = useState<string>()
  const [exploded, setExploded] = useState(false)
  const [overrides, setOverrides] = useState<BomOverrides>({})
  const [brand, setBrand] = useState<BrandSettings>({
    name: '由壹点AI',
    logoUrl: '/api/favicon?surface=hicad',
  })
  const [notes, setNotes] = useState(
    '材料、表面处理、公差、连接方式和检验标准须在投产前由工程人员复核。'
  )
  const explodeOffsetsRef = useRef<ExplodeOffset[]>([])
  const resolvedProjectName = projectName || 'HiCAD 模型'

  const loadBrandSettings = async () => {
    try {
      const response = await fetch('/api/site-settings?scope=chat', {
        credentials: 'same-origin',
      })
      if (!response.ok) return
      const settings = (await response.json()) as Record<string, unknown>
      const name =
        typeof settings.siteName === 'string' && settings.siteName.trim()
          ? settings.siteName.trim()
          : '由壹点AI'
      const configuredLogo =
        typeof settings.siteLogo === 'string' && settings.siteLogo.trim()
          ? settings.siteLogo.trim()
          : typeof settings.siteLogoDark === 'string' &&
              settings.siteLogoDark.trim()
            ? settings.siteLogoDark.trim()
            : '/api/favicon?surface=hicad'
      setBrand({ name, logoUrl: configuredLogo })
    } catch {
      // Keep the built-in website branding when settings are unavailable.
    }
  }

  const sendModelingCommand = async (cmd: ModelingCmd) => {
    const maxAttempts = 15

    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
      const response = await kclManager.engineCommandManager.sendSceneCommand({
        type: 'modeling_cmd_req',
        cmd_id: uuidv4(),
        cmd,
      })
      const normalized = Array.isArray(response) ? response[0] : response

      if (isModelingResponse(normalized)) {
        return modelingResponseData(normalized)
      }
      if (response !== null && response !== undefined) {
        const message = engineFailureMessage(response)
        if (attempt < maxAttempts - 1 && isTransientEngineFailure(message)) {
          await new Promise((resolve) =>
            setTimeout(resolve, Math.min(150 * (attempt + 1), 900))
          )
          continue
        }
        console.error('[HiCAD manufacturing] Engine command failed', {
          command: cmd.type,
          message,
          response,
        })
        throw new Error(message)
      }

      await new Promise((resolve) => setTimeout(resolve, 200))
    }

    throw new Error('HiCAD 引擎连接尚未就绪，请稍后重新分析')
  }

  const getSceneSolidIds = async () => {
    const response = await sendModelingCommand({
      type: 'scene_get_entity_ids',
      filter: ['solid3d'],
      skip: 0,
      take: 1000,
    })
    if (
      response.type !== 'scene_get_entity_ids' ||
      typeof response.data !== 'object' ||
      response.data === null ||
      !('entity_ids' in response.data) ||
      !Array.isArray(response.data.entity_ids)
    ) {
      return []
    }

    return [
      ...new Set(
        response.data.entity_ids.flatMap((ids) =>
          Array.isArray(ids)
            ? ids.filter((id): id is string => typeof id === 'string')
            : []
        )
      ),
    ]
  }

  const readEntityChildIds = async (entityId: string) => {
    const response = await sendModelingCommand({
      type: 'entity_get_all_child_uuids',
      entity_id: entityId,
    })
    if (
      response.type !== 'entity_get_all_child_uuids' ||
      typeof response.data !== 'object' ||
      response.data === null ||
      !('entity_ids' in response.data) ||
      !Array.isArray(response.data.entity_ids)
    ) {
      return []
    }
    return response.data.entity_ids.filter(
      (id): id is string => typeof id === 'string'
    )
  }

  const readCircularSamples = async (entityIds: string[]) => {
    const typedEntities = await settleInBatches(
      [...new Set(entityIds)],
      6,
      async (entityId) => {
        const response = await sendModelingCommand({
          type: 'get_entity_type',
          entity_id: entityId,
        })
        const entityType =
          response.type === 'get_entity_type' &&
          typeof response.data === 'object' &&
          response.data !== null &&
          'entity_type' in response.data &&
          typeof response.data.entity_type === 'string'
            ? response.data.entity_type
            : undefined
        return { entityId, entityType }
      }
    )
    const curveCandidates = typedEntities.flatMap((result) =>
      result.status === 'fulfilled' &&
      (result.value.entityType === 'edge' ||
        result.value.entityType === 'curve')
        ? [result.value]
        : []
    )
    const edgeResults = await settleInBatches(
      curveCandidates,
      4,
      async ({ entityId, entityType }) => {
        const typeResponse = await sendModelingCommand({
          type: 'curve_get_type',
          curve_id: entityId,
        })
        const curveType =
          typeResponse.type === 'curve_get_type' &&
          typeof typeResponse.data === 'object' &&
          typeResponse.data !== null &&
          'curve_type' in typeResponse.data
            ? typeResponse.data.curve_type
            : undefined
        if (curveType !== 'arc' && curveType !== 'nurbs') return undefined

        const [pointsResult, lengthResult] = await Promise.allSettled([
          sendModelingCommand({
            type: 'curve_get_control_points',
            curve_id: entityId,
          }),
          entityType === 'edge'
            ? sendModelingCommand({
                type: 'edge_get_length',
                edge_id: entityId,
              })
            : Promise.resolve(undefined),
        ])
        if (
          pointsResult.status !== 'fulfilled' ||
          pointsResult.value.type !== 'curve_get_control_points' ||
          typeof pointsResult.value.data !== 'object' ||
          pointsResult.value.data === null ||
          !('control_points' in pointsResult.value.data) ||
          !Array.isArray(pointsResult.value.data.control_points)
        ) {
          return undefined
        }
        const controlPoints =
          pointsResult.value.data.control_points.flatMap((point) =>
            typeof point === 'object' &&
            point !== null &&
            'x' in point &&
            'y' in point &&
            'z' in point &&
            typeof point.x === 'number' &&
            typeof point.y === 'number' &&
            typeof point.z === 'number'
              ? [{ x: point.x, y: point.y, z: point.z }]
              : []
          )
        let length: number | undefined
        if (
          lengthResult.status === 'fulfilled' &&
          lengthResult.value &&
          lengthResult.value.type === 'edge_get_length' &&
          typeof lengthResult.value.data === 'object' &&
          lengthResult.value.data !== null &&
          'length' in lengthResult.value.data &&
          typeof lengthResult.value.data.length === 'number'
        ) {
          length = lengthResult.value.data.length
        }
        return { controlPoints, length } satisfies CircularEdgeSample
      }
    )

    return edgeResults.flatMap((result) =>
      result.status === 'fulfilled' && result.value ? [result.value] : []
    )
  }

  const readCircularEdges = async (bodyId: string) => {
    try {
      const childSamples = await readCircularSamples(
        await readEntityChildIds(bodyId)
      )
      if (childSamples.length > 0) return childSamples

      const sketchResponse = await sendModelingCommand({
        type: 'entity_get_sketch_paths',
        entity_id: bodyId,
      })
      if (
        sketchResponse.type !== 'entity_get_sketch_paths' ||
        typeof sketchResponse.data !== 'object' ||
        sketchResponse.data === null ||
        !('entity_ids' in sketchResponse.data) ||
        !Array.isArray(sketchResponse.data.entity_ids)
      ) {
        return []
      }
      const sketchIds = sketchResponse.data.entity_ids.filter(
        (id): id is string => typeof id === 'string'
      )
      const sketchChildren = await settleInBatches(
        sketchIds,
        4,
        async (sketchId) => [sketchId, ...(await readEntityChildIds(sketchId))]
      )
      const sketchEntityIds = sketchChildren.flatMap((result) =>
        result.status === 'fulfilled' ? result.value : []
      )
      return readCircularSamples(sketchEntityIds)
    } catch (error) {
      console.warn(
        '[HiCAD manufacturing] Unable to inspect circular body edges',
        { bodyId, error }
      )
      return []
    }
  }

  const readBoundingBox = async (entityIds: string[]) => {
    const response = await sendModelingCommand({
      type: 'bounding_box',
      entity_ids: entityIds,
      output_unit: 'mm',
    })
    if (
      response.type !== 'bounding_box' ||
      typeof response.data !== 'object' ||
      response.data === null
    ) {
      throw new Error('HiCAD 引擎没有返回尺寸数据')
    }
    return response.data as BoundingBox
  }

  const captureSnapshot = async () => {
    const response = await sendModelingCommand({
      type: 'take_snapshot',
      format: 'png',
    })
    if (
      response.type !== 'take_snapshot' ||
      typeof response.data !== 'object' ||
      response.data === null ||
      !('contents' in response.data) ||
      typeof response.data.contents !== 'string'
    ) {
      return undefined
    }
    const dataUrl = createSnapshotDataUrl(response.data.contents)
    setSnapshot(dataUrl)
    return dataUrl
  }

  const resetExplodeTransforms = async () => {
    const offsets = explodeOffsetsRef.current
    if (offsets.length === 0) return

    await Promise.allSettled(
      offsets.map(({ id, offset }) =>
        sendModelingCommand({
          type: 'set_object_transform',
          object_id: id,
          transforms: [
            {
              translate: {
                property: {
                  x: -offset.x,
                  y: -offset.y,
                  z: -offset.z,
                },
                set: false,
                origin: { type: 'global' },
              },
            },
          ],
        })
      )
    )
    explodeOffsetsRef.current = []
    setExploded(false)
  }

  const analyzeModel = async (manageBusy = true) => {
    if (manageBusy) setBusy(true)
    try {
      if (explodeOffsetsRef.current.length > 0) {
        await resetExplodeTransforms()
      }

      const artifactBodies = [
        ...getBodiesFromArtifactGraph(
          kclManager.execStateSignal.value.artifactGraph
        ),
      ]
      let sceneBodyIds: string[] = []
      try {
        sceneBodyIds = await getSceneSolidIds()
      } catch (error) {
        console.warn(
          '[HiCAD manufacturing] Unable to enumerate scene solids; using artifact graph',
          error
        )
      }
      const bodyIds =
        sceneBodyIds.length > 0
          ? sceneBodyIds
          : artifactBodies.map(([bodyId]) => bodyId)

      if (bodyIds.length === 0) {
        throw new Error('当前模型还没有可识别的实体')
      }

      const variables = kclManager.variablesSignal.value as VariableMap
      const wasmInstance = await kclManager.wasmInstancePromise
      const lengthParameters = collectManufacturingLengthParameters(
        variables,
        wasmInstance
      )
      const measurementResults = await settleInBatches(
        bodyIds,
        3,
        async (bodyId, index): Promise<BodyMeasurement> => {
          const boundingBox = await readBoundingBox([bodyId])
          const [volumeResponse, areaResponse] = await Promise.allSettled([
            sendModelingCommand({
              type: 'volume',
              entity_ids: [bodyId],
              output_unit: 'mm3',
            }),
            sendModelingCommand({
              type: 'surface_area',
              entity_ids: [bodyId],
              output_unit: 'mm2',
            }),
          ])

          const measurement: BodyMeasurement = {
            id: bodyId,
            name: resolveBodyName(bodyId, variables, index),
            center: boundingBox.center,
            dimensions: boundingBox.dimensions,
            volume:
              volumeResponse.status === 'fulfilled'
                ? numberValue(volumeResponse.value.data, 'volume')
                : undefined,
            surfaceArea:
              areaResponse.status === 'fulfilled'
                ? numberValue(areaResponse.value.data, 'surface_area')
                : undefined,
          }
          const circularEdges = await readCircularEdges(bodyId)
          measurement.holes = detectPanelHoles(measurement, circularEdges)
          return measurement
        }
      )
      const measured = measurementResults.flatMap((result) =>
        result.status === 'fulfilled' ? [result.value] : []
      )
      const measurementErrors = measurementResults.flatMap((result) =>
        result.status === 'rejected'
          ? [
              result.reason instanceof Error
                ? result.reason.message
                : String(result.reason),
            ]
          : []
      )

      if (measured.length === 0) {
        try {
          const overallBoundingBox = await readBoundingBox([])
          measured.push({
            id: 'hicad-scene-aggregate',
            name: '模型整体',
            center: overallBoundingBox.center,
            dimensions: overallBoundingBox.dimensions,
          })
          toast(
            '当前引擎只返回了整模尺寸，已生成整体工程记录；独立零件 BOM 需模型包含可分离实体。'
          )
        } catch (error) {
          const details =
            measurementErrors[0] ||
            (error instanceof Error ? error.message : String(error))
          throw new Error(`无法读取模型尺寸：${details}`)
        }
      } else if (measurementErrors.length > 0) {
        toast(
          `已识别 ${measured.length} 个实体，另有 ${measurementErrors.length} 个实体暂时无法测量。`
        )
      }

      const manufacturingBodies = reconcileManufacturingDimensions(
        filterManufacturingBodies(measured),
        lengthParameters
      )
      const parametricCount = manufacturingBodies.filter(
        (body) => body.dimensionSource === 'kcl-parameters'
      ).length
      const correctedCount = manufacturingBodies.filter(
        (body) => body.engineDimensions !== undefined
      ).length
      if (parametricCount > 0) {
        toast.success(
          correctedCount > 0
            ? `已按 KCL 参数校准 ${parametricCount} 个零件，修正 ${correctedCount} 项场景缩放尺寸。`
            : `已使用 KCL 参数核验 ${parametricCount} 个零件的制造尺寸。`
        )
      }
      if (manufacturingBodies.length < measured.length) {
        toast(
          `已忽略 ${measured.length - manufacturingBodies.length} 个建模模板实体。`
        )
      }
      setBodies(manufacturingBodies)
      await Promise.allSettled([
        engineViewIsometric({
          engineCommandManager: kclManager.engineCommandManager,
          padding: 0.22,
        }),
        engineStreamZoomToFit({
          engineCommandManager: kclManager.engineCommandManager,
          padding: 0.24,
        }),
      ])
      await new Promise((resolve) => setTimeout(resolve, 180))
      try {
        await captureSnapshot()
      } catch (error) {
        console.warn(
          '[HiCAD manufacturing] Snapshot failed after successful analysis',
          error
        )
      }
      return manufacturingBodies
    } catch (error) {
      const message =
        error instanceof Error ? error.message : '工程数据分析失败'
      toast.error(message)
      return []
    } finally {
      if (manageBusy) setBusy(false)
    }
  }

  // This component is lazy-mounted by the launcher, so automatic analysis only
  // starts after the user explicitly opens the engineering tools.
  useEffect(() => {
    if (!initialOpen) return
    void loadBrandSettings()
    void analyzeModel()
  }, [initialOpen])

  const handleOpen = () => {
    setOpen(true)
    void loadBrandSettings()
    if (bodies.length === 0) {
      void analyzeModel()
    }
  }

  const toggleExplodedView = async () => {
    if (busy) return
    setBusy(true)
    try {
      if (exploded) {
        await resetExplodeTransforms()
      } else {
        const measured =
          bodies.length > 0 ? bodies : await analyzeModel(false)
        if (measured.length < 2) {
          throw new Error(
            '爆炸图需要至少两个独立实体；当前模型可能已经布尔合并为一个整体'
          )
        }
        const offsets = buildExplodeOffsets(measured)
        const transformResults = await Promise.allSettled(
          offsets.map(({ id, offset }) =>
            sendModelingCommand({
              type: 'set_object_transform',
              object_id: id,
              transforms: [
                {
                  translate: {
                    property: offset,
                    set: false,
                    origin: { type: 'global' },
                  },
                },
              ],
            })
          )
        )
        const successfulOffsets = offsets.filter(
          (_, index) => transformResults[index]?.status === 'fulfilled'
        )
        explodeOffsetsRef.current = successfulOffsets
        const failedCount = transformResults.length - successfulOffsets.length
        if (failedCount > 0) {
          await resetExplodeTransforms()
          throw new Error(
            `${failedCount} 个实体无法移动，已自动复原装配，请检查模型实体`
          )
        }
        explodeOffsetsRef.current = offsets
        setExploded(true)
      }

      await engineViewIsometric({
        engineCommandManager: kclManager.engineCommandManager,
        padding: 0.18,
      })
      await engineStreamZoomToFit({
        engineCommandManager: kclManager.engineCommandManager,
        padding: 0.18,
      })
      await new Promise((resolve) => setTimeout(resolve, 240))
      await captureSnapshot()
    } catch (error) {
      toast.error(error instanceof Error ? error.message : '爆炸图生成失败')
    } finally {
      setBusy(false)
    }
  }

  const bomRows = useMemo(
    () =>
      groupBodiesIntoBom(bodies).map((row) => ({
        ...row,
        ...overrides[row.key],
      })),
    [bodies, overrides]
  )
  const overall = useMemo(() => getOverallBounds(bodies), [bodies])
  const parametricDimensionCount = useMemo(
    () =>
      bodies.filter((body) => body.dimensionSource === 'kcl-parameters').length,
    [bodies]
  )
  const volumeCheckedDimensionCount = useMemo(
    () =>
      bodies.filter((body) => body.dimensionSource === 'engine-volume-check')
        .length,
    [bodies]
  )

  const updateRow = (
    row: BomRow,
    field: 'name' | 'material' | 'process',
    value: string
  ) => {
    setOverrides((current) => ({
      ...current,
      [row.key]: {
        ...current[row.key],
        [field]: value,
      },
    }))
  }

  const downloadBom = () => {
    if (bomRows.length === 0) {
      toast.error('请先分析模型')
      return
    }
    downloadText(
      `${resolvedProjectName}-BOM.csv`,
      createBomCsv(resolvedProjectName, bomRows),
      'text/csv;charset=utf-8'
    )
  }

  const printEngineeringSheet = () => {
    if (bomRows.length === 0) {
      toast.error('请先分析模型')
      return
    }
    const reportWindow = window.open('', '_blank')
    if (!reportWindow) {
      toast.error('浏览器阻止了工艺图窗口，请允许本站打开新窗口')
      return
    }
    reportWindow.opener = null
    reportWindow.document.open()
    reportWindow.document.write(
      createEngineeringSheetHtml({
        projectName: resolvedProjectName,
        generatedAt: new Date().toLocaleString('zh-CN'),
        overallDimensions: overall.dimensions,
        bodies,
        brandName: brand.name,
        brandLogoUrl: brand.logoUrl,
        bomRows,
        notes,
      })
    )
    reportWindow.document.close()
  }

  const handleClose = async () => {
    if (busy) return
    setBusy(true)
    try {
      if (explodeOffsetsRef.current.length > 0) {
        await resetExplodeTransforms()
        await engineStreamZoomToFit({
          engineCommandManager: kclManager.engineCommandManager,
          padding: 0.24,
        })
      }
      setOpen(false)
      onRequestClose?.()
    } finally {
      setBusy(false)
    }
  }

  return (
    <>
      {!hideTrigger && (
        <button
          type="button"
          data-testid="hicad-manufacturing-trigger"
          onClick={handleOpen}
          className="absolute right-4 top-14 z-20 h-9 border border-chalkboard-30 bg-chalkboard-10 px-3 text-sm font-medium shadow-sm hover:bg-chalkboard-20 dark:border-chalkboard-70 dark:bg-chalkboard-90 dark:hover:bg-chalkboard-80"
        >
          工程出图
        </button>
      )}

      {open && (
        <div
          className="fixed inset-0 z-[100] bg-black/50 p-4 md:p-8"
          role="dialog"
          aria-modal="true"
          aria-label="工程出图"
        >
          <div className="mx-auto flex h-full max-w-[1500px] flex-col overflow-hidden bg-chalkboard-10 dark:bg-chalkboard-100 border border-chalkboard-30 dark:border-chalkboard-70 shadow-2xl">
            <header className="flex shrink-0 items-center justify-between gap-4 border-b border-chalkboard-30 dark:border-chalkboard-70 px-5 py-4">
              <div>
                <h2 className="text-lg font-semibold">工程出图</h2>
                <p className="text-xs text-chalkboard-60 dark:text-chalkboard-40">
                  真实实体爆炸、尺寸、BOM 与可打印生产工艺图
                </p>
              </div>
              <div className="flex items-center gap-2">
                <button
                  type="button"
                  disabled={busy}
                  onClick={() => void analyzeModel()}
                  className="h-9 border border-chalkboard-30 dark:border-chalkboard-70 px-3 text-sm disabled:opacity-50"
                >
                  重新分析
                </button>
                <button
                  type="button"
                  aria-label="关闭"
                  disabled={busy}
                  onClick={() => void handleClose()}
                  className="grid size-9 place-items-center border border-chalkboard-30 dark:border-chalkboard-70 text-xl disabled:opacity-50"
                >
                  ×
                </button>
              </div>
            </header>

            <div className="flex shrink-0 flex-wrap items-center gap-2 border-b border-chalkboard-30 dark:border-chalkboard-70 px-5 py-3">
              <button
                type="button"
                disabled={busy}
                onClick={() => void toggleExplodedView()}
                className="h-9 bg-chalkboard-100 px-4 text-sm font-medium text-chalkboard-10 dark:bg-chalkboard-10 dark:text-chalkboard-100 disabled:opacity-50"
              >
                {busy ? '处理中…' : exploded ? '复原装配' : '一键爆炸'}
              </button>
              <button
                type="button"
                onClick={downloadBom}
                className="h-9 border border-chalkboard-30 dark:border-chalkboard-70 px-4 text-sm"
              >
                下载 BOM
              </button>
              <button
                type="button"
                onClick={printEngineeringSheet}
                className="h-9 border border-chalkboard-30 dark:border-chalkboard-70 px-4 text-sm"
              >
                打印 / PDF 工艺图
              </button>
              <span className="ml-auto text-xs text-chalkboard-60 dark:text-chalkboard-40">
                {bodies.length} 个独立实体 · {bomRows.length} 类零件 · 总尺寸{' '}
                {formatNumber(overall.dimensions.x)} ×{' '}
                {formatNumber(overall.dimensions.y)} ×{' '}
                {formatNumber(overall.dimensions.z)} mm
              </span>
            </div>

            <div className="grid min-h-0 flex-1 grid-cols-1 overflow-y-auto xl:grid-cols-[minmax(360px,0.8fr)_minmax(700px,1.4fr)]">
              <section className="border-b border-chalkboard-30 dark:border-chalkboard-70 p-5 xl:border-b-0 xl:border-r">
                <h3 className="mb-3 text-sm font-semibold">装配 / 爆炸预览</h3>
                <div className="grid min-h-[320px] place-items-center border border-chalkboard-30 dark:border-chalkboard-70 bg-white dark:bg-black">
                  {snapshot ? (
                    <img
                      src={snapshot}
                      alt={exploded ? '模型爆炸图' : '模型装配图'}
                      className="max-h-[520px] w-full object-contain"
                    />
                  ) : (
                    <span className="text-sm text-chalkboard-60">
                      {busy ? '正在读取工程数据…' : '暂无预览'}
                    </span>
                  )}
                </div>
                <h3 className="mb-2 mt-5 text-sm font-semibold">生产说明</h3>
                <textarea
                  value={notes}
                  onChange={(event) => setNotes(event.target.value)}
                  className="min-h-28 w-full resize-y border border-chalkboard-30 bg-transparent p-3 text-sm dark:border-chalkboard-70"
                />
              </section>

              <section className="min-w-0 p-5">
                <h3 className="mb-3 text-sm font-semibold">配件明细表</h3>
                <div className="overflow-x-auto border border-chalkboard-30 dark:border-chalkboard-70">
                  <table className="w-full min-w-[920px] border-collapse text-sm">
                    <thead className="bg-chalkboard-20 dark:bg-chalkboard-90">
                      <tr>
                        <th className="border-b p-2 text-left">序号</th>
                        <th className="border-b p-2 text-left">零件名称</th>
                        <th className="border-b p-2 text-left">数量</th>
                        <th className="border-b p-2 text-left">长 × 宽 × 高 (mm)</th>
                        <th className="border-b p-2 text-left">材料</th>
                        <th className="border-b p-2 text-left">生产工艺</th>
                        <th className="border-b p-2 text-left">体积 / 表面积</th>
                      </tr>
                    </thead>
                    <tbody>
                      {bomRows.map((row) => (
                        <tr
                          key={row.key}
                          className="border-b border-chalkboard-30 last:border-b-0 dark:border-chalkboard-70"
                        >
                          <td className="p-2">{row.itemNumber}</td>
                          <td className="p-2">
                            <input
                              value={row.name}
                              onChange={(event) =>
                                updateRow(row, 'name', event.target.value)
                              }
                              aria-label={`零件名称 ${row.itemNumber}`}
                              className="h-8 w-36 border border-chalkboard-30 bg-transparent px-2 font-medium dark:border-chalkboard-70"
                            />
                          </td>
                          <td className="p-2">{row.quantity}</td>
                          <td className="p-2 whitespace-nowrap">
                            {formatNumber(row.dimensions.x)} ×{' '}
                            {formatNumber(row.dimensions.y)} ×{' '}
                            {formatNumber(row.dimensions.z)}
                          </td>
                          <td className="p-2">
                            <input
                              value={row.material}
                              onChange={(event) =>
                                updateRow(row, 'material', event.target.value)
                              }
                              className="h-8 w-28 border border-chalkboard-30 bg-transparent px-2 dark:border-chalkboard-70"
                            />
                          </td>
                          <td className="p-2">
                            <input
                              value={row.process}
                              onChange={(event) =>
                                updateRow(row, 'process', event.target.value)
                              }
                              className="h-8 w-64 border border-chalkboard-30 bg-transparent px-2 dark:border-chalkboard-70"
                            />
                          </td>
                          <td className="p-2 text-xs whitespace-nowrap">
                            {formatNumber(row.volume)} mm³ /{' '}
                            {formatNumber(row.surfaceArea)} mm²
                          </td>
                        </tr>
                      ))}
                      {bomRows.length === 0 && (
                        <tr>
                          <td
                            colSpan={7}
                            className="p-10 text-center text-chalkboard-60"
                          >
                            {busy ? '正在分析模型…' : '暂无可识别零件'}
                          </td>
                        </tr>
                      )}
                    </tbody>
                  </table>
                </div>
                <p className="mt-3 text-xs text-chalkboard-60 dark:text-chalkboard-40">
                  {parametricDimensionCount > 0
                    ? `制造尺寸优先采用 KCL 已求值参数（${parametricDimensionCount} 个实体）`
                    : volumeCheckedDimensionCount > 0
                      ? `制造尺寸已通过实体体积交叉校验（${volumeCheckedDimensionCount} 个实体）`
                      : '当前制造尺寸来自模型实体包围盒'}
                  。材料、工艺、公差和连接方式必须由工程人员投产前复核。
                </p>
              </section>
            </div>
          </div>
        </div>
      )}
    </>
  )
}