import { createTaskEvent } from "../../../repositories/task-event-repo.js";
import { updateTask } from "../../../repositories/task-repo.js";
import { createHttpError } from "../../../utils/http.js";
import { nowIso } from "../../../utils/time.js";
import { TASK_STATUS, normalizeTaskStatus, type TaskStatus } from "../../../domain/task-status.js";
import { notifyKuaishouCloudAssetNotEnough } from "../../notification/domain-notifications.js";
import {
  buyCloudtentaclesSku,
  getCloudtentaclesAsset,
  listCloudtentaclesSku,
  useCloudtentaclesSku,
} from "../../platforms/cloudtentacles/catalog-service.js";
import { getCloudtentaclesKnapsack } from "../../platforms/cloudtentacles/knapsack-service.js";
import { backCloudtentaclesVirtualNumber } from "../../platforms/cloudtentacles/virtual-number-service.js";
import { consumeKuaishouIndustryVouchersForTask } from "../../platforms/kuaishou-industry/voucher-service.js";
import {
  isKuaishouCloudTask,
  isIndustryEVoucherTask,
  maskCode,
  maskPhone,
  normalizeKuaishouCloudFlow,
  type JsonObject,
} from "./domain.js";
import { resolvePersistedCloudtentaclesContextBySourceKeys } from "./cloudtentacles-context.js";
import { syncKuaishouCloudRoleInfoBeforeDispatch } from "./dispatch-role-sync.js";
import { normalizeActor, parseTaskContext } from "./task-context.js";
import type { TaskRow } from "../../../types/repository/rows.js";

type DispatchDeliveryItem = {
  cloudSkuId: number;
  cloudSkuName: string;
  quantity: number;
};

type DispatchResultItem = DispatchDeliveryItem & {
  unitIndex: number;
  sendType: number;
  note: string;
  responseMessage: string;
};

type DispatchStockItem = DispatchDeliveryItem & {
  requiredCount: number;
  knapsackCount: number;
  purchasedCount: number;
};

type DispatchStockResult = {
  usedKnapsack: boolean;
  purchaseTriggered: boolean;
  assetBefore: number;
  assetAfter: number;
  items: DispatchStockItem[];
};

const cloudSkuDispatchLocks = new Map<string, Promise<void>>();

export async function dispatchKuaishouCloudFulfillmentTask(
  task: TaskRow,
  options: JsonObject = {}
) {
  if (!isKuaishouCloudTask(task)) {
    throw createHttpError("当前任务不是 kuaishou-lewan 履约任务", {
      statusCode: 409,
      errorCode: "kuaishou_cloud_task_invalid",
    });
  }

  const actor = normalizeActor(options.actor);
  const now = nowIso();
  const taskContext = parseTaskContext(task);
  const flow = normalizeKuaishouCloudFlow(taskContext.kuaishouCloudFulfillment);
  const cloudContext = resolvePersistedCloudtentaclesContextBySourceKeys([
    flow.binding.resolvedSourceKey,
    ...flow.binding.cloudSourceKeys,
  ]);

  if (!flow.binding.skuId || !flow.binding.vnId || !flow.binding.vnPhone) {
    throw createHttpError(
      "当前任务还没有准备好绑定资源，请先完成绑定资源准备",
      {
        statusCode: 409,
        errorCode: "kuaishou_cloud_not_prepared",
      }
    );
  }

  const persistedTicketCode = String(flow.ticket.code || "").trim();
  const voucherContext = isPlainObject(taskContext.kuaishouIndustryVoucher)
    ? taskContext.kuaishouIndustryVoucher
    : {};
  const industryVoucherCode = String(
    voucherContext.voucherCode || voucherContext.eticketId || ""
  ).trim();
  const hasIndustryVoucherForDispatch =
    Boolean(industryVoucherCode) || isIndustryEVoucherTask(task);
  const resolvedTicketCode = persistedTicketCode || industryVoucherCode;

  if (!resolvedTicketCode && !hasIndustryVoucherForDispatch) {
    throw createHttpError("旧快手小店核销流程已停用，请改用行业电子凭证处理", {
      statusCode: 409,
      errorCode: "kuaishou_cloud_missing_ticket_code",
    });
  }

  if (
    flow.dispatch.status === "success" &&
    normalizeTaskStatus(task.task_status) === TASK_STATUS.DISPATCHED_PENDING_RETURN
  ) {
    return { task, flow };
  }

  const synced = await syncKuaishouCloudRoleInfoBeforeDispatch(task, {
    now,
    actor,
    source: options.source || "system_before_dispatch",
    cloudContext,
    taskContext,
    flow,
  });
  const syncedFlow = synced.flow;
  const syncedTaskContext = synced.taskContext;

  const deliveryItems = resolveDispatchDeliveryItems(syncedFlow);
  if (deliveryItems.length === 0) {
    throw createHttpError("当前任务缺少 cloud 发货物品配置", {
      statusCode: 409,
      errorCode: "kuaishou_cloud_missing_delivery_items",
    });
  }

  let dispatchResults: DispatchResultItem[];
  let stockResult: DispatchStockResult;
  try {
    ({ dispatchResults, stockResult } = await withCloudSkuDispatchLocks(
      resolveCloudSkuDispatchLockKeys(cloudContext.resolvedSourceKey, deliveryItems),
      () => prepareStockAndDispatch({
        task,
        flow: syncedFlow,
        cloudContext,
        deliveryItems,
      })
    ));
  } catch (error) {
    await markKuaishouCloudDispatchFailed(task, syncedTaskContext, syncedFlow, error, {
      actor,
      source: options.source || "system",
    });
    throw error;
  }
  const firstDispatchResult: DispatchResultItem = dispatchResults[0] || {
    cloudSkuId: syncedFlow.binding.skuId,
    cloudSkuName: syncedFlow.binding.skuName,
    quantity: 1,
    unitIndex: 1,
    sendType: 0,
    note: "",
    responseMessage: "",
  };
  const dispatchSummary =
    dispatchResults.length > 1
      ? `cloudtentacles 发货成功，共 ${dispatchResults.length} 次`
      : String(
          firstDispatchResult.responseMessage ||
            firstDispatchResult.note ||
            "cloudtentacles 发货成功"
        ).trim();

  const nextContext = {
    ...syncedTaskContext,
    kuaishouCloudFulfillment: {
      ...syncedFlow,
      ticket: {
        ...syncedFlow.ticket,
        code: resolvedTicketCode,
        capturedAt: resolvedTicketCode
          ? syncedFlow.ticket.capturedAt || now
          : syncedFlow.ticket.capturedAt,
        capturedBy: syncedFlow.ticket.capturedBy,
      },
      dispatch: {
        ...syncedFlow.dispatch,
        status: "success",
        dispatchAt: now,
        dispatchBy: actor,
        sendType: Number(firstDispatchResult.sendType || 0) || 0,
        note: dispatchSummary,
        items: dispatchResults,
      },
      purchase: {
        ...syncedFlow.purchase,
        usedKnapsack: stockResult.usedKnapsack,
        purchaseTriggered: stockResult.purchaseTriggered,
        assetBefore: stockResult.assetBefore,
        assetAfter: stockResult.assetAfter,
        purchaseAt: stockResult.purchaseTriggered
          ? now
          : syncedFlow.purchase.purchaseAt,
        items: stockResult.items,
      },
    },
  };

  let updatedTask = await updateTask(task.id, {
    task_status: TASK_STATUS.DISPATCHED_PENDING_RETURN,
    delivery_status: "delivered",
    result_code: "kuaishou_cloud_dispatched",
    result_message: dispatchSummary,
    user_action_status: "not_required",
    last_error: "",
    context_json: JSON.stringify(nextContext),
    updated_at: now,
  });
  if (!updatedTask) {
    throw createHttpError("kuaishou-lewan 发货状态更新失败", {
      statusCode: 500,
      errorCode: "kuaishou_cloud_dispatch_update_failed",
    });
  }

  await createTaskEvent(
    task.id,
    "kuaishou_cloud_dispatched",
    {
      source: String(options.source || "system").trim() || "system",
      ticketCodeMasked: maskCode(resolvedTicketCode),
      skuId: syncedFlow.binding.skuId,
      vnId: syncedFlow.binding.vnId,
      vnPhoneMasked: maskPhone(syncedFlow.binding.vnPhone),
      sendType: firstDispatchResult.sendType,
      note: dispatchSummary,
      deliveryItems,
      dispatchResults,
      stockResult,
      actor,
    },
    now
  );

  const shouldAutoFinalize =
    options.autoFinalize === true &&
    normalizeKuaishouCloudFlow(nextContext.kuaishouCloudFulfillment)
      .returnNumber.autoReturnEnabled === true;

  if (shouldAutoFinalize) {
    const finalizeResult = await returnKuaishouCloudFulfillmentTask(
      updatedTask,
      {
        actor,
        source: options.source || "system_auto_finalize",
      }
    );
    updatedTask = finalizeResult.task;
  }

  return {
    task: updatedTask,
    flow: normalizeKuaishouCloudFlow(
      parseTaskContext(updatedTask).kuaishouCloudFulfillment
    ),
  };
}

async function markKuaishouCloudDispatchFailed(
  task: TaskRow,
  taskContext: JsonObject,
  flow: JsonObject,
  error: unknown,
  options: JsonObject = {}
) {
  const now = nowIso();
  const errorMessage = resolveErrorMessage(error);
  const errorCode = resolveErrorCode(error) || "kuaishou_cloud_dispatch_failed";
  const failureContext = resolveDispatchFailureContext(error);
  const stockResult = isPlainObject(failureContext.stockResult)
    ? (failureContext.stockResult as Partial<DispatchStockResult>)
    : null;
  const nextContext = {
    ...taskContext,
    kuaishouCloudFulfillment: {
      ...flow,
      dispatch: {
        ...flow.dispatch,
        status: "failed",
        failedAt: now,
        failedStage: String(failureContext.stage || "").trim(),
        errorCode,
        errorMessage,
        note: buildDispatchFailedMessage(errorMessage),
      },
      purchase: {
        ...flow.purchase,
        ...(stockResult
          ? {
            usedKnapsack: stockResult.usedKnapsack,
            purchaseTriggered: stockResult.purchaseTriggered,
            assetBefore: stockResult.assetBefore,
            assetAfter: stockResult.assetAfter,
            items: stockResult.items,
          }
          : {}),
      },
    },
  };

  await updateTask(task.id, {
    task_status: TASK_STATUS.MANUAL_REVIEW,
    user_action_status: "not_required",
    last_error: errorMessage,
    result_code: errorCode,
    result_message: buildDispatchFailedMessage(errorMessage),
    context_json: JSON.stringify(nextContext),
    updated_at: now,
  });

  await createTaskEvent(
    task.id,
    "kuaishou_cloud_dispatch_failed",
    {
      source: String(options.source || "system").trim() || "system",
      actor: options.actor,
      errorCode,
      errorMessage,
      failureContext,
    },
    now
  );
}

async function prepareStockAndDispatch({
  task,
  flow,
  cloudContext,
  deliveryItems,
}: {
  task: TaskRow;
  flow: JsonObject;
  cloudContext: JsonObject;
  deliveryItems: DispatchDeliveryItem[];
}) {
  const [knapsack, skuList] = await Promise.all([
    getCloudtentaclesKnapsack(cloudContext),
    listCloudtentaclesSku(cloudContext),
  ]);
  const skuItems = Array.isArray(skuList.items) ? skuList.items : [];
  const knapsackItems = Array.isArray(knapsack.items) ? knapsack.items : [];
  const stockItems = buildDispatchStockItems(deliveryItems, {
    skuItems,
    knapsackItems,
  });
  const missingItems = stockItems.filter((item) => item.purchasedCount > 0);

  let assetBefore = 0;
  let assetAfter = 0;
  let purchaseTriggered = false;

  if (missingItems.length > 0) {
    if (flow.purchase?.autoBuyEnabled === false) {
      throw createHttpError("背包中没有现成库存，且当前配置未开启自动购买", {
        statusCode: 409,
        errorCode: "kuaishou_cloud_auto_buy_disabled",
      });
    }

    const missingSku = missingItems.find((item) => !findCloudSkuItem(skuItems, item.cloudSkuId));
    if (missingSku) {
      throw createHttpError(`cloudtentacles 未找到 SKU ${missingSku.cloudSkuId}`, {
        statusCode: 404,
        errorCode: "kuaishou_cloud_sku_not_found",
      });
    }

    const asset = await getCloudtentaclesAsset(cloudContext);
    assetBefore = Number(asset.asset || 0) || 0;
    const targetPrice = missingItems.reduce((sum, item) => {
      const skuItem = findCloudSkuItem(skuItems, item.cloudSkuId);
      return sum + item.purchasedCount * Number(skuItem?.price || 0);
    }, 0);
    const requiredAsset = targetPrice + Number(flow.purchase?.minAssetReserve || 0);

    if (assetBefore < requiredAsset) {
      await notifyKuaishouCloudAssetNotEnough({
        task,
        flow,
        assetBefore,
        requiredAsset,
        skuName: missingItems
          .map((item) => item.cloudSkuName || `SKU ${item.cloudSkuId}`)
          .join("、"),
      });
      throw createHttpError(`余额不足，当前 ${assetBefore}，至少需要 ${requiredAsset}`, {
        statusCode: 409,
        errorCode: "kuaishou_cloud_asset_not_enough",
      });
    }

    for (const item of missingItems) {
      await createTaskEvent(
        task.id,
        "cloudtentacles_sku_buy_started",
        {
          source: "kuaishou_cloud_dispatch",
          cloudSkuId: item.cloudSkuId,
          cloudSkuName: item.cloudSkuName,
          count: item.purchasedCount,
          assetBefore,
        },
        nowIso()
      );

      try {
        const buyResult = await buyCloudtentaclesSku({
          ...cloudContext,
          id: item.cloudSkuId,
          count: item.purchasedCount,
        });
        await createTaskEvent(
          task.id,
          "cloudtentacles_sku_buy_succeeded",
          {
            source: "kuaishou_cloud_dispatch",
            cloudSkuId: item.cloudSkuId,
            cloudSkuName: item.cloudSkuName,
            count: item.purchasedCount,
            responseMessage: buyResult.responseMessage,
          },
          nowIso()
        );
      } catch (error) {
        await createTaskEvent(
          task.id,
          "cloudtentacles_sku_buy_failed",
          {
            source: "kuaishou_cloud_dispatch",
            cloudSkuId: item.cloudSkuId,
            cloudSkuName: item.cloudSkuName,
            count: item.purchasedCount,
            errorCode: resolveErrorCode(error),
            errorMessage: resolveErrorMessage(error),
          },
          nowIso()
        );
        throw enrichCloudtentaclesDispatchError(error, {
          stage: "purchase",
          stockResult: buildCurrentStockResult({
            stockItems,
            purchaseTriggered,
            assetBefore,
            assetAfter,
          }),
          item,
        });
      }
    }

    purchaseTriggered = true;
    const assetResult = await getCloudtentaclesAsset(cloudContext);
    assetAfter = Number(assetResult.asset || 0) || 0;
  }

  const dispatchResults: DispatchResultItem[] = [];
  for (const item of deliveryItems) {
    for (let index = 0; index < item.quantity; index += 1) {
      await createTaskEvent(
        task.id,
        "cloudtentacles_sku_use_started",
        {
          source: "kuaishou_cloud_dispatch",
          cloudSkuId: item.cloudSkuId,
          cloudSkuName: item.cloudSkuName,
          unitIndex: index + 1,
          quantity: item.quantity,
          vnId: flow.binding.vnId,
          vnPhoneMasked: maskPhone(flow.binding.vnPhone),
        },
        nowIso()
      );

      let dispatchResult: Awaited<ReturnType<typeof useCloudtentaclesSku>>;
      try {
        dispatchResult = await useCloudtentaclesSku({
          ...cloudContext,
          id: item.cloudSkuId,
          virtualNumberId: flow.binding.vnId,
          phone: flow.binding.vnPhone,
        });
      } catch (error) {
        await createTaskEvent(
          task.id,
          "cloudtentacles_sku_use_failed",
          {
            source: "kuaishou_cloud_dispatch",
            cloudSkuId: item.cloudSkuId,
            cloudSkuName: item.cloudSkuName,
            unitIndex: index + 1,
            quantity: item.quantity,
            vnId: flow.binding.vnId,
            vnPhoneMasked: maskPhone(flow.binding.vnPhone),
            errorCode: resolveErrorCode(error),
            errorMessage: resolveErrorMessage(error),
          },
          nowIso()
        );
        throw enrichCloudtentaclesDispatchError(error, {
          stage: "dispatch",
          stockResult: buildCurrentStockResult({
            stockItems,
            purchaseTriggered,
            assetBefore,
            assetAfter,
          }),
          item,
          unitIndex: index + 1,
          vnId: flow.binding.vnId,
          vnPhoneMasked: maskPhone(flow.binding.vnPhone),
        });
      }

      await createTaskEvent(
        task.id,
        "cloudtentacles_sku_use_succeeded",
        {
          source: "kuaishou_cloud_dispatch",
          cloudSkuId: item.cloudSkuId,
          cloudSkuName: item.cloudSkuName,
          unitIndex: index + 1,
          quantity: item.quantity,
          vnId: flow.binding.vnId,
          vnPhoneMasked: maskPhone(flow.binding.vnPhone),
          sendType: Number(dispatchResult.sendType || 0) || 0,
          note: String(dispatchResult.note || "").trim(),
          responseMessage: String(dispatchResult.responseMessage || "").trim(),
        },
        nowIso()
      );
      dispatchResults.push({
        cloudSkuId: item.cloudSkuId,
        cloudSkuName: item.cloudSkuName,
        unitIndex: index + 1,
        quantity: item.quantity,
        sendType: Number(dispatchResult.sendType || 0) || 0,
        note: String(dispatchResult.note || "").trim(),
        responseMessage: String(dispatchResult.responseMessage || "").trim(),
      });
    }
  }

  return {
    dispatchResults,
    stockResult: {
      usedKnapsack: stockItems.every((item) => item.purchasedCount <= 0),
      purchaseTriggered,
      assetBefore,
      assetAfter,
      items: stockItems,
    },
  };
}

function buildCurrentStockResult({
  stockItems,
  purchaseTriggered,
  assetBefore,
  assetAfter,
}: {
  stockItems: DispatchStockItem[];
  purchaseTriggered: boolean;
  assetBefore: number;
  assetAfter: number;
}): DispatchStockResult {
  return {
    usedKnapsack: stockItems.every((item) => item.purchasedCount <= 0),
    purchaseTriggered,
    assetBefore,
    assetAfter,
    items: stockItems,
  };
}

function enrichCloudtentaclesDispatchError(error: unknown, context: JsonObject) {
  const currentError = error instanceof Error
    ? (error as Error & { context?: unknown })
    : createHttpError(resolveErrorMessage(error), {
      statusCode: 500,
      errorCode: "kuaishou_cloud_dispatch_failed",
    }) as Error & { context?: unknown };
  const currentContext = isPlainObject(currentError.context) ? currentError.context : {};
  currentError.context = {
    ...currentContext,
    dispatchFailure: {
      ...(isPlainObject((currentContext as JsonObject).dispatchFailure)
        ? (currentContext as JsonObject).dispatchFailure
        : {}),
      ...context,
    },
  };

  return currentError;
}

function resolveDispatchFailureContext(error: unknown): JsonObject {
  if (!error || typeof error !== "object") {
    return {};
  }

  const context = (error as { context?: unknown }).context;
  if (!isPlainObject(context)) {
    return {};
  }

  const dispatchFailure = context.dispatchFailure;
  return isPlainObject(dispatchFailure) ? dispatchFailure : {};
}

function resolveErrorCode(error: unknown) {
  if (!error || typeof error !== "object") {
    return "";
  }

  return String((error as { errorCode?: unknown }).errorCode || "").trim();
}

function resolveErrorMessage(error: unknown) {
  return error instanceof Error ? error.message : String(error || "CloudTentacles 发货失败");
}

function buildDispatchFailedMessage(message: unknown) {
  const reason = String(message || "").trim() || "未知错误";
  return `CloudTentacles 发货失败：${reason}`;
}

function isPlainObject(value: unknown): value is JsonObject {
  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
}

function hasKuaishouIndustryVoucherContext(value: JsonObject): boolean {
  const voucher = isPlainObject(value.kuaishouIndustryVoucher)
    ? value.kuaishouIndustryVoucher
    : {};
  const voucherCode = String(voucher.voucherCode || voucher.eticketId || "").trim();
  const status = String(voucher.status || "UNUSED").trim().toUpperCase();
  const sendCallbackStatus = String(voucher.sendCallbackStatus || "success").trim().toLowerCase();
  return Boolean(voucherCode && status !== "DESTROYED" && sendCallbackStatus === "success");
}

export function buildDispatchStockItems(
  deliveryItems: DispatchDeliveryItem[],
  { skuItems = [], knapsackItems = [] }: { skuItems?: JsonObject[]; knapsackItems?: JsonObject[] } = {}
): DispatchStockItem[] {
  return deliveryItems.map((item) => {
    const knapsackItem = findCloudSkuItem(knapsackItems, item.cloudSkuId);
    const skuItem = findCloudSkuItem(skuItems, item.cloudSkuId);
    const knapsackCount = Math.max(0, Number(knapsackItem?.count || 0) || 0);

    return {
      ...item,
      cloudSkuName: item.cloudSkuName || String(skuItem?.name || knapsackItem?.name || "").trim(),
      requiredCount: item.quantity,
      knapsackCount,
      purchasedCount: Math.max(0, item.quantity - knapsackCount),
    };
  });
}

function findCloudSkuItem(items: JsonObject[], cloudSkuId: number) {
  return items.find((item) => Number(item.id || 0) === cloudSkuId) || null;
}

function resolveCloudSkuDispatchLockKeys(sourceKey: unknown, deliveryItems: DispatchDeliveryItem[]) {
  const normalizedSourceKey = String(sourceKey || "default").trim() || "default";
  return deliveryItems.map((item) => `${normalizedSourceKey}:${item.cloudSkuId}`);
}

async function withCloudSkuDispatchLocks<T>(keys: string[], callback: () => Promise<T>): Promise<T> {
  const normalizedKeys = [...new Set(keys.map((key) => String(key || "").trim()).filter(Boolean))].sort();

  async function run(index: number): Promise<T> {
    const key = normalizedKeys[index];
    if (!key) {
      return callback();
    }

    return withCloudSkuDispatchLock(key, () => run(index + 1));
  }

  return run(0);
}

async function withCloudSkuDispatchLock<T>(key: string, callback: () => Promise<T>): Promise<T> {
  const previous = cloudSkuDispatchLocks.get(key) || Promise.resolve();
  let release: () => void = () => {};
  const current = new Promise<void>((resolve) => {
    release = resolve;
  });
  const queued = previous.catch(() => {}).then(() => current);

  cloudSkuDispatchLocks.set(key, queued);

  await previous.catch(() => {});

  try {
    return await callback();
  } finally {
    release();
    if (cloudSkuDispatchLocks.get(key) === queued) {
      cloudSkuDispatchLocks.delete(key);
    }
  }
}

function resolveDispatchDeliveryItems(flow: JsonObject): DispatchDeliveryItem[] {
  const rawItems = Array.isArray(flow.deliveryItems) ? flow.deliveryItems : [];
  const items = rawItems
    .map((item: unknown) => {
      const source = item && typeof item === "object" ? item as JsonObject : {};
      const cloudSkuId = Number(source.cloudSkuId || source.skuId || 0) || 0;
      const quantity = Number(source.quantity || 1) || 1;
      if (!Number.isInteger(cloudSkuId) || cloudSkuId <= 0) {
        return null;
      }

      return {
        cloudSkuId,
        cloudSkuName: String(source.cloudSkuName || source.skuName || "").trim(),
        quantity: Number.isInteger(quantity) && quantity > 0 ? quantity : 1,
      };
    })
    .filter((item): item is DispatchDeliveryItem => Boolean(item));

  if (items.length > 0) {
    return items;
  }

  const fallbackSkuId = Number(flow?.binding?.skuId || 0) || 0;
  if (!fallbackSkuId) {
    return [];
  }

  return [
    {
      cloudSkuId: fallbackSkuId,
      cloudSkuName: String(flow?.binding?.skuName || "").trim(),
      quantity: 1,
    },
  ];
}

export async function returnKuaishouCloudFulfillmentTask(
  task: TaskRow,
  options: JsonObject = {}
) {
  if (!isKuaishouCloudTask(task)) {
    throw createHttpError("当前任务不是 kuaishou-lewan 履约任务", {
      statusCode: 409,
      errorCode: "kuaishou_cloud_task_invalid",
    });
  }

  const actor = normalizeActor(options.actor);
  const now = nowIso();
  const taskContext = parseTaskContext(task);
  const flow = normalizeKuaishouCloudFlow(taskContext.kuaishouCloudFulfillment);
  const cloudContext = resolvePersistedCloudtentaclesContextBySourceKeys([
    flow.binding.resolvedSourceKey,
    ...flow.binding.cloudSourceKeys,
  ]);

  if (!flow.binding.vnId || !flow.binding.vnKey) {
    throw createHttpError("当前任务缺少可退还的虚拟号信息", {
      statusCode: 409,
      errorCode: "kuaishou_cloud_missing_return_context",
    });
  }

  const taskStatus = normalizeTaskStatus(task.task_status);
  if (
    flow.returnNumber.status === "success" &&
    (taskStatus === TASK_STATUS.COMPLETED || taskStatus === TASK_STATUS.MANUAL_REVIEW)
  ) {
    return { task, flow };
  }

  await backCloudtentaclesVirtualNumber({
    ...cloudContext,
    key: flow.binding.vnKey,
    id: flow.binding.vnId,
  });

  const ticketCode = String(flow.ticket.code || "").trim();
  let consumeStatus = "pending";
  let consumeErrorMessage = "";
  let consumedAt = null;
  let nextTaskStatus: TaskStatus = TASK_STATUS.COMPLETED;
  let nextResultCode = "kuaishou_cloud_completed";
  const consumeAlreadyCompleted = flow.consume.status === "success";
  const hasIndustryVoucher = hasKuaishouIndustryVoucherContext(taskContext);
  const isIndustryTask = isIndustryEVoucherTask(task);
  const shouldConsumeIndustryVoucher = hasIndustryVoucher || isIndustryTask;
  let nextResultMessage = shouldConsumeIndustryVoucher
    ? "cloudtentacles 发货、退号并完成电子凭证核销"
    : "cloudtentacles 发货、退号并收口";
  let industryVoucherContextPatch: JsonObject | null = null;

  if (consumeAlreadyCompleted) {
    consumeStatus = "success";
    consumedAt = flow.consume.consumedAt || now;
  } else if (shouldConsumeIndustryVoucher) {
    const industryResult = hasIndustryVoucher
      ? await consumeKuaishouIndustryVouchersForTask(task, {
          source: String(options.source || "system_auto_finalize").trim() || "system_auto_finalize",
          token: String(taskContext.kuaishouIndustryVoucher?.token || "").trim(),
          consumeTime: Date.now(),
        })
      : { ok: true, consumed: [], failed: [] };

    if (industryResult.ok) {
      consumeStatus = "success";
      consumedAt = now;
      const consumedVoucher = industryResult.consumed[0] || null;
      if (consumedVoucher) {
        industryVoucherContextPatch = {
          oid: consumedVoucher.oid,
          token: consumedVoucher.token,
          eticketId: consumedVoucher.voucher_code,
          voucherCode: consumedVoucher.voucher_code,
          unitIndex: Number(consumedVoucher.unit_index || 0) || 0,
          status: "CONSUMED",
          validStartTime: Number(consumedVoucher.valid_start_time || 0) || 0,
          validEndTime: Number(consumedVoucher.valid_end_time || 0) || 0,
          consumedAt: now,
          consumeSerialNum: consumedVoucher.consume_serial_num || `CONSUME-${consumedVoucher.voucher_code}`,
        };
      }
    } else {
      consumeStatus = "failed";
      consumeErrorMessage =
        industryResult.failed[0]?.errorMessage || "电子凭证核销回调失败，请人工处理";
    }
  } else {
    consumeStatus = "skipped";
    consumeErrorMessage = "";
  }

  if (consumeStatus !== "success") {
    if (shouldConsumeIndustryVoucher) {
      nextTaskStatus = TASK_STATUS.MANUAL_REVIEW;
      nextResultCode = "kuaishou_cloud_consume_failed";
      nextResultMessage =
        consumeErrorMessage || "号码已退还，但电子凭证核销未完成，请人工处理";
    } else {
      nextResultCode = "kuaishou_cloud_completed_without_eticket_consume";
    }
  }

  const nextContext = {
    ...taskContext,
    ...(industryVoucherContextPatch
      ? {
          kuaishouIndustryVoucher: {
            ...(isPlainObject(taskContext.kuaishouIndustryVoucher)
              ? taskContext.kuaishouIndustryVoucher
              : {}),
            ...industryVoucherContextPatch,
          },
        }
      : {}),
    kuaishouCloudFulfillment: {
      ...flow,
      returnNumber: {
        ...flow.returnNumber,
        status: "success",
        returnedAt: now,
        returnedBy: actor,
      },
      consume: {
        ...flow.consume,
        status: consumeStatus,
        shopId: flow.consume.shopId,
        shopName: flow.consume.shopName,
        autoConsumeEnabled: flow.consume.autoConsumeEnabled === true,
        consumedAt,
        errorMessage: consumeErrorMessage,
      },
    },
  };

  const updatedTask = await updateTask(task.id, {
    task_status: nextTaskStatus,
    delivery_status: "delivered",
    result_code: nextResultCode,
    result_message: nextResultMessage,
    redeemed_at: consumeStatus === "failed" ? task.redeemed_at : now,
    last_error: consumeErrorMessage,
    context_json: JSON.stringify(nextContext),
    updated_at: now,
  });

  await createTaskEvent(
    task.id,
    "kuaishou_cloud_number_returned",
    {
      source: String(options.source || "system").trim() || "system",
      vnId: flow.binding.vnId,
      vnPhoneMasked: maskPhone(flow.binding.vnPhone),
      actor,
    },
    now
  );

  const consumeEventType = consumeAlreadyCompleted
    ? "kuaishou_cloud_consume_already_completed"
    : consumeStatus === "success"
      ? "kuaishou_cloud_consumed"
      : consumeStatus === "skipped"
        ? "kuaishou_cloud_consume_skipped"
        : "kuaishou_cloud_consume_failed";

  await createTaskEvent(
    task.id,
    consumeEventType,
    {
      source: String(options.source || "system").trim() || "system",
      ticketCodeMasked: maskCode(ticketCode),
      shopId: flow.consume.shopId,
      shopName: flow.consume.shopName,
      consumeStatus,
      consumeMode: shouldConsumeIndustryVoucher ? "industry_voucher" : "legacy_writeoff_disabled",
      errorMessage: consumeErrorMessage,
      actor,
    },
    now
  );

  return {
    task: updatedTask,
    flow: normalizeKuaishouCloudFlow(
      parseTaskContext(updatedTask).kuaishouCloudFulfillment
    ),
  };
}