import { createTask, listTasksByOrderId, updateTask } from '../../repositories/task-repo.js'
import { getFulfillmentProfileByKey } from '../../repositories/fulfillment-profile-repo.js'
import { createTaskClaimToken } from '../claim/claim-service.js'
import { notifyTaskAutoManualReview } from '../notification/domain-notifications.js'
import { nowIso } from '../../utils/time.js'
import { randomId } from '../../utils/random.js'
import type { OrderItemRow, OrderRow, TaskRow } from '../../types/repository/rows.js'

type JsonObject = Record<string, unknown>

type ClaimTokenLike = {
  token: string
  expired_at: string
  [key: string]: unknown
}

type FulfillmentBindingLike = {
  id: number
  profile_id?: number
  profile_key?: string
  profile_name?: string
  name?: string
  executor_key?: string
  requires_claim?: boolean
  auto_dispatch?: boolean
  config_json?: string | JsonObject
  [key: string]: unknown
}

type DeliveryTaskRow = TaskRow & {
  skuCode?: string
  skuName?: string
}

type DeliveryTaskDeps = {
  createTask?: typeof createTask
  listTasksByOrderId?: typeof listTasksByOrderId
  updateTask?: typeof updateTask
  getFulfillmentProfileByKey?: (profileKey: string) => Promise<FulfillmentBindingLike | null>
  createTaskClaimToken?: (taskId: number | string) => Promise<ClaimTokenLike>
  notifyTaskAutoManualReview?: (payload: {
    task: unknown
    reason: string
    source: string
  }) => Promise<unknown> | unknown
  nowIso?: () => string
  randomId?: (prefix?: string) => string
}

type RuntimeDeliveryTaskDeps = Required<Pick<
  DeliveryTaskDeps,
  'updateTask'
  | 'createTaskClaimToken'
  | 'notifyTaskAutoManualReview'
  | 'nowIso'
>>

type TaskContext = {
  [key: string]: unknown
}

export async function syncDeliveryTasksForOrder(
  order: OrderRow,
  orderItems: OrderItemRow[],
): Promise<TaskRow[]> {
  return syncDeliveryTasksForOrderWithDeps(order, orderItems)
}

export async function syncDeliveryTasksForOrderWithDeps(
  order: OrderRow,
  orderItems: OrderItemRow[],
  deps: DeliveryTaskDeps = {},
): Promise<TaskRow[]> {
  const {
    createTask: createDeliveryTask = createTask,
    listTasksByOrderId: listTasks = listTasksByOrderId,
    updateTask: updateDeliveryTask = updateTask,
    getFulfillmentProfileByKey: getProfileByKey = getFulfillmentProfileByKey,
    createTaskClaimToken: createClaimToken = createTaskClaimToken,
    notifyTaskAutoManualReview: notifyManualReview = notifyTaskAutoManualReview,
    nowIso: getNowIso = nowIso,
    randomId: createRandomId = randomId,
  } = deps

  const runtimeDeps: RuntimeDeliveryTaskDeps = {
    updateTask: updateDeliveryTask,
    createTaskClaimToken: createClaimToken,
    notifyTaskAutoManualReview: notifyManualReview,
    nowIso: getNowIso,
  }

  const existingTasks = await listTasks(order.id)

  if (existingTasks.length > 0) {
    if (order.pay_status !== 'paid') {
      return existingTasks
    }

    const itemMap = new Map(orderItems.map((item) => [item.id, item]))
    const preparedTasks = await Promise.all(existingTasks.map((task) => preparePaidTask({
      ...task,
      skuCode: itemMap.get(task.order_item_id)?.sku_code || '',
      skuName: itemMap.get(task.order_item_id)?.sku_name || '',
    }, runtimeDeps)))
    return preparedTasks.filter(isTaskRow)
  }

  const tasks: DeliveryTaskRow[] = []

  for (const item of orderItems) {
    const profile = await resolveDynamicCloudtentaclesProfile(item, getProfileByKey)

    if (!profile) {
      continue
    }
    const itemSnapshot = parseJsonObject(item.item_snapshot_json)
    const quantity = Math.max(1, Number(item.quantity || 1))
    const fulfillmentConfig = parseJsonObject(profile.config_json)
    const cloudtentaclesConfig = parseJsonObject(fulfillmentConfig.cloudtentacles)
    const kuaishouConsumeConfig = parseJsonObject(fulfillmentConfig.kuaishouConsume)
    const kuaishouShopConfig = parseJsonObject(fulfillmentConfig.kuaishouShop)
    const deliveryItems = normalizeCloudDeliveryItems(cloudtentaclesConfig)
    const primaryDeliveryItem = deliveryItems[0] || {
      cloudSkuId: Number(cloudtentaclesConfig.skuId || 0) || 0,
      cloudSkuName: String(cloudtentaclesConfig.skuName || '').trim(),
      quantity: 1,
    }

    for (let index = 0; index < quantity; index += 1) {
      const createdAt = getNowIso()
      const initialStatus = order.pay_status === 'paid'
        ? resolvePaidTaskStatus(profile)
        : 'pending_payment'

      const task = await createDeliveryTask({
        orderId: order.id,
        orderItemId: item.id,
        unitIndex: index + 1,
        provider: order.provider,
        platform: order.platform,
        shopId: order.shop_id,
        shopName: order.shop_name,
        platformOrderId: order.platform_order_id,
        taskNo: createRandomId('DT'),
        profileId: Number(profile.profile_id || profile.id),
        executorKey: String(profile.executor_key || 'manual_dispatch'),
        taskStatus: initialStatus,
        deliveryStatus: 'pending',
        resultCode: '',
        resultMessage: '',
        claimToken: '',
        claimExpiresAt: null,
        automationMode: profile.auto_dispatch ? 'automatic' : 'manual',
        requiresClaim: Boolean(profile.requires_claim),
        userActionStatus: profile.requires_claim ? 'pending_claim' : 'not_required',
        attemptCount: 0,
        lastError: '',
        contextJson: JSON.stringify({
          profileKey: String(profile.profile_key || ''),
          profileName: String(profile.profile_name || profile.name || ''),
          skuCode: item.sku_code,
          skuName: item.sku_name,
          kuaishouCloudFulfillment: isKuaishouCloudExecutor(profile.executor_key)
            ? {
              flowType: 'kuaishou_cloud_fulfillment',
              configId: String(fulfillmentConfig.configId || '').trim(),
              internalSkuCode: item.sku_code,
              internalSkuName: item.sku_name,
              deliveryItems,
              ticket: {
                code: '',
                status: 'pending',
                capturedAt: null,
                capturedBy: null,
                verifiedAt: null,
                oid: '',
                formToken: '',
                leftCount: 0,
                goodsTitle: '',
              },
              binding: {
                prepareStatus: 'pending',
                cloudSourceKeys: normalizeStringArray(cloudtentaclesConfig.cloudSourceKeys),
                resolvedSourceKey: String(cloudtentaclesConfig.resolvedSourceKey || '').trim(),
                skuId: primaryDeliveryItem.cloudSkuId,
                skuName: primaryDeliveryItem.cloudSkuName,
                vnKey: '1',
                vnId: 0,
                vnPhone: '',
                bindUrl: '',
                bindPreparedAt: null,
                bindExpiresAt: null,
                bindProbeAt: null,
                bindProbeStatus: '',
                bindProbeMessage: '',
              },
              role: {
                status: 'pending',
                name: '',
                rid: '',
                refreshedAt: null,
                errorMessage: '',
                rawInfo: null,
              },
              purchase: {
                autoBuyEnabled: cloudtentaclesConfig.autoBuyEnabled !== false,
                minAssetReserve: Number(cloudtentaclesConfig.minAssetReserve || 0) || 0,
                usedKnapsack: false,
                purchaseTriggered: false,
                assetBefore: 0,
                assetAfter: 0,
                purchaseAt: null,
              },
              dispatch: {
                status: 'pending',
                dispatchAt: null,
                dispatchBy: null,
                sendType: 0,
                note: '',
              },
              returnNumber: {
                status: 'pending',
                returnedAt: null,
                returnedBy: null,
                autoReturnEnabled: cloudtentaclesConfig.autoReturnNumberAfterDispatch === true,
              },
              consume: {
                status: 'pending',
                shopId: String(kuaishouConsumeConfig.shopId || kuaishouShopConfig.shopId || itemSnapshot.shopId || order.shop_id || '').trim(),
                shopName: String(kuaishouConsumeConfig.shopName || kuaishouShopConfig.kshopName || itemSnapshot.shopName || order.shop_name || '').trim(),
                autoConsumeEnabled: kuaishouConsumeConfig.autoConsumeAfterDispatch === true,
                consumedAt: null,
                errorMessage: '',
              },
              notes: String(fulfillmentConfig.notes || '').trim(),
            }
            : null,
        }),
        createdAt,
        updatedAt: createdAt,
      })

      if (task) {
        tasks.push({
          ...task,
          skuCode: item.sku_code,
          skuName: item.sku_name,
        })
      }
    }
  }

  if (order.pay_status !== 'paid') {
    return tasks
  }

  const preparedTasks = await Promise.all(tasks.map((task) => preparePaidTask(task, runtimeDeps)))
  return preparedTasks.filter(isTaskRow)
}

async function preparePaidTask(
  task: DeliveryTaskRow,
  deps: Partial<RuntimeDeliveryTaskDeps> = {},
): Promise<TaskRow | DeliveryTaskRow | null> {
  const {
    updateTask: updateDeliveryTask = updateTask,
    createTaskClaimToken: createClaimToken = createTaskClaimToken,
    notifyTaskAutoManualReview: notifyManualReview = notifyTaskAutoManualReview,
    nowIso: getNowIso = nowIso,
  } = deps

  const now = getNowIso()

  if (['link_generated', 'claimed', 'role_confirmed', 'redeeming', 'redeemed', 'closed'].includes(task.task_status)) {
    return task
  }

  if (isKuaishouCloudExecutor(task.executor_key)) {
    if ([
      'pending_binding_prepare',
      'waiting_binding',
      'dispatched_pending_return',
      'completed',
      'manual_review',
      'failed',
    ].includes(String(task.task_status || '').trim())) {
      if (!task.primary_claim_token_id && !String(task.claim_token || '').trim()) {
        const claimToken = await createClaimToken(task.id)
        return updateDeliveryTask(task.id, {
          claim_token: claimToken.token,
          claim_expires_at: claimToken.expired_at,
          user_action_status: 'pending_claim',
          updated_at: now,
        })
      }

      return task
    }

    const claimToken = await createClaimToken(task.id)

    return updateDeliveryTask(task.id, {
      task_status: 'pending_binding_prepare',
      claim_token: claimToken.token,
      claim_expires_at: claimToken.expired_at,
      user_action_status: 'pending_claim',
      last_error: task.last_error || '领取链接已生成，等待客户提交核销码',
      updated_at: now,
    })
  }

  if (!task.requires_claim || String(task.executor_key || '').trim() === 'manual_dispatch') {
    const lastError = task.last_error || '当前任务需要人工履约处理'
    const updatedTask = await updateDeliveryTask(task.id, {
      task_status: 'manual_review',
      user_action_status: 'not_required',
      last_error: lastError,
      updated_at: now,
    })
    await notifyManualReview({
      task: updatedTask || task,
      reason: lastError,
      source: 'manual_dispatch_profile',
    })
    return updatedTask
  }

  return task
}

function resolvePaidTaskStatus(profile: FulfillmentBindingLike | null | undefined): string {
  if (Boolean(profile?.requires_claim)) {
    return 'paid'
  }

  if (isKuaishouCloudExecutor(profile?.executor_key)) {
    return 'pending_binding_prepare'
  }

  if (String(profile?.executor_key || '').trim() === 'manual_dispatch') {
    return 'manual_review'
  }

  return 'paid'
}

function parseTaskContext(task: { context_json?: unknown } | null | undefined): TaskContext {
  const value = task?.context_json

  if (!value) {
    return {}
  }

  if (typeof value === 'object') {
    return value as TaskContext
  }

  try {
    const parsed = JSON.parse(String(value || '{}'))
    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed as TaskContext : {}
  } catch {
    return {}
  }
}

function parseJsonObject(value: unknown): JsonObject {
  if (!value) {
    return {}
  }

  if (typeof value === 'object' && !Array.isArray(value)) {
    return value as JsonObject
  }

  try {
    const parsed = JSON.parse(String(value || '{}'))
    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed as JsonObject : {}
  } catch {
    return {}
  }
}

async function resolveDynamicCloudtentaclesProfile(
  item: OrderItemRow,
  getProfileByKey: (profileKey: string) => Promise<FulfillmentBindingLike | null>,
): Promise<FulfillmentBindingLike | null> {
  const snapshot = parseJsonObject(item.item_snapshot_json)
  const cloudtentacles = parseJsonObject(snapshot.cloudtentacles)
  const cloudSourceKeys = normalizeStringArray(cloudtentacles.cloudSourceKeys)
  const deliveryItems = normalizeCloudDeliveryItems({
    deliveryItems: cloudtentacles.deliveryItems,
    skuId: cloudtentacles.cloudSkuId,
    skuName: cloudtentacles.cloudSkuName || item.sku_name,
  })
  const primaryDeliveryItem = deliveryItems[0] || {
    cloudSkuId: 0,
    cloudSkuName: '',
    quantity: 1,
  }

  if (!primaryDeliveryItem.cloudSkuId || !primaryDeliveryItem.cloudSkuName || cloudSourceKeys.length === 0) {
    return null
  }

  const profile = await getProfileByKey('kuaishou_ct_assisted')
  if (!profile) {
    return null
  }

  return {
    ...profile,
    profile_id: Number(profile.id || profile.profile_id || 0),
    profile_key: 'kuaishou_ct_assisted',
    profile_name: String(profile.profile_name || profile.name || '快手 cloud 履约').trim(),
    executor_key: 'kuaishou_ct_assisted',
    requires_claim: false,
    auto_dispatch: false,
    config_json: {
      flowType: 'kuaishou_cloud_fulfillment',
      configId: `${String(cloudtentacles.matchMode || 'cloudtentacles_name').trim()}:${String(cloudtentacles.normalizedProductName || primaryDeliveryItem.cloudSkuId).trim()}`,
      cloudtentacles: {
        cloudSourceKeys,
        skuId: primaryDeliveryItem.cloudSkuId,
        skuName: primaryDeliveryItem.cloudSkuName,
        resolvedSourceKey: String(cloudtentacles.resolvedSourceKey || '').trim(),
        deliveryItems,
        vnKey: '1',
        autoBuyEnabled: true,
        minAssetReserve: 0,
        autoReturnNumberAfterDispatch: true,
      },
      kuaishouConsume: {
        shopId: String(snapshot.shopId || '').trim(),
        shopName: String(snapshot.shopName || '').trim(),
        autoConsumeAfterDispatch: false,
      },
      notes: cloudtentacles.matchMode === 'cloudtentacles_override'
        ? '91卡券商品名命中 cloudtentacles 覆盖规则'
        : '91卡券商品名自动匹配 cloudtentacles 商品',
    },
  }
}

function normalizeStringArray(value: unknown): string[] {
  if (!Array.isArray(value)) {
    return []
  }

  return Array.from(
    new Set(value.map((item) => String(item || '').trim()).filter(Boolean)),
  )
}

function normalizeCloudDeliveryItems(value: JsonObject): Array<{
  cloudSkuId: number
  cloudSkuName: string
  quantity: number
}> {
  const rawItems = Array.isArray(value.deliveryItems) ? value.deliveryItems : []
  const items = rawItems
    .map((item) => normalizeCloudDeliveryItem(item))
    .filter((item): item is { cloudSkuId: number; cloudSkuName: string; quantity: number } => Boolean(item))

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

  const cloudSkuId = Number(value.skuId || 0) || 0
  if (!cloudSkuId) {
    return []
  }

  return [{
    cloudSkuId,
    cloudSkuName: String(value.skuName || '').trim(),
    quantity: 1,
  }]
}

function normalizeCloudDeliveryItem(value: unknown) {
  const source = value && typeof value === 'object' && !Array.isArray(value)
    ? value as JsonObject
    : {}
  const cloudSkuId = Number(source.cloudSkuId || source.skuId || 0) || 0
  if (!Number.isInteger(cloudSkuId) || cloudSkuId <= 0) {
    return null
  }

  const quantity = Number(source.quantity || 1) || 1
  return {
    cloudSkuId,
    cloudSkuName: String(source.cloudSkuName || source.skuName || '').trim(),
    quantity: Number.isInteger(quantity) && quantity > 0 ? quantity : 1,
  }
}

function mergeCloudDeliveryItems(
  items: Array<{ cloudSkuId: number; cloudSkuName: string; quantity: number }>,
) {
  const merged = new Map<number, { cloudSkuId: number; cloudSkuName: string; quantity: number }>()

  for (const item of items) {
    const existing = merged.get(item.cloudSkuId)
    if (existing) {
      existing.quantity += item.quantity
      existing.cloudSkuName = existing.cloudSkuName || item.cloudSkuName
      continue
    }

    merged.set(item.cloudSkuId, { ...item })
  }

  return Array.from(merged.values())
}

function isTaskRow(task: TaskRow | DeliveryTaskRow | null | undefined): task is TaskRow {
  return Boolean(task && Number(task.id || 0) > 0)
}

function isKuaishouCloudExecutor(value: unknown): boolean {
  return String(value || '').trim() === 'kuaishou_ct_assisted'
}