import { buildDmsPrintBarcode } from './dmsPrintBarcode';
import type { DmsPrintAttempt, DmsPrintBatch as DmsAttemptBatch } from './dmsPrintAttempt';
import { attemptBatches, recoverDmsBatchReceipts, recordDmsBatchSubmitted, updateDmsPrintAttempt } from './dmsPrintAttempt';
import type { DmsPrintRenderItem } from '#/api/x/dms/print';
import type { DmsPageVariables, DmsPreviewPrintOptions, DmsPrintConfig, DmsPrintCopyBarcodes } from '#/components/GlobalOfficeDocumentModal/types';
import type { HiprintPrintConfig, HiprintPrintResult } from '#/utils/jnpf';

import { getDocument, GlobalWorkerOptions } from 'pdfjs-dist';
import pdfWorkerUrl from 'pdfjs-dist/build/pdf.worker.min.mjs?url';
import { v4 as uuidv4 } from 'uuid';

import { createDmsFilePrintTicket, getDmsFilePageCount, renderDmsPrintPdf } from '#/api/x/dms/print';
import { watermarkParameters } from '#/api/x/dms/watermarkParameters';
import { onlineUtils } from '#/utils/jnpf';

GlobalWorkerOptions.workerSrc = pdfWorkerUrl;

const MAX_PAGE_VARIABLES = 1_000;
const MAX_SELECTED_PAGES = 1_000;
const MAX_VARIABLES_PER_PAGE = 50;
const MAX_VARIABLE_NAME_LENGTH = 100;
const MAX_STRING_LENGTH = 2_000;
const MAX_PRINT_OPTIONS_BYTES = 1024 * 1024;
const MAX_COPY_BARCODE_COPIES = 999;
const MAX_BATCH_COPIES = 20;
const MAX_BATCH_PAGES = 100;
const PRINT_CONFIRM_TIMEOUT_MILLIS = 60_000;

export class DmsPrintError extends Error {
  constructor(
    public readonly code: 'INVALID_PAGES' | 'INVALID_VARIABLES' | 'PRINT_FAILED',
    message: string,
  ) {
    super(message);
    this.name = 'DmsPrintError';
  }
}

export interface DmsPrintPageContext {
  canvas: HTMLCanvasElement;
  pageNo: number;
  variables: Readonly<Record<string, unknown>>;
}

export type DmsPrintPageVariableHandler = (context: DmsPrintPageContext) => Promise<void> | void;

const pageVariableHandlers = new Set<DmsPrintPageVariableHandler>();

/** 登记业务页面变量处理器；返回值用于在业务模块卸载时取消登记。 */
export function registerDmsPrintPageVariableHandler(handler: DmsPrintPageVariableHandler) {
  pageVariableHandlers.add(handler);
  return () => pageVariableHandlers.delete(handler);
}

function invalidPages(message = '打印页码无效') {
  return new DmsPrintError('INVALID_PAGES', message);
}

function invalidVariables(message = '页面打印参数无效') {
  return new DmsPrintError('INVALID_VARIABLES', message);
}

export function parseDmsPrintPages(value?: string, pageCount?: number): number[] | undefined {
  const text = value?.trim();
  if (!text) return undefined;

  const pages = new Set<number>();
  for (const part of text.split(',')) {
    const token = part.trim();
    if (!token) throw invalidPages();
    const match = /^(\d+)(?:\s*-\s*(\d+))?$/.exec(token);
    if (!match) throw invalidPages();
    const start = Number(match[1]);
    const end = Number(match[2] ?? match[1]);
    if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 1 || end < start) throw invalidPages();
    const actualEnd = pageCount === undefined ? end : Math.min(end, pageCount);
    for (let pageNo = start; pageNo <= actualEnd; pageNo++) {
      if (pages.has(pageNo)) continue;
      if (pages.size >= MAX_SELECTED_PAGES) throw invalidPages('打印页数超过系统限制');
      pages.add(pageNo);
    }
  }
  return [...pages].sort((left, right) => left - right);
}

function validateVariableValue(value: unknown) {
  if (value === null || typeof value === 'boolean' || typeof value === 'number') return;
  if (typeof value === 'string') {
    if (value.length > MAX_STRING_LENGTH) throw invalidVariables('页面变量字符串超过长度限制');
    return;
  }
  if (Array.isArray(value)) {
    for (const item of value) {
      if (Array.isArray(item) || (typeof item === 'object' && item !== null) || item === undefined) throw invalidVariables();
      validateVariableValue(item);
    }
    return;
  }
  throw invalidVariables();
}

export function normalizeDmsPrintOptions(
  options?: DmsPreviewPrintOptions,
): Pick<DmsPreviewPrintOptions, 'copyBarcodes' | 'pages'> & Required<Pick<DmsPreviewPrintOptions, 'copies' | 'pageVariables'>> {
  const copyBarcodes = normalizeCopyBarcodes(options?.copyBarcodes);
  const copies = options?.copies ?? copyBarcodes?.length ?? 1;
  if (!Number.isInteger(copies) || copies < 1 || copies > 999) throw invalidVariables('打印份数必须为 1～999 的整数');
  if (copyBarcodes && copies !== copyBarcodes.length) throw invalidVariables('打印份数必须与逐份条码配置数量一致');

  const pages = options?.pages?.trim() || undefined;
  const selectedPages = parseDmsPrintPages(pages);
  const selectedPageSet = selectedPages ? new Set(selectedPages) : undefined;
  const pageVariables = options?.pageVariables ?? [];
  if (!Array.isArray(pageVariables) || pageVariables.length > MAX_PAGE_VARIABLES) throw invalidVariables();

  const pageNumbers = new Set<number>();
  for (const item of pageVariables) {
    if (!item || !Number.isInteger(item.pageNo) || item.pageNo < 1 || pageNumbers.has(item.pageNo)) throw invalidVariables();
    if (selectedPageSet && !selectedPageSet.has(item.pageNo)) throw invalidVariables('页面变量引用了未选择的打印页');
    if (!item.variables || Array.isArray(item.variables) || typeof item.variables !== 'object') throw invalidVariables();
    const entries = Object.entries(item.variables);
    if (entries.length > MAX_VARIABLES_PER_PAGE) throw invalidVariables('单页变量数量超过系统限制');
    for (const [name, value] of entries) {
      if (!name || name.length > MAX_VARIABLE_NAME_LENGTH) throw invalidVariables('页面变量名称无效');
      validateVariableValue(value);
    }
    pageNumbers.add(item.pageNo);
  }

  if (new TextEncoder().encode(JSON.stringify({ copies, copyBarcodes, pages, pageVariables })).byteLength > MAX_PRINT_OPTIONS_BYTES) {
    throw invalidVariables('页面打印参数超过系统大小限制');
  }
  return { copies, copyBarcodes, pageVariables, pages };
}

function normalizeCopyBarcodes(value?: DmsPrintCopyBarcodes[]) {
  if (value === undefined) return undefined;
  if (!Array.isArray(value) || value.length < 1 || value.length > MAX_COPY_BARCODE_COPIES) {
    throw invalidVariables(`逐份条码配置数量必须为 1～${MAX_COPY_BARCODE_COPIES}`);
  }
  const normalized = value
    .map((item) => {
      if (!item || !Number.isInteger(item.copyNo) || item.copyNo < 1 || !Array.isArray(item.customBarcode) || item.customBarcode.length < 1) {
        throw invalidVariables('逐份条码配置无效');
      }
      return {
        copyNo: item.copyNo,
        customBarcode: item.customBarcode.map((barcode) => {
          if (
            !barcode ||
            (barcode.page !== undefined && barcode.page !== null && (!Number.isInteger(barcode.page) || barcode.page < 1)) ||
            typeof barcode.barValue !== 'string' ||
            !barcode.barValue.trim() ||
            typeof barcode.barText !== 'string' ||
            !barcode.barText.trim()
          ) {
            throw invalidVariables('逐份条码内容无效');
          }
          return { ...barcode };
        }),
      };
    })
    .sort((left, right) => left.copyNo - right.copyNo);
  normalized.forEach((item, index) => {
    if (item.copyNo !== index + 1) throw invalidVariables('打印份序必须从 1 开始连续且不可重复');
  });
  return normalized;
}

function pageVariablesMap(values: DmsPageVariables[]) {
  return new Map(values.map((item) => [item.pageNo, Object.freeze({ ...item.variables })]));
}

function printableHtml(pages: Array<{ dataUrl: string; height: number; width: number }>) {
  const body = pages
    .map((page) => `<section class="jnpf-dms-print-page" style="width:${page.width}pt;height:${page.height}pt"><img alt="" src="${page.dataUrl}" /></section>`)
    .join('');
  return `<style>
    .jnpf-dms-print-pages { margin: 0; padding: 0; }
    .jnpf-dms-print-page { box-sizing: border-box; margin: 0; overflow: hidden; break-after: page; page-break-after: always; }
    .jnpf-dms-print-page:last-child { break-after: auto; page-break-after: auto; }
    .jnpf-dms-print-page img { display: block; width: 100%; height: 100%; object-fit: fill; }
  </style><div class="jnpf-dms-print-pages">${body}</div>`;
}

export async function buildDmsPrintableHtml(pdf: ArrayBuffer | Blob, options: DmsPreviewPrintOptions, documentCopies = 1, sourcePageNumbers?: number[]) {
  const bytes = pdf instanceof Blob ? await pdf.arrayBuffer() : pdf;
  const task = getDocument({ data: new Uint8Array(bytes) });
  const pdfDocument = await task.promise;
  try {
    if (!Number.isInteger(documentCopies) || documentCopies < 1 || pdfDocument.numPages % documentCopies !== 0) {
      throw new DmsPrintError('PRINT_FAILED', '批量打印 PDF 页数与打印份数不匹配');
    }
    const sourcePageCount = pdfDocument.numPages / documentCopies;
    const serverFiltered = sourcePageNumbers !== undefined;
    const selectedPages =
      sourcePageNumbers ?? parseDmsPrintPages(options.pages, sourcePageCount) ?? Array.from({ length: sourcePageCount }, (_, index) => index + 1);
    if ((serverFiltered && selectedPages.length !== sourcePageCount) || selectedPages.some((pageNo) => !Number.isInteger(pageNo) || pageNo < 1)) {
      throw invalidPages('服务端打印页数与指定页码不一致');
    }
    const selectedPageSet = new Set(selectedPages);
    const variables = pageVariablesMap((options.pageVariables ?? []).filter((item) => selectedPageSet.has(item.pageNo)));

    const renderedPages: Array<{ dataUrl: string; height: number; width: number }> = [];
    for (let copyIndex = 0; copyIndex < documentCopies; copyIndex++) {
      for (const [pageIndex, selectedPage] of selectedPages.entries()) {
        const pageNo = selectedPage!;
        const page = await pdfDocument.getPage(copyIndex * sourcePageCount + (serverFiltered ? pageIndex + 1 : pageNo));
        const outputScale = Math.max(1, Math.min(2, window.devicePixelRatio || 1));
        const viewport = page.getViewport({ scale: outputScale });
        const canvas = document.createElement('canvas');
        canvas.width = Math.ceil(viewport.width);
        canvas.height = Math.ceil(viewport.height);
        const context = canvas.getContext('2d', { alpha: false });
        if (!context) throw new DmsPrintError('PRINT_FAILED', '无法生成打印页面');
        await page.render({ canvasContext: context, viewport }).promise;
        const pageContext: DmsPrintPageContext = { canvas, pageNo, variables: variables.get(pageNo) ?? Object.freeze({}) };
        for (const handler of pageVariableHandlers) await handler(pageContext);
        renderedPages.push({
          dataUrl: canvas.toDataURL('image/png'),
          height: viewport.height / outputScale,
          width: viewport.width / outputScale,
        });
        page.cleanup();
      }
    }
    return printableHtml(renderedPages);
  } finally {
    await pdfDocument.destroy();
  }
}

interface DmsPrintBatch {
  items: DmsPrintRenderItem[];
  pageNumbers: number[];
}

function formatPageNumbers(pages: number[]) {
  const ranges: string[] = [];
  for (let index = 0; index < pages.length; index++) {
    const start = pages[index]!;
    let end = start;
    while (index + 1 < pages.length && pages[index + 1] === end + 1) end = pages[++index]!;
    ranges.push(start === end ? String(start) : `${start}-${end}`);
  }
  return ranges.join(',');
}

function withBatchPages(items: DmsPrintRenderItem[], pageNumbers: number[]) {
  const printPages = formatPageNumbers(pageNumbers);
  return items.map((item) => ({ ...item, printPages }));
}

function createPrintBatches(items: DmsPrintRenderItem[], pageNumbers: number[], copySpecific: boolean): DmsPrintBatch[] {
  const pageChunks: number[][] = [];
  for (let index = 0; index < pageNumbers.length; index += MAX_BATCH_PAGES) {
    pageChunks.push(pageNumbers.slice(index, index + MAX_BATCH_PAGES));
  }
  if (!copySpecific) {
    return pageChunks.map((pages) => ({ items: withBatchPages(items, pages), pageNumbers: pages }));
  }
  if (pageChunks.length > 1) {
    return items.flatMap((item) => pageChunks.map((pages) => ({ items: withBatchPages([item], pages), pageNumbers: pages })));
  }
  const pages = pageChunks[0]!;
  const batchCopies = Math.max(1, Math.min(MAX_BATCH_COPIES, Math.floor(MAX_BATCH_PAGES / pages.length)));
  const batches: DmsPrintBatch[] = [];
  for (let index = 0; index < items.length; index += batchCopies) {
    batches.push({ items: withBatchPages(items.slice(index, index + batchCopies), pages), pageNumbers: pages });
  }
  return batches;
}

function splitPrintBatch(batch: DmsPrintBatch): DmsPrintBatch[] | undefined {
  if (batch.items.length > 1) {
    const middle = Math.ceil(batch.items.length / 2);
    return [
      { items: batch.items.slice(0, middle), pageNumbers: batch.pageNumbers },
      { items: batch.items.slice(middle), pageNumbers: batch.pageNumbers },
    ];
  }
  if (batch.pageNumbers.length > 1) {
    const middle = Math.ceil(batch.pageNumbers.length / 2);
    const left = batch.pageNumbers.slice(0, middle);
    const right = batch.pageNumbers.slice(middle);
    return [
      { items: withBatchPages(batch.items, left), pageNumbers: left },
      { items: withBatchPages(batch.items, right), pageNumbers: right },
    ];
  }
}

async function isBatchPdfSizeError(error: any) {
  const responseData = error?.response?.data;
  let responseText = '';
  if (responseData instanceof Blob) responseText = await responseData.text();
  else if (typeof responseData === 'string') responseText = responseData;
  else if (responseData) responseText = JSON.stringify(responseData);
  return `${error?.message ?? ''} ${responseText}`.includes('打印 PDF 超过系统大小限制');
}

async function dispatchDmsPrintBatch(config: HiprintPrintConfig, onSubmitted?: () => Promise<unknown>) {
  let receiptSeen = false;
  let settled = false;
  let resolveConfirmation!: (result: HiprintPrintResult) => void;
  let rejectConfirmation!: (error: unknown) => void;
  const confirmation = new Promise<HiprintPrintResult>((resolve, reject) => {
    resolveConfirmation = resolve;
    rejectConfirmation = reject;
  });
  const timeoutId = window.setTimeout(() => {
    if (settled) return;
    settled = true;
    rejectConfirmation(new DmsPrintError('PRINT_FAILED', '打印客户端确认任务超时，发送结果未知，请核对客户端任务和实际输出，勿直接重复打印'));
  }, PRINT_CONFIRM_TIMEOUT_MILLIS);
  const resolveOnce = (result: HiprintPrintResult) => {
    if (receiptSeen) return;
    receiptSeen = true;
    window.clearTimeout(timeoutId);
    // 计时器只结束前端等待，不抛弃成功回执；持久化失败交由 outbox 恢复。
    void (async () => {
      try {
        await onSubmitted?.();
        if (!settled) {
          settled = true;
          resolveConfirmation(result);
        }
      } catch (error) {
        if (!settled) {
          settled = true;
          rejectConfirmation(error);
        }
      }
    })();
  };
  const rejectOnce = (error: unknown) => {
    if (settled) return;
    settled = true;
    window.clearTimeout(timeoutId);
    rejectConfirmation(error || new DmsPrintError('PRINT_FAILED', '打印客户端发送任务失败'));
  };

  try {
    const dispatched = await onlineUtils.hiprint({
      ...config,
      errorMessageMode: 'none',
      onError: rejectOnce,
      onPrint: resolveOnce,
    });
    if (!dispatched) rejectOnce(new DmsPrintError('PRINT_FAILED', '打印任务派发失败'));
  } catch (error) {
    rejectOnce(error);
  }
  return confirmation;
}

export async function printDmsDocument(fileName: string, printConfig: DmsPrintConfig, shouldContinue: () => boolean = () => true) {
  const normalized = normalizeDmsPrintOptions(printConfig);
  if (!shouldContinue()) return;
  const pageCountResponse = await getDmsFilePageCount(printConfig.fileVersionId);
  if (!shouldContinue()) return;
  const pageCount = pageCountResponse.data?.pageCount;
  if (!Number.isInteger(pageCount) || pageCount < 1) throw new DmsPrintError('PRINT_FAILED', '后端返回的文件页数无效');
  const selectedPages = parseDmsPrintPages(normalized.pages, pageCount) ?? Array.from({ length: pageCount }, (_, index) => index + 1);
  if (selectedPages.length === 0) return;
  const authorizedPages = formatPageNumbers(selectedPages);
  const copyParameters = normalized.copyBarcodes?.map((item) => ({
    ...watermarkParameters(printConfig),
    customBarcode: item.customBarcode,
  })) ?? [watermarkParameters(printConfig)];
  const renderItems: DmsPrintRenderItem[] = [];
  for (const parameters of copyParameters) {
    const ticketResponse = await createDmsFilePrintTicket({
      ...parameters,
      copies: normalized.copyBarcodes ? 1 : normalized.copies,
      operationId: uuidv4(),
      printPages: authorizedPages,
      resourceId: printConfig.fileVersionId,
      resourceType: 'FILE_VERSION',
    });
    if (!shouldContinue()) return;
    const ticket = ticketResponse.data;
    if (!ticket?.accessTicket || !ticket.fileVersionId || !ticket.fileName) throw new DmsPrintError('PRINT_FAILED', '后端返回的 DMS 打印票据不完整');
    if (ticket.fileVersionId !== printConfig.fileVersionId) throw new DmsPrintError('PRINT_FAILED', '打印文件版本与预览版本不一致');
    renderItems.push({ accessTicket: ticket.accessTicket, fileName: ticket.fileName, fileVersionId: ticket.fileVersionId });
  }

  const source = renderItems[0]!;
  const batches = createPrintBatches(renderItems, selectedPages, Boolean(normalized.copyBarcodes));
  let lastResult;
  for (let batchIndex = 0; batchIndex < batches.length; ) {
    const batch = batches[batchIndex]!;
    let pdf: Blob;
    try {
      pdf = await renderDmsPrintPdf({ items: batch.items, source });
    } catch (error) {
      const split = (await isBatchPdfSizeError(error)) && splitPrintBatch(batch);
      if (!split) throw error;
      batches.splice(batchIndex, 1, ...split);
      continue;
    }
    if (!shouldContinue()) return;
    const html = await buildDmsPrintableHtml(pdf, { ...normalized, pages: undefined }, normalized.copyBarcodes ? batch.items.length : 1, batch.pageNumbers);
    if (!shouldContinue()) return;
    lastResult = await dispatchDmsPrintBatch({
      clientOptions: {
        copies: normalized.copyBarcodes ? 1 : normalized.copies,
        title: batches.length > 1 ? `${fileName} (第 ${batchIndex + 1} 批)` : fileName,
      },
      html,
    });
    batchIndex++;
    // 已收到最后一批成功回执后必须完成业务确认，不能因预览关闭而丢弃记账。
    if (batchIndex < batches.length && !shouldContinue()) return;
  }
  await printConfig.onPrintSuccess?.();
  return lastResult;
}

export interface DmsManagedPrintTransport {
  recover: typeof recoverDmsBatchReceipts;
  update: typeof updateDmsPrintAttempt;
  submitted: typeof recordDmsBatchSubmitted;
  allowHistoricalSerial?: boolean;
}

/** 台账专用发送：所有恢复均读取服务端计划，SENDING 永不自动重发。 */
export async function printManagedDmsDocument(fileName: string, config: DmsPrintConfig, original: DmsPrintAttempt, transport: DmsManagedPrintTransport = {
  recover: recoverDmsBatchReceipts, update: updateDmsPrintAttempt, submitted: recordDmsBatchSubmitted,
}) {
  if (config.copyBarcodes || config.pages) throw new Error('台账打印必须发送完整文档，不能覆盖页段或逐份配置');
  const normalized = normalizeDmsPrintOptions({ ...config, copies: original.copies });
  let attempt = await transport.recover(original);
  if (attempt.state !== 'OPEN') return;
  const numbers: Array<{ serialNumber: string; countSerialNumber: string }> = JSON.parse(attempt.numbersJson || '[]');
  if (numbers.length !== attempt.copies || numbers.some((n) => !n.serialNumber || (!transport.allowHistoricalSerial && !/^\d{8}$/.test(n.countSerialNumber)))) {
    throw new Error('打印号码未完整冻结，请核对原发送任务，不能重新发送');
  }
  let batches = attemptBatches(attempt);
  if (batches.some((batch) => batch.state === 'SENDING')) throw new Error('打印发送结果未知，请核对原客户端任务并等待回传；系统已阻止重复发送');
  if (!batches.length) {
    const response = await getDmsFilePageCount(config.fileVersionId);
    const pageCount = response.data?.pageCount;
    if (!Number.isInteger(pageCount) || pageCount < 1 || pageCount > MAX_SELECTED_PAGES) throw new Error('后端返回的文件页数无效');
    const plan: DmsAttemptBatch[] = [];
    for (let copy = 0; copy < attempt.copies; copy++) {
      for (let page = 1; page <= pageCount; page += 100) {
        plan.push({ id: uuidv4(), pages: Array.from({ length: Math.min(100, pageCount - page + 1) }, (_, i) => page + i), items: [copy], state: 'READY' });
      }
    }
    attempt = await transport.update(attempt, 'fasong-jihua', { batches: plan });
    batches = attemptBatches(attempt);
  }
  // 所有待发送份的格式先校验；每份只读取一次，分页/拆批复用该结果。
  const barcodes = new Map<number, Awaited<ReturnType<typeof buildDmsPrintBarcode>>>();
  for (const batch of batches) {
    if (batch.state === 'SUBMITTED') continue;
    if (batch.state !== 'READY') throw new Error('打印发送结果未知，禁止重复发送');
    const copy = batch.items[0]!;
    const number = numbers[copy];
    if (!number || batch.items.length !== 1) throw new Error('批次与逐份号码不匹配');
    if (!barcodes.has(copy)) barcodes.set(copy, await buildDmsPrintBarcode(number, config.buildCustomBarcode));
  }
  for (let index = 0; index < batches.length; ) {
    const batch = batches[index]!;
    if (batch.state === 'SUBMITTED') {
      index++;
      continue;
    }
    if (batch.state !== 'READY') throw new Error('打印发送结果未知，禁止重复发送');
    const number = numbers[batch.items[0]!];
    if (!number || batch.items.length !== 1) throw new Error('批次与逐份号码不匹配');
    const ticketResponse = await createDmsFilePrintTicket({
      requireSerialWatermark: true,
      ...watermarkParameters(config),
      customBarcode: barcodes.get(batch.items[0]!)!,
      copies: 1,
      operationId: batch.id,
      printPages: formatPageNumbers(batch.pages),
      resourceId: config.fileVersionId,
      resourceType: 'FILE_VERSION',
    });
    const ticket = ticketResponse.data;
    if (!ticket?.accessTicket || ticket.fileVersionId !== attempt.fileVersionId || !ticket.fileName) throw new Error('打印票据版本或内容无效');
    const item = {
      accessTicket: ticket.accessTicket,
      fileName: ticket.fileName,
      fileVersionId: ticket.fileVersionId,
      printPages: formatPageNumbers(batch.pages),
    };
    let pdf: Blob;
    try {
      pdf = await renderDmsPrintPdf({ items: [item], source: item });
    } catch (error) {
      if (!(await isBatchPdfSizeError(error)) || batch.pages.length < 2) throw error;
      const middle = Math.ceil(batch.pages.length / 2);
      const parts = [batch.pages.slice(0, middle), batch.pages.slice(middle)].map((pages) => ({ id: uuidv4(), pages, items: [...batch.items], state: 'READY' }));
      attempt = await transport.update(attempt, 'chaifen-pici', { batchId: batch.id, batches: parts });
      batches = attemptBatches(attempt);
      continue;
    }
    const html = await buildDmsPrintableHtml(pdf, { ...normalized, pages: undefined }, 1, batch.pages);
    if (!(await onlineUtils.isHiprintClientReady())) throw new Error('打印客户端未连接，请启动客户端后恢复原任务');
    const token = uuidv4();
    // 只有成功取得一次派发许可才调用客户端；许可响应丢失按未知处理。
    await transport.update(attempt, 'kaishi-pici', { batchId: batch.id, token });
    await dispatchDmsPrintBatch(
      {
        html,
        clientOptions: { copies: 1, title: `${fileName} [${attempt.id}/${batch.id}]` },
      },
      async () => {
        attempt = await transport.submitted(attempt, batch, token);
      },
    );
    batch.state = 'SUBMITTED';
    index++;
  }
}