王明 / Food-Labeling-Management-Platform

  import {
    createImageBitmapPatch,
    createTextBitmapPatch,
    shouldRasterizeTextElement,
  } from './nativeBitmapPatch'

  import { applyTemplateData } from './templateRenderer'
  import type {
    EscTemplateItem,
    LabelTemplateData,
    PrinterTemplateUnit,
    StructuredLabelTemplate,
    TscTemplateItem,
    StructuredTscTemplate,
    StructuredEscTemplate,
    SystemLabelTemplate,
    SystemTemplateElementBase,
    SystemTemplateTextAlign,
  } from './types/printer'
  
  const DESIGN_DPI = 96
  
  function roundNumber (value: number, digits = 1): number {
    const factor = Math.pow(10, digits)
    return Math.round(value * factor) / factor
  }
  
  function toMillimeter (value: number, unit: PrinterTemplateUnit = 'inch'): number {
    if (unit === 'mm') return value
    if (unit === 'cm') return value * 10
    if (unit === 'px') return value / DESIGN_DPI * 25.4
    return value * 25.4
  }
  
  function templateWidthPx (template: SystemLabelTemplate): number {
    return toMillimeter(template.width, template.unit || 'inch') / 25.4 * DESIGN_DPI
  }
  
  function pxToDots (value: number, dpi: number): number {
    return Math.max(0, Math.round((Number(value) || 0) * dpi / DESIGN_DPI))
  }
  
  function clamp (value: number, min: number, max: number): number {
    return Math.max(min, Math.min(max, Math.round(value)))
  }
  
  function sortElements (elements: SystemTemplateElementBase[]): SystemTemplateElementBase[] {
    return [...elements].sort((a, b) => {
      if (a.y !== b.y) return a.y - b.y
      return a.x - b.x
    })
  }
  
  function getConfigString (
    config: Record<string, any>,
    keys: string[],
    fallback = ''
  ): string {
    for (let i = 0; i < keys.length; i++) {
      const value = config?.[keys[i]]
      if (value != null && value !== '') return String(value)
    }
    return fallback
  }
  
  function getConfigNumber (
    config: Record<string, any>,
    keys: string[],
    fallback = 0
  ): number {
    for (let i = 0; i < keys.length; i++) {
      const value = Number(config?.[keys[i]])
      if (!Number.isNaN(value) && Number.isFinite(value)) return value
    }
    return fallback
  }
  
  function toCamelCaseKey (value: string): string {
    return value
      .toLowerCase()
      .split(/[_\s-]+/)
      .map((segment, index) => index === 0
        ? segment
        : segment.charAt(0).toUpperCase() + segment.slice(1))
      .join('')
  }
  
  function resolveBindingKey (element: SystemTemplateElementBase): string {
    const config = element.config || {}
    const explicit = getConfigString(config, ['dataKey', 'field', 'bindField', 'key', 'valueKey'])
    if (explicit) return explicit
  
    const type = String(element.type || '').toUpperCase()
    const map: Record<string, string> = {
      TEXT_PRODUCT: 'productName',
      TEXT_LABEL_ID: 'labelId',
      TEXT_CATEGORY: 'category',
      TEXT_PRICE: 'price',
      TEXT_DATE: 'date',
      TEXT_TIME: 'time',
      QRCODE: 'qrCode',
      BARCODE: 'barcode',
    }
    if (map[type]) return map[type]
  
    const pureType = type
      .replace(/^TEXT_/, '')
      .replace(/^FIELD_/, '')
      .replace(/^VALUE_/, '')
    return pureType ? toCamelCaseKey(pureType) : ''
  }
  
  function resolveTemplateFieldValue (data: LabelTemplateData, key: string): string {
    if (!key) return ''
    const candidates = [key]
    if (key === 'productName') candidates.push('product')
    if (key === 'product') candidates.push('productName')
    if (key === 'qrCode') candidates.push('labelId', 'barcode')
    if (key === 'barcode') candidates.push('labelId', 'qrCode')
  
    for (let i = 0; i < candidates.length; i++) {
      const value = data[candidates[i]]
      if (value != null) return String(value)
    }
    return ''
  }
  

  function formatPriceValue (
    rawValue: string,
    config: Record<string, any>
  ): string {
    const prefix = getConfigString(config, ['prefix'], '')
    const suffix = getConfigString(config, ['suffix'], '')
    const decimal = getConfigNumber(config, ['decimal'], -1)
    const numericValue = Number(rawValue)
    const value = !Number.isNaN(numericValue) && Number.isFinite(numericValue) && decimal >= 0
      ? numericValue.toFixed(decimal)
      : rawValue
    return `${prefix}${value}${suffix}`
  }
  

  /** WEIGHT / DATE / TIME / DURATION：画布已把展示写入 config.text；此处兜底 value+unit、format */
  function resolvePlainTextLikeElement (
    element: SystemTemplateElementBase,
    data: LabelTemplateData
  ): string {
    const config = element.config || {}
    const t = getConfigString(config, ['text', 'Text'])
    if (t) return applyTemplateData(t, data)
    const type = String(element.type || '').toUpperCase()
    if (type === 'WEIGHT') {
      const v = getConfigString(config, ['value', 'Value'])
      const u = getConfigString(config, ['unit', 'Unit'])
      if (!v && !u) return ''
      if (v && u && !v.endsWith(u)) return `${v}${u}`
      return v || u
    }
    if (type === 'DATE' || type === 'TIME' || type === 'DURATION') {
      return getConfigString(config, ['format', 'Format'])
    }
    return ''
  }
  

  function resolveElementText (
    element: SystemTemplateElementBase,
    data: LabelTemplateData
  ): string {
    const config = element.config || {}

    const type = String(element.type || '').toUpperCase()

    const hasText = config.text != null && config.text !== ''

    if (type === 'TEXT_PRICE') {
      const bindingKey = resolveBindingKey(element)
      const boundValue = resolveTemplateFieldValue(data, bindingKey)
      const baseValue = boundValue || (hasText ? applyTemplateData(String(config.text), data) : '')
      return baseValue ? formatPriceValue(baseValue, config) : ''
    }
    if (hasText && type === 'TEXT_STATIC') {

      return applyTemplateData(String(config.text), data)
    }
    if (hasText && String(config.text).includes('{{')) {
      return applyTemplateData(String(config.text), data)
    }
    const bindingKey = resolveBindingKey(element)
    const boundValue = resolveTemplateFieldValue(data, bindingKey)
    if (boundValue) return boundValue
    if (hasText) return applyTemplateData(String(config.text), data)
    return ''
  }
  
  function resolveElementDataValue (
    element: SystemTemplateElementBase,
    data: LabelTemplateData
  ): string {
    const config = element.config || {}
    const raw = getConfigString(config, ['data', 'value'])
    if (raw) return applyTemplateData(raw, data)
    return resolveTemplateFieldValue(data, resolveBindingKey(element))
  }
  
  function resolveElementAlign (
    element: SystemTemplateElementBase,
    pageWidthPx: number
  ): SystemTemplateTextAlign {
    const config = element.config || {}
    const align = String(config.textAlign || '').toLowerCase()
    if (align === 'left' || align === 'center' || align === 'right') return align as SystemTemplateTextAlign
    const centerX = (Number(element.x) || 0) + (Number(element.width) || 0) / 2
    if (centerX <= pageWidthPx * 0.33) return 'left'
    if (centerX >= pageWidthPx * 0.67) return 'right'
    return 'center'
  }
  
  function toEscAlign (align: SystemTemplateTextAlign): 0 | 1 | 2 {
    if (align === 'center') return 1
    if (align === 'right') return 2
    return 0
  }
  
  function resolveRotation (value?: string): number {
    return value === 'vertical' ? 90 : 0
  }
  
  function normalizeQrLevel (value?: string): 'L' | 'M' | 'Q' | 'H' {
    const key = String(value || 'M').trim().toUpperCase()
    if (key === 'L' || key === 'M' || key === 'Q' || key === 'H') return key
    return 'M'
  }
  
  function estimateTextWidthDots (text: string, fontDots: number): number {
    let total = 0
    for (let i = 0; i < text.length; i++) {
      const code = text.charCodeAt(i)
      total += code > 255 ? fontDots : fontDots * 0.6
    }
    return Math.round(total)
  }
  
  function resolveTextScale (fontSizePx: number, dpi: number): number {
    const targetDots = Math.max(12, Math.round(fontSizePx * dpi / DESIGN_DPI))
    return clamp(targetDots / 24, 1, 7)
  }
  

  function estimateQrModuleCount (value: string, level: 'L' | 'M' | 'Q' | 'H'): number {
    const capacities: Record<'L' | 'M' | 'Q' | 'H', number[]> = {
      L: [17, 32, 53, 78, 106, 134, 154, 192, 230, 271],
      M: [14, 26, 42, 62, 84, 106, 122, 152, 180, 213],
      Q: [11, 20, 32, 46, 60, 74, 86, 108, 130, 151],
      H: [7, 14, 24, 34, 44, 58, 64, 84, 98, 119],
    }
    const length = Math.max(1, String(value || '').length)
    const versions = capacities[level] || capacities.M
    let version = versions.length
    for (let i = 0; i < versions.length; i++) {
      if (length <= versions[i]) {
        version = i + 1
        break
      }
    }
    return 21 + (version - 1) * 4
  }
  
  function resolveQrModuleSize (
    widthPx: number,
    heightPx: number,
    dpi: number,
    value: string,
    level: 'L' | 'M' | 'Q' | 'H'
  ): number {
    const targetDots = Math.max(24, Math.min(
      pxToDots(widthPx, dpi),
      pxToDots(heightPx, dpi)
    ))
    const moduleCount = Math.max(21, estimateQrModuleCount(value, level))
    return clamp(Math.floor(targetDots / moduleCount), 3, 12)
  }
  

  function resolveTextX (params: {
    align: SystemTemplateTextAlign
    xPx: number
    widthPx: number
    dpi: number
    text: string
    scale: number
  }): number {
    const left = pxToDots(params.xPx, params.dpi)
    if (params.align === 'left') return left
  
    const boxWidth = pxToDots(params.widthPx, params.dpi)
    const fontDots = Math.max(24, params.scale * 24)
    const textWidth = estimateTextWidthDots(params.text, fontDots)
    if (params.align === 'center') {
      return Math.max(0, left + Math.round(Math.max(0, boxWidth - textWidth) / 2))
    }
    return Math.max(0, left + Math.max(0, boxWidth - textWidth))
  }
  
  function buildTscTemplate (
    template: SystemLabelTemplate,
    data: LabelTemplateData,
    dpi: number,

    printQty: number,
    options: {
      disableBitmapText?: boolean
    } = {}

  ): StructuredTscTemplate {
    const widthMm = roundNumber(toMillimeter(template.width, template.unit || 'inch'))
    const heightMm = roundNumber(toMillimeter(template.height, template.unit || 'inch'))
    const items: TscTemplateItem[] = []
  

    const pageWidth = templateWidthPx(template)
  

    sortElements(template.elements).forEach((element) => {
      const config = element.config || {}
      const type = String(element.type || '').toUpperCase()
  

      const renderAsTextBlock =
        type.startsWith('TEXT_') ||
        type === 'WEIGHT' ||
        type === 'DATE' ||
        type === 'TIME' ||
        type === 'DURATION'
  
      if (renderAsTextBlock) {
        const text = type.startsWith('TEXT_')
          ? resolveElementText(element, data)
          : resolvePlainTextLikeElement(element, data)

        if (!text) return
        const scale = resolveTextScale(getConfigNumber(config, ['fontSize'], 14), dpi)

        const align = resolveElementAlign(element, pageWidth)
  

        if (!options.disableBitmapText && shouldRasterizeTextElement(text, type)) {

          const bitmapPatch = createTextBitmapPatch({
            element,
            text,
            dpi,
            align,
          })
          if (bitmapPatch) {
            items.push(bitmapPatch)
            return
          }
        }
  

        items.push({
          type: 'text',
          x: resolveTextX({
            align,
            xPx: element.x,
            widthPx: element.width,
            dpi,
            text,
            scale,
          }),
          y: pxToDots(element.y, dpi),
          text,
          font: 'TSS24.BF2',
          rotation: resolveRotation(element.rotation),
          xScale: scale,
          yScale: scale,
        })
        return
      }
  
      if (type === 'QRCODE') {
        const value = resolveElementDataValue(element, data)
        if (!value) return

        const level = normalizeQrLevel(getConfigString(config, ['errorLevel'], 'M'))

        items.push({
          type: 'qrcode',
          x: pxToDots(element.x, dpi),
          y: pxToDots(element.y, dpi),
          value,

          level,
          cellWidth: resolveQrModuleSize(element.width, element.height, dpi, value, level),

          mode: 'A',
        })
        return
      }
  
      if (type === 'BARCODE') {
        const value = resolveElementDataValue(element, data)
        if (!value) return
        items.push({
          type: 'barcode',
          x: pxToDots(element.x, dpi),
          y: pxToDots(element.y, dpi),
          value,
          symbology: getConfigString(config, ['barcodeType'], 'CODE128'),
          height: Math.max(20, pxToDots(element.height, dpi)),
          readable: config.showText !== false,
          rotation: resolveRotation(getConfigString(config, ['orientation'], element.rotation || 'horizontal')),
          narrow: clamp(element.width / Math.max(40, value.length * 6), 1, 4),
          wide: clamp(element.width / Math.max(24, value.length * 3), 2, 6),
        })

        return
      }
  
      if (type === 'IMAGE') {
        const bitmapPatch = createImageBitmapPatch({
          element,
          dpi,
        })
        if (bitmapPatch) items.push(bitmapPatch)
        return
      }
  
      if (type === 'BLANK' && String(element.border || '').toLowerCase() === 'line') {
        items.push({
          type: 'bar',
          x: pxToDots(element.x, dpi),
          y: pxToDots(element.y, dpi),
          width: Math.max(1, pxToDots(element.width, dpi)),
          height: Math.max(1, pxToDots(element.height || 1, dpi)),
        })

      }
    })
  
    return {
      widthMm,
      heightMm,
      gapMm: 0,
      density: 14,
      speed: 5,
      printQty,
      items,
    }
  }
  
  function buildEscTemplate (
    template: SystemLabelTemplate,
    data: LabelTemplateData,
    printQty: number
  ): StructuredEscTemplate {
    const pageWidth = templateWidthPx(template)
    const items: EscTemplateItem[] = []
  
    sortElements(template.elements).forEach((element) => {
      const config = element.config || {}
      const type = String(element.type || '').toUpperCase()
      const align = toEscAlign(resolveElementAlign(element, pageWidth))
  

      const renderAsTextBlockEsc =
        type.startsWith('TEXT_') ||
        type === 'WEIGHT' ||
        type === 'DATE' ||
        type === 'TIME' ||
        type === 'DURATION'
  
      if (renderAsTextBlockEsc) {
        const text = type.startsWith('TEXT_')
          ? resolveElementText(element, data)
          : resolvePlainTextLikeElement(element, data)

        if (!text) return
        const fontSize = getConfigNumber(config, ['fontSize'], 14)
        const scale = fontSize >= 28 ? 2 : 1
        items.push({
          type: 'text',
          text,
          align,
          bold: String(config.fontWeight || '').toLowerCase() === 'bold',
          widthScale: scale,
          heightScale: scale,
        })
        return
      }
  
      if (type === 'QRCODE') {
        const value = resolveElementDataValue(element, data)
        if (!value) return

        const level = normalizeQrLevel(getConfigString(config, ['errorLevel'], 'M'))

        items.push({
          type: 'qrcode',
          value,
          align,

          size: resolveQrModuleSize(element.width, element.height, 203, value, level),
          level,

        })
        return
      }
  
      if (type === 'BARCODE') {
        const value = resolveElementDataValue(element, data)
        if (!value) return
        items.push({
          type: 'barcode',
          value,
          align,
          symbology: getConfigString(config, ['barcodeType'], 'CODE128'),
          height: clamp(element.height * 2, 48, 180),
          width: clamp(element.width / Math.max(48, value.length * 4), 2, 6),
          showText: config.showText !== false,
        })

        return
      }
  
      if (type === 'BLANK' && String(element.border || '').toLowerCase() === 'line') {
        items.push({
          type: 'rule',
          width: clamp(element.width / 8, 8, 48),
        })

      }
    })
  
    return {
      printQty,
      feedLines: 3,
      items,
    }
  }
  
  export function adaptSystemLabelTemplate (
    template: SystemLabelTemplate,
    data: LabelTemplateData = {},
    options: {
      dpi?: number
      printQty?: number

      disableBitmapText?: boolean

    } = {}
  ): StructuredLabelTemplate {
    const dpi = options.dpi || 203
    const printQty = Math.max(1, Math.round(options.printQty || 1))
    return {
      key: template.id || template.name || 'system-label-template',

      tsc: buildTscTemplate(template, data, dpi, printQty, {
        disableBitmapText: options.disableBitmapText,
      }),

      esc: buildEscTemplate(template, data, printQty),
    }
  }