import { buildDmsPrintBarcode, type DmsPrintBarcodeBuilder } from './dmsPrintBarcode';
import type { DmsPrintAttempt, DmsPrintBatch } from './dmsPrintAttempt';
import { v4 as uuidv4 } from 'uuid';
import { defHttp } from '#/api/request';
import { onlineUtils } from '#/utils/jnpf';
import { printManagedDmsDocument } from './dmsHiprint';
import { attemptBatches } from './dmsPrintAttempt';

const MODEL_ID = '37a318b30d7c4daf9670d141b33ed1b7';
const endpoint = '/api/dms/biz/wenjian/dayin/chongda/';
export interface DmsReprintAttempt extends DmsPrintAttempt {
  printRecordId: string;
  reason: string;
  bizSign: string;
  createdAt: number | string;
  submittedAt?: number | string;
  documentId?: string;
}
export interface DmsReprintLockStatus {
  locked: boolean;
  requestId?: string;
  printRecordId: string;
  userId?: string;
  userName?: string;
  reason?: string;
  createdAt?: number | string;
  phase?: 'READY' | 'UNKNOWN' | 'PARTIAL' | 'REGISTRATION_PENDING';
  owner?: boolean;
  canCancel?: boolean;
  canResume?: boolean;
  submittedBatches?: number;
  totalBatches?: number;
}
export const REPRINT_LOCK_EVENT = 'DMS_REPRINT_LOCK_STATUS';
export const REPRINT_COMPLETED_EVENT = 'DMS_REPRINT_COMPLETED';
export interface DmsReprintLockDialog {
  buildCustomBarcode?: DmsPrintBarcodeBuilder;
  watermarkBusinessTypes?: string[];
  status: DmsReprintLockStatus;
  onConfirm?: () => void;
}
interface NativeSubmitContext {
  formData: Record<string, any>;
  params?: Record<string, any>;
  setFormData: (field: string, value: any) => void;
  formContext: {
    closeReprintForm?: () => Promise<void>;
    refreshReprint?: () => void;
    isEdit: boolean;
    submit: (resolve: (value: any) => void, reject: (error: unknown) => void) => void;
  };
}
async function post(action: string, data: unknown): Promise<DmsReprintAttempt> {
  const res = await defHttp.post<{ code: number; data: DmsReprintAttempt; msg?: string }>({ url: endpoint + action, data }, { errorMessageMode: 'none' });
  if (res.code !== 200) throw new Error(res.msg || '保存重打进度失败');
  return res.data;
}
function update(attempt: DmsPrintAttempt, action: string, data: Record<string, unknown> = {}) {
  return post(action, { requestId: attempt.id, printRecordId: (attempt as DmsReprintAttempt).printRecordId, ...data });
}
function receiptKey(attempt: DmsReprintAttempt, batch: DmsPrintBatch) {
  return `dms-reprint-receipt:${encodeURIComponent(attempt.tenantId)}:${encodeURIComponent(attempt.userId)}:${attempt.id}:${batch.id}`;
}
/** 局部实例锁防止同一表单的连点和迟到回调并发保存，服务端唯一关联兜底。 */
const submissions = new Map<string, Promise<any>>();

export async function getDmsReprintLockStatus(recordId: string): Promise<DmsReprintLockStatus> {
  const res = await defHttp.get<{ code: number; data: DmsReprintLockStatus; msg?: string }>({
    url: `${endpoint}${encodeURIComponent(recordId)}/lock-status`,
  });
  if (res.code !== 200) throw new Error(res.msg || '无法读取重打状态');
  return res.data;
}

export async function openDmsReprint(recordId: string, onConfirm?: () => void, buildCustomBarcode?: DmsPrintBarcodeBuilder, watermarkBusinessTypes?: string[]) {
  if (!recordId) throw new Error('打印记录ID不能为空');
  const status = await getDmsReprintLockStatus(recordId);
  if (status.locked) {
    onlineUtils.getEmitter().emit(REPRINT_LOCK_EVENT, { status, onConfirm, buildCustomBarcode, ...(watermarkBusinessTypes ? { watermarkBusinessTypes } : {}) });
    return;
  }
  openNativeReprint(recordId, undefined, onConfirm, buildCustomBarcode, watermarkBusinessTypes);
}

async function getActive(recordId: string) {
  const res = await defHttp.get<{ code: number; data?: DmsReprintAttempt; msg?: string }>({
    url: `${endpoint}${encodeURIComponent(recordId)}/active`,
  });
  if (res.code !== 200) throw new Error(res.msg || '无法读取重打状态');
  return res.data;
}

export async function resumeDmsReprint(recordId: string, requestId: string, onConfirm?: () => void, buildCustomBarcode?: DmsPrintBarcodeBuilder, watermarkBusinessTypes?: string[]) {
  let existing = await getActive(recordId);
  if (!existing || existing.id !== requestId) throw new Error('原任务状态已变化，请刷新状态后操作');
  if (attemptBatches(existing).some((batch) => batch.state === 'SENDING')) throw new Error('发送结果尚未确认，请先刷新状态并补交已有回执');
  existing = await update(existing, 'zhuangtai');
  if (existing.documentId && existing.state !== 'OPEN') {
    await sendDmsReprint(existing, undefined, buildCustomBarcode, watermarkBusinessTypes);
    onConfirm?.();
  } else if (existing.documentId) await openReprintPreview(existing, onConfirm, undefined, buildCustomBarcode, watermarkBusinessTypes);
  else openNativeReprint(recordId, existing, onConfirm, buildCustomBarcode, watermarkBusinessTypes);
}

export async function cancelDmsReprint(recordId: string, requestId: string) {
  await post('quxiao-fasong', { printRecordId: recordId, requestId });
}

/** 只补交当前浏览器已经收到的成功回执；不能把未知状态推定为成功或失败。 */
export async function refreshDmsReprintLock(status: DmsReprintLockStatus) {
  if (status.owner) {
    let active = await getActive(status.printRecordId);
    if (active && active.id === status.requestId) {
      for (const batch of attemptBatches(active)) {
        const key = receiptKey(active, batch);
        let token: string | null = null;
        try {
          token = localStorage.getItem(key);
        } catch {
          /* 未保存回执时保持未知。 */
        }
        if (!token) continue;
        active = await update(active, 'queren-pici', { batchId: batch.id, token });
        try {
          localStorage.removeItem(key);
        } catch {
          /* 服务端回执幂等。 */
        }
      }
    }
  }
  return getDmsReprintLockStatus(status.printRecordId);
}

function openNativeReprint(recordId: string, existing?: DmsReprintAttempt, onConfirm?: () => void, buildCustomBarcode?: DmsPrintBarcodeBuilder, watermarkBusinessTypes?: string[]) {
  const requestId = existing?.id || uuidv4();
  onlineUtils.openFormModal({
    modelId: MODEL_ID,
    mode: 'form',
    submitMode: 'form',
    params: {
      dmsReprint: true,
      buildCustomBarcode,
      watermarkBusinessTypes,
      recovering: !!existing,
      requestId,
      printRecordId: recordId,
      bupingheng_mingxi: [{ dayin_jilu_id: recordId, cuoshi: 'cuoshi3', yuanyin: existing?.reason || '' }],
      chongda_fasong_id: requestId,
    },
    fieldMapping: { bupingheng_mingxi: 'bupingheng_mingxi', chongda_fasong_id: 'chongda_fasong_id' },
    onConfirm,
  });
}

/** 由签名后的原生customSubmit调用；原生formContext.submit仍负责主子表CRUD。 */
export function submitDmsReprint(context: NativeSubmitContext): Promise<any> {
  const id = String(context.params?.requestId || context.formData.chongda_fasong_id || '');
  if (!id) return Promise.reject(new Error('请从打印记录重打入口操作'));
  const current = submissions.get(id);
  if (current) return current;
  const promise = execute(context, id).finally(() => submissions.delete(id));
  submissions.set(id, promise);
  return promise;
}
async function execute(context: NativeSubmitContext, id: string) {
  const rows = context.formData.bupingheng_mingxi;
  if (!Array.isArray(rows) || rows.length !== 1 || rows[0]?.cuoshi !== 'cuoshi3' || context.formContext.isEdit)
    throw new Error('重打必须由单条原打印记录发起，已保存记录不得再次执行');
  let attempt = await post('zhunbei-fasong', {
    requestId: id,
    printRecordId: rows[0].dayin_jilu_id,
    reason: rows[0].yuanyin,
    bizSign: context.formData.biz_sign,
  });
  // 重试保留第一次发送的签名和原因，不允许新输入改变已经发生的重打。
  function freezeForm() {
    context.setFormData('chongda_fasong_id', attempt.id);
    context.setFormData('biz_sign', attempt.bizSign);
    context.setFormData('dengji_ren_id', attempt.userId);
    context.setFormData('dengji_shijian', new Date(attempt.createdAt).getTime());
    context.setFormData('bupingheng_mingxi', [
      { ...rows[0], dayin_jilu_id: attempt.printRecordId, cuoshi: 'cuoshi3', yuanyin: attempt.reason, xin_dayin_renwu_id: '' },
    ]);
  }
  freezeForm();
  attempt = await update(attempt, 'zhuangtai');
  const saveRegistration = async () => {
    const result: any = await new Promise((resolve, reject) => context.formContext.submit(resolve, reject));
    if (result?.code !== 200) throw new Error(result?.msg || '不平衡登记保存失败');
  };
  // 恢复已成功发送的任务只补原生登记，不再打开预览或派发。
  if (attempt.state === 'CONFIRMED' || attempt.state === 'CLOSED') {
    await completeRegistration(attempt, saveRegistration);
    const completed = await update(attempt, 'zhuangtai');
    return { code: 200, msg: '重打不平衡登记已完成', data: { id: completed.documentId } };
  }
  await context.formContext.closeReprintForm?.();
  let msg = '重打信息已暂存，请在预览中手动打印，发送成功后自动登记不平衡';
  try {
    await openReprintPreview(attempt, context.formContext.refreshReprint, saveRegistration, context.params?.buildCustomBarcode, context.params?.watermarkBusinessTypes);
  } catch (error: any) {
    msg = `重打信息已暂存，预览打开失败：${error?.message || '网络异常'}。请从原打印记录点击重打继续，尚未新增不平衡登记`;
  }
  return { code: 200, msg, dmsReprintPrepared: true };
}

// 发送成功与原生保存分属两个系统：以任务状态和唯一关联恢复，失败时只补登记。
const registrations = new Map<string, Promise<void>>();
function completeRegistration(original: DmsReprintAttempt, saveRegistration?: () => Promise<void>): Promise<void> {
  const current = registrations.get(original.id);
  if (current) return current;
  const promise = (async () => {
    let attempt = await update(original, 'zhuangtai');
    if (!['CONFIRMED', 'CLOSED'].includes(attempt.state)) throw new Error('尚未收到全部打印发送成功回传，不能登记不平衡');
    if (attempt.state !== 'CLOSED') {
      try {
        if (!attempt.documentId) {
          if (!saveRegistration) throw new Error('请从原打印记录继续任务，补存不平衡登记');
          try {
            await saveRegistration();
          } catch (error) {
            attempt = await update(attempt, 'zhuangtai');
            if (!attempt.documentId) throw error;
          }
          attempt = await update(attempt, 'zhuangtai');
          if (!attempt.documentId) throw new Error('尚未确认原生登记保存结果，请恢复原任务核对');
        }
        attempt = await update(attempt, 'jieshu-fasong');
      } catch (error: any) {
        throw new Error(`打印已发送成功，但不平衡登记未完成：${error?.message || '网络异常'}。请继续原任务补登记，系统不会重复打印`);
      }
    }
    onlineUtils.getEmitter().emit(REPRINT_COMPLETED_EVENT, { printRecordId: attempt.printRecordId, requestId: attempt.id });
  })().finally(() => registrations.delete(original.id));
  registrations.set(original.id, promise);
  return promise;
}

async function openReprintPreview(attempt: DmsReprintAttempt, onPrintSuccess?: () => void, saveRegistration?: () => Promise<void>, buildCustomBarcode?: DmsPrintBarcodeBuilder, watermarkBusinessTypes?: string[]) {
  const numbers = JSON.parse(attempt.numbersJson || '[]');
  const number = numbers[0];
  if (!number?.serialNumber) throw new Error('原流水缺失，不能打开重打预览');
  const opened = await onlineUtils.previewDmsFile({
    wenjianZhongxinId: attempt.fileVersionId,
    previewFormat: 'pdf',
    watermarkType: 'print',
    customBarcode: await buildDmsPrintBarcode(number, buildCustomBarcode),
    ...(watermarkBusinessTypes ? { watermarkBusinessTypes } : {}),
    showPrintButton: true,
    printOptions: { copies: 1 },
    closeOnPrintSuccess: true,
    onPrintSuccess,
    reprint: { requestId: attempt.id, printRecordId: attempt.printRecordId, send: () => sendDmsReprint(attempt, saveRegistration, buildCustomBarcode, watermarkBusinessTypes) },
  });
  if (!opened) throw new Error('打印预览未能打开，请稍后重试');
}

const sending = new Map<string, Promise<void>>();
/** 预览手动发送或恢复已确认任务；先核对原状态，已发送只补登记，不重新取号或派发。 */
export function sendDmsReprint(original: DmsReprintAttempt, saveRegistration?: () => Promise<void>, buildCustomBarcode?: DmsPrintBarcodeBuilder, watermarkBusinessTypes?: string[]): Promise<void> {
  const current = sending.get(original.id);
  if (current) return current;
  const promise = send(original, saveRegistration, buildCustomBarcode, watermarkBusinessTypes).finally(() => sending.delete(original.id));
  sending.set(original.id, promise);
  return promise;
}
async function send(original: DmsReprintAttempt, saveRegistration?: () => Promise<void>, buildCustomBarcode?: DmsPrintBarcodeBuilder, watermarkBusinessTypes?: string[]) {
  let attempt = await update(original, 'zhuangtai');
  if (String(attempt.state) === 'CANCELLED') throw new Error('本次重打已取消，请关闭预览');
  if (attempt.state === 'CONFIRMED' || attempt.state === 'CLOSED') {
    await completeRegistration(attempt, saveRegistration);
    return;
  }
  if (!attempt.documentId && !saveRegistration) throw new Error('请从原打印记录继续重打，恢复原生登记上下文后再打印');
  const finish = () => completeRegistration(attempt, saveRegistration);
  async function submitted(original: DmsPrintAttempt, batch: DmsPrintBatch, token: string) {
    const current = original as DmsReprintAttempt;
    const key = receiptKey(current, batch);
    try {
      localStorage.setItem(key, token);
    } catch {
      /* 成功事实优先持久化到服务端。 */
    }
    attempt = await update(current, 'queren-pici', { batchId: batch.id, token });
    try {
      localStorage.removeItem(key);
    } catch {
      /* 重复回传服务端幂等。 */
    }
    if (attempt.state !== 'OPEN') await finish();
    return attempt;
  }
  async function recover(original: DmsPrintAttempt) {
    attempt = original as DmsReprintAttempt;
    for (const batch of attemptBatches(original)) {
      let token: string | null = null;
      try {
        token = localStorage.getItem(receiptKey(attempt, batch));
      } catch {
        /* 无证据保持未知。 */
      }
      if (token) await submitted(attempt, batch, token);
    }
    return attempt;
  }
  await printManagedDmsDocument('原流水重打', { fileVersionId: attempt.fileVersionId, copies: 1, buildCustomBarcode, watermarkBusinessTypes }, attempt, {
    update,
    recover,
    submitted,
    allowHistoricalSerial: true,
  });
  await finish();
}