import { beforeEach, describe, expect, it, vi } from 'vitest';
const mocks = vi.hoisted(() => ({ post: vi.fn(), get: vi.fn(), print: vi.fn(), open: vi.fn(), emit: vi.fn(), preview: vi.fn() }));
vi.mock('#/api/request', () => ({ defHttp: { post: mocks.post, get: mocks.get } }));
vi.mock('#/utils/jnpf', () => ({ onlineUtils: { openFormModal: mocks.open, previewDmsFile: mocks.preview, getEmitter: () => ({ emit: mocks.emit }) } }));
vi.mock('../dmsHiprint', () => ({ printManagedDmsDocument: mocks.print }));
import { openDmsReprint, submitDmsReprint, sendDmsReprint, resumeDmsReprint, cancelDmsReprint, refreshDmsReprintLock, REPRINT_LOCK_EVENT } from '../dmsReprint';
import { configureReprintModal, reprintAuditSign, DMS_REPRINT_MODEL_ID } from '../dmsReprintMeasure';
let attempt: any;
let data: any;
let submit: any;
let context: any;
const receiptStore = new Map<string, string>();
beforeEach(() => {
  vi.resetAllMocks();
  receiptStore.clear();
  vi.stubGlobal('localStorage', {
    getItem: (k: string) => receiptStore.get(k),
    setItem: (k: string, v: string) => receiptStore.set(k, v),
    removeItem: (k: string) => receiptStore.delete(k),
  });
  attempt = {
    id: 'request',
    tenantId: '0',
    userId: 'actor',
    printRecordId: 'record',
    fileVersionId: 'version',
    reason: 'original reason',
    bizSign: 'original-sign',
    createdAt: 1700000000000,
    state: 'OPEN',
    numbersJson: JSON.stringify([{ serialNumber: 'original', countSerialNumber: '20260001' }]),
    copies: 1,
    batchesJson: '[]',
  };
  data = { chongda_fasong_id: 'request', biz_sign: 'new-sign', bupingheng_mingxi: [{ dayin_jilu_id: 'record', cuoshi: 'cuoshi3', yuanyin: 'new reason' }] };
  submit = vi.fn((resolve: any) => {
    attempt.documentId = 'doc';
    resolve({ code: 200, data: { id: 'doc' } });
  });
  context = {
    formData: data,
    setFormData: (k: string, v: any) => {
      data[k] = v;
    },
    formContext: { isEdit: false, submit, closeReprintForm: vi.fn().mockResolvedValue(undefined) },
  };
  mocks.post.mockImplementation(async ({ url }: any) => {
    if (url.endsWith('jieshu-fasong')) attempt.state = 'CLOSED';
    if (url.endsWith('queren-pici')) attempt.state = 'CONFIRMED';
    return { code: 200, data: { ...attempt } };
  });
  mocks.print.mockImplementation(async () => {
    attempt.state = 'CONFIRMED';
  });
  mocks.preview.mockResolvedValue(true);
});
describe('原生重打成功后登记及恢复', () => {
  it('在线配置格式贯穿重打入口、原生表单、预览和实际发送，号码保持原流水', async () => {
    const builder = async ({ serialNumber, countSerialNumber }: any) => [{ barValue: serialNumber, barText: `原件 ${serialNumber} / ${countSerialNumber || '历史无计数号'}` }];
    mocks.get.mockResolvedValue({ code: 200, data: { locked: false, printRecordId: 'record' } });
    await openDmsReprint('record', undefined, builder, ['RECORD', 'REPORT']);
    context.params = mocks.open.mock.calls[0]![0].params;
    expect(context.params.buildCustomBarcode).toBe(builder);
    expect(context.params.watermarkBusinessTypes).toEqual(['RECORD', 'REPORT']);
    await submitDmsReprint(context);
    const preview = mocks.preview.mock.calls[0]![0];
    expect(preview.watermarkType).toBe('print');
    expect(preview.watermarkBusinessTypes).toEqual(['RECORD', 'REPORT']);
    expect(preview.customBarcode).toEqual([{ barValue: 'original', barText: '原件 original / 20260001' }]);
    await preview.reprint.send();
    expect(mocks.print.mock.calls[0]![1].buildCustomBarcode).toBe(builder);
    expect(mocks.print.mock.calls[0]![1].watermarkBusinessTypes).toEqual(['RECORD', 'REPORT']);
    expect(mocks.print.mock.calls[0]![2].numbersJson).toBe(attempt.numbersJson);
  });
  it('共享格式接口失败时保留原重打任务，不打开预览、不发送、不提前登记', async () => {
    const builder = async () => { throw new Error('格式接口不可用'); };
    mocks.get.mockResolvedValue({ code: 200, data: { locked: false, printRecordId: 'record' } });
    await openDmsReprint('record', undefined, builder);
    context.params = mocks.open.mock.calls[0]![0].params;
    const result = await submitDmsReprint(context);
    expect(result.msg).toContain('格式接口不可用');
    expect(mocks.preview).not.toHaveBeenCalled();
    expect(mocks.print).not.toHaveBeenCalled();
    expect(submit).not.toHaveBeenCalled();
  });
  it('历史无计数号重打和已保存登记恢复仍使用在线配置，不补号', async () => {
    const builder = async ({ serialNumber, countSerialNumber }: any) => [{ barValue: serialNumber, barText: countSerialNumber || `历史 ${serialNumber}` }];
    attempt.numbersJson = JSON.stringify([{ serialNumber: 'original' }]);
    attempt.documentId = 'doc';
    mocks.get.mockResolvedValue({ code: 200, data: attempt });
    await resumeDmsReprint('record', 'request', undefined, builder);
    const preview = mocks.preview.mock.calls[0]![0];
    expect(preview.customBarcode).toEqual([{ barValue: 'original', barText: '历史 original' }]);
    await preview.reprint.send();
    expect(mocks.print.mock.calls[0]![1].buildCustomBarcode).toBe(builder);
    expect(mocks.post.mock.calls.some(([req]: any) => req.url.endsWith('/yulan-canshu'))).toBe(false);
  });
  it('占用弹窗及未保存登记恢复均保留格式函数', async () => {
    const builder = ({ serialNumber }: any) => [{ barValue: serialNumber, barText: serialNumber }];
    mocks.get.mockResolvedValueOnce({ code: 200, data: { locked: true } }).mockResolvedValueOnce({ code: 200, data: attempt });
    await openDmsReprint('record', undefined, builder);
    expect(mocks.emit.mock.calls[0]![1].buildCustomBarcode).toBe(builder);
    await resumeDmsReprint('record', 'request', undefined, builder);
    expect(mocks.open.mock.calls[0]![0].params.buildCustomBarcode).toBe(builder);
  });
  it('统一弹窗预填一条固定措施，恢复保持原请求ID', async () => {
    mocks.get.mockResolvedValue({ code: 200, data: attempt });
    await resumeDmsReprint('record', 'request');
    const config = mocks.open.mock.calls[0]![0];
    expect(config.submitMode).toBe('form');
    expect(config.params.requestId).toBe('request');
    expect(config.params.bupingheng_mingxi).toEqual([{ dayin_jilu_id: 'record', cuoshi: 'cuoshi3', yuanyin: 'original reason' }]);
  });
  it('查询未锁定后才打开原生重打表单', async () => {
    mocks.get.mockResolvedValue({ code: 200, data: { locked: false, printRecordId: 'record' } });
    await openDmsReprint('record');
    expect(mocks.get).toHaveBeenCalledWith({ url: expect.stringContaining('/record/lock-status') });
    expect(mocks.open).toHaveBeenCalledTimes(1);
    expect(mocks.emit).not.toHaveBeenCalled();
  });
  it('已有占用只打开状态弹窗，包括其他发起人的占用', async () => {
    const status = { locked: true, printRecordId: 'record', requestId: 'request', owner: false, phase: 'READY' };
    mocks.get.mockResolvedValue({ code: 200, data: status });
    await openDmsReprint('record');
    expect(mocks.open).not.toHaveBeenCalled();
    expect(mocks.emit).toHaveBeenCalledWith(REPRINT_LOCK_EVENT, { status, onConfirm: undefined, buildCustomBarcode: undefined });
  });
  it('刷新状态只补交已保存回执，不打印也不自行登记', async () => {
    attempt.state = 'OPEN';
    attempt.batchesJson = JSON.stringify([{ id: 'batch', state: 'SENDING' }]);
    receiptStore.set('dms-reprint-receipt:0:actor:request:batch', 'token');
    mocks.get.mockResolvedValueOnce({ code: 200, data: attempt }).mockResolvedValueOnce({ code: 200, data: { locked: true, phase: 'REGISTRATION_PENDING' } });
    const result = await refreshDmsReprintLock({ locked: true, printRecordId: 'record', requestId: 'request', owner: true });
    expect(result.phase).toBe('REGISTRATION_PENDING');
    expect(mocks.post).toHaveBeenCalledWith(
      expect.objectContaining({ url: expect.stringContaining('queren-pici'), data: expect.objectContaining({ token: 'token' }) }),
      expect.anything(),
    );
    expect(mocks.print).not.toHaveBeenCalled();
    expect(submit).not.toHaveBeenCalled();
    expect(receiptStore.size).toBe(0);
  });
  it('取消只使用原任务ID，后端拒绝时不打开新表单', async () => {
    mocks.post.mockResolvedValue({ code: 400, msg: '任务已派发，不能取消' });
    await expect(cancelDmsReprint('record', 'request')).rejects.toThrow('不能取消');
    expect(mocks.open).not.toHaveBeenCalled();
    expect(mocks.print).not.toHaveBeenCalled();
  });
  it('原任务已消失时恢复不偷偷创建新任务', async () => {
    mocks.get.mockResolvedValue({ code: 200, data: null });
    await expect(resumeDmsReprint('record', 'request')).rejects.toThrow('状态已变化');
    expect(mocks.open).not.toHaveBeenCalled();
  });
  it('先暂存关闭表单再打开预览，手动发送成功后才原生登记', async () => {
    await expect(submitDmsReprint(context)).resolves.toMatchObject({ code: 200, dmsReprintPrepared: true });
    expect(submit).not.toHaveBeenCalled();
    expect(data.biz_sign).toBe('original-sign');
    expect(data.dengji_ren_id).toBe('actor');
    expect(data.bupingheng_mingxi[0].yuanyin).toBe('original reason');
    expect(context.formContext.closeReprintForm.mock.invocationCallOrder[0]!).toBeLessThan(mocks.preview.mock.invocationCallOrder[0]!);
    expect(mocks.print).not.toHaveBeenCalled();
    expect(mocks.preview.mock.calls[0]![0]).toMatchObject({
      wenjianZhongxinId: 'version',
      printOptions: { copies: 1 },
      customBarcode: [{ barValue: 'original', barText: '打印流水号: original  计数流水号: 20260001' }],
    });
    await mocks.preview.mock.calls[0]![0].reprint.send();
    expect(mocks.print).toHaveBeenCalledTimes(1);
    expect(submit).toHaveBeenCalledTimes(1);
    expect(mocks.print.mock.invocationCallOrder[0]!).toBeLessThan(submit.mock.invocationCallOrder[0]!);
    expect(attempt.state).toBe('CLOSED');
  });
  it('打印成功登记失败保留确认状态，重试只补登记不再派发', async () => {
    submit.mockImplementation((_: any, reject: any) => reject(new Error('save failed')));
    await submitDmsReprint(context);
    const send = mocks.preview.mock.calls[0]![0].reprint.send;
    await expect(send()).rejects.toThrow('save failed');
    expect(attempt.state).toBe('CONFIRMED');
    expect(mocks.post.mock.calls.some(([r]: any[]) => r.url.endsWith('jieshu-fasong'))).toBe(false);
    submit.mockImplementation((resolve: any) => {
      attempt.documentId = 'doc';
      resolve({ code: 200 });
    });
    await send();
    expect(mocks.print).toHaveBeenCalledTimes(1);
    expect(attempt.state).toBe('CLOSED');
  });
  it('发送成功后原生保存响应丢失按唯一关联恢复，不重复创建', async () => {
    submit.mockImplementation((_: any, reject: any) => {
      attempt.documentId = 'doc';
      reject(new Error('network'));
    });
    await submitDmsReprint(context);
    await mocks.preview.mock.calls[0]![0].reprint.send();
    expect(submit).toHaveBeenCalledTimes(1);
    expect(attempt.state).toBe('CLOSED');
  });
  it('原生非200响应不得标记登记完成，保留已发送事实', async () => {
    submit.mockImplementation((resolve: any) => resolve({ code: 400, msg: 'save failed' }));
    await submitDmsReprint(context);
    await expect(mocks.preview.mock.calls[0]![0].reprint.send()).rejects.toThrow('save failed');
    expect(attempt.state).toBe('CONFIRMED');
    expect(mocks.emit).not.toHaveBeenCalledWith('DMS_REPRINT_COMPLETED', expect.anything());
  });
  it('预览打开失败保留技术任务，不生成不平衡登记', async () => {
    mocks.preview.mockRejectedValue(new Error('preview failed'));
    await expect(submitDmsReprint(context)).resolves.toMatchObject({ code: 200, dmsReprintPrepared: true, msg: expect.stringContaining('预览打开失败') });
    expect(submit).not.toHaveBeenCalled();
    expect(mocks.print).not.toHaveBeenCalled();
    expect(attempt.state).toBe('OPEN');
  });
  it('未发送就取消只结束技术任务，不创建登记', async () => {
    await submitDmsReprint(context);
    mocks.post.mockImplementation(async () => {
      attempt.state = 'CANCELLED';
      return { code: 200, data: attempt };
    });
    await cancelDmsReprint('record', 'request');
    await expect(mocks.preview.mock.calls[0]![0].reprint.send()).rejects.toThrow('已取消');
    expect(submit).not.toHaveBeenCalled();
    expect(mocks.print).not.toHaveBeenCalled();
  });
  it('已确认任务恢复表单后直接补登记，复用冻结签名且不打开预览', async () => {
    attempt.state = 'CONFIRMED';
    await expect(submitDmsReprint(context)).resolves.toMatchObject({ code: 200, data: { id: 'doc' } });
    expect(data.biz_sign).toBe('original-sign');
    expect(submit).toHaveBeenCalledTimes(1);
    expect(mocks.preview).not.toHaveBeenCalled();
    expect(mocks.print).not.toHaveBeenCalled();
  });
  it('迟到及并发成功回执只创建一次原生登记', async () => {
    let transport: any;
    mocks.print.mockImplementation(async (_: any, __: any, ___: any, t: any) => {
      transport = t;
      throw new Error('timeout');
    });
    await submitDmsReprint(context);
    await expect(mocks.preview.mock.calls[0]![0].reprint.send()).rejects.toThrow('timeout');
    expect(submit).not.toHaveBeenCalled();
    const b = { id: 'batch', state: 'SENDING' };
    await Promise.all([transport.submitted(attempt, b, 'token'), transport.submitted(attempt, b, 'token')]);
    expect(submit).toHaveBeenCalledTimes(1);
    expect(attempt.state).toBe('CLOSED');
  });
  it('暂存失败不关闭填写窗口，也不保存或打开预览', async () => {
    mocks.post.mockRejectedValue(new Error('prepare failed'));
    await expect(submitDmsReprint(context)).rejects.toThrow('prepare failed');
    expect(context.formContext.closeReprintForm).not.toHaveBeenCalled();
    expect(submit).not.toHaveBeenCalled();
    expect(mocks.preview).not.toHaveBeenCalled();
  });
  it('部分回传或结果未知时不登记，全部成功才登记', async () => {
    let transport: any;
    mocks.print.mockImplementation(async (_: any, __: any, ___: any, t: any) => {
      transport = t;
      throw new Error('unknown');
    });
    await submitDmsReprint(context);
    await expect(mocks.preview.mock.calls[0]![0].reprint.send()).rejects.toThrow('unknown');
    mocks.post.mockImplementation(async () => ({ code: 200, data: { ...attempt } }));
    await transport.submitted(attempt, { id: 'partial', state: 'SENDING' }, 'token');
    expect(submit).not.toHaveBeenCalled();
    attempt.state = 'CONFIRMED';
    mocks.post.mockImplementation(async ({ url }: any) => {
      if (url.endsWith('jieshu-fasong')) attempt.state = 'CLOSED';
      return { code: 200, data: { ...attempt } };
    });
    await transport.submitted(attempt, { id: 'final', state: 'SENDING' }, 'token');
    expect(submit).toHaveBeenCalledTimes(1);
    expect(attempt.state).toBe('CLOSED');
  });
  it('已有登记恢复直接打开原任务预览，不再次签名登记或自动打印', async () => {
    attempt.documentId = 'doc';
    mocks.get.mockResolvedValue({ code: 200, data: attempt });
    await resumeDmsReprint('record', 'request');
    expect(mocks.open).not.toHaveBeenCalled();
    expect(mocks.preview).toHaveBeenCalledTimes(1);
    expect(submit).not.toHaveBeenCalled();
    expect(mocks.print).not.toHaveBeenCalled();
  });
  it('同请求并发提交仅暂存并打开一次预览', async () => {
    const first = submitDmsReprint(context);
    const second = submitDmsReprint(context);
    expect(first).toBe(second);
    await first;
    expect(submit).not.toHaveBeenCalled();
    expect(mocks.preview).toHaveBeenCalledTimes(1);
  });
  it('无已保存登记时即使调用发送也不打印', async () => {
    await expect(sendDmsReprint(attempt)).rejects.toThrow('恢复原生登记上下文');
    expect(mocks.print).not.toHaveBeenCalled();
  });
  it('未知结果不能登记或结束任务', async () => {
    attempt.documentId = 'doc';
    mocks.print.mockRejectedValue(new Error('结果未知'));
    await expect(sendDmsReprint(attempt)).rejects.toThrow('结果未知');
    expect(submit).not.toHaveBeenCalled();
    expect(mocks.post.mock.calls.some(([r]: any[]) => r.url.endsWith('jieshu-fasong'))).toBe(false);
  });
  it('旧流程已有登记的迟到回传复用原单据', async () => {
    attempt.documentId = 'doc';
    let transport: any;
    mocks.print.mockImplementation(async (_: any, __: any, ___: any, t: any) => {
      transport = t;
      throw new Error('timeout');
    });
    await expect(sendDmsReprint(attempt)).rejects.toThrow('timeout');
    const b = { id: 'batch', items: [0], pages: [1], state: 'SENDING' };
    await transport.submitted(attempt, b, 'token');
    expect(mocks.emit).toHaveBeenCalledWith('DMS_REPRINT_COMPLETED', { printRecordId: 'record', requestId: 'request' });
    expect(submit).not.toHaveBeenCalled();
    expect(receiptStore.size).toBe(0);
  });
  it('发送成功但更新执行失败，重试读取确认状态后仅更新执行', async () => {
    attempt.documentId = 'doc';
    mocks.post.mockImplementation(async ({ url }: any) => {
      if (url.endsWith('jieshu-fasong')) throw new Error('finish failed');
      return { code: 200, data: { ...attempt } };
    });
    await expect(sendDmsReprint(attempt)).rejects.toThrow('finish failed');
    expect(attempt.state).toBe('CONFIRMED');
    // 真实传输层对CONFIRMED直接返回；模拟此契约，不派发新批次。
    mocks.print.mockImplementation(async (_: any, __: any, original: any) => {
      expect(original.state).toBe('CONFIRMED');
    });
    mocks.post.mockImplementation(async ({ url }: any) => {
      if (url.endsWith('jieshu-fasong')) attempt.state = 'CLOSED';
      return { code: 200, data: { ...attempt } };
    });
    await sendDmsReprint(attempt);
    expect(attempt.state).toBe('CLOSED');
    expect(submit).not.toHaveBeenCalled();
  });
});
describe('重打弹窗专属配置', () => {
  it('仅目标入口隐藏子表增删按钮并锁恢复原因', () => {
    const form = {
      fields: [
        {
          __vModel__: 'bupingheng_mingxi',
          columnBtnsList: [{ show: true }],
          footerBtnsList: [{ show: true }],
          __config__: { children: [{ __vModel__: 'cuoshi' }, { __vModel__: 'yuanyin' }] },
        },
      ],
    };
    configureReprintModal('other', form, { dmsReprint: true });
    expect(form.fields[0]!.columnBtnsList[0]!.show).toBe(true);
    configureReprintModal(DMS_REPRINT_MODEL_ID, form, { dmsReprint: true, recovering: true });
    expect(form.fields[0]!.columnBtnsList[0]!.show).toBe(false);
    expect(form.fields[0]!.footerBtnsList[0]!.show).toBe(false);
    expect((form.fields[0]!.__config__.children[1] as any).disabled).toBe(true);
  });
  it('仅已冻结任务恢复免再次签名，首次确认仍要求原生签名', () => {
    const form = { confirmBtnConfig: { biz_sign_enabled: true }, fields: [] };
    configureReprintModal(DMS_REPRINT_MODEL_ID, form, { dmsReprint: true });
    expect(form.confirmBtnConfig.biz_sign_enabled).toBe(true);
    configureReprintModal(DMS_REPRINT_MODEL_ID, form, { dmsReprint: true, recovering: true });
    expect(form.confirmBtnConfig.biz_sign_enabled).toBe(false);
  });
  it('恢复使用冻结签名作为原生保存审计关联，其他业务不变', () => {
    expect(reprintAuditSign(DMS_REPRINT_MODEL_ID, data, 'current-sign')).toBe('new-sign');
    expect(reprintAuditSign('other', data, 'current-sign')).toBe('current-sign');
  });
});