import { findLatestOrderByPlatformOrderId } from '../../repositories/order-repo.js'
import { listTasksByOrderId } from '../../repositories/task-repo.js'
import { buildClaimUrl } from '../claim/claim-service.js'
import { ensureTaskClaimLink } from '../fulfillment/kuaishou-cloud/index.js'
import { logIntegration } from '../../utils/logger.js'
import {
  OPEN_91_MANUAL_FAILED_STATUS,
  OPEN_91_PENDING_CONFIG_STATUS,
} from '../platforms/ninetyone/order-service.js'
import {
  assertOpen91Config,
  OPEN_91_DEFAULT_FAIL_CODE,
  OPEN_91_PLATFORM,
  OPEN_91_PROVIDER,
} from './config.js'
import {
  assertOpen91QueryPayload,
  assertOpen91Timestamp,
  normalizeOpen91QueryPayload,
} from './payload.js'
import { assertOpen91Signature, buildOpen91Cards } from './crypto.js'
import {
  buildOpen91CardItem,
  buildOpen91OrderCost,
  buildOpen91OutTradeNo,
  buildOpen91SuccessResponse,
  resolveOpen91QueryState,
} from './response.js'
import type { OrderRow } from '../../types/repository/rows.js'

type JsonObject = Record<string, any>

export async function queryOpen91Order(payload: JsonObject = {}, { requestId = '' } = {}) {
  const config = assertOpen91Config()
  const normalized = normalizeOpen91QueryPayload(payload)

  assertOpen91QueryPayload(normalized, config)
  assertOpen91Timestamp(normalized.timestamp, config.timestampToleranceSeconds)
  assertOpen91Signature(payload, config)

  const order = await findLatestOrderByPlatformOrderId({
    provider: OPEN_91_PROVIDER,
    platform: OPEN_91_PLATFORM,
    platformOrderId: normalized.orderNo,
  })

  if (!order) {
    return buildOpen91SuccessResponse({
      orderNo: normalized.orderNo,
      outTradeNo: '',
      orderStatus: 30,
      failCode: OPEN_91_DEFAULT_FAIL_CODE,
      failReason: '订单不存在',
    })
  }

  const tasks = await listTasksByOrderId(order.id)

  if (tasks.length === 0) {
    if (String(order.order_status || '').trim() === OPEN_91_PENDING_CONFIG_STATUS) {
      return buildOpen91SuccessResponse({
        orderNo: normalized.orderNo,
        outTradeNo: buildOpen91OutTradeNo(order),
        orderStatus: 10,
        failCode: 0,
        failReason: '',
        orderCost: buildOpen91OrderCost(0),
        cards: '',
      })
    }

    if (String(order.order_status || '').trim() === OPEN_91_MANUAL_FAILED_STATUS) {
      return buildOpen91SuccessResponse({
        orderNo: normalized.orderNo,
        outTradeNo: buildOpen91OutTradeNo(order),
        orderStatus: 30,
        failCode: OPEN_91_DEFAULT_FAIL_CODE,
        failReason: resolveOpen91OrderFailReason(order) || '商家手动标记无法履约',
      })
    }
  }

  const cardItems = []
  const readyTaskIds = []

  for (const task of tasks) {
    let claimUrl = ''
    let expireTime: unknown = task.primary_claim_expires_at || task.claim_expires_at || ''
    const primaryToken = String(task.primary_claim_token || task.claim_token || '').trim()

    if (primaryToken) {
      claimUrl = buildClaimUrl(primaryToken)
    } else if (String(task.executor_key || '').trim() === 'kuaishou_ct_assisted') {
      try {
        const ensured = await ensureTaskClaimLink(task)
        claimUrl = String(ensured.claimUrl || '').trim()
        expireTime = ensured.expiredAt || expireTime
      } catch {
        claimUrl = ''
      }
    }

    if (!claimUrl) {
      continue
    }

    readyTaskIds.push(Number(task.id))
    cardItems.push(buildOpen91CardItem({
      claimUrl,
      expireTime,
    }))
  }

  const queryState = resolveOpen91QueryState({
    tasks,
    readyTaskIds,
  })

  logIntegration('[open-91/query]', '91卡券订单查询已处理', {
    requestId,
    orderNo: normalized.orderNo,
    orderId: order.id,
    taskCount: tasks.length,
    readyTaskCount: readyTaskIds.length,
    orderStatus: queryState.orderStatus,
  })

  if (queryState.orderStatus === 30) {
    return buildOpen91SuccessResponse({
      orderNo: normalized.orderNo,
      outTradeNo: buildOpen91OutTradeNo(order),
      orderStatus: 30,
      failCode: queryState.failCode,
      failReason: queryState.failReason,
    })
  }

  if (queryState.orderStatus === 10) {
    return buildOpen91SuccessResponse({
      orderNo: normalized.orderNo,
      outTradeNo: buildOpen91OutTradeNo(order),
      orderStatus: 10,
      failCode: 0,
      failReason: '',
      orderCost: buildOpen91OrderCost(0),
      cards: '',
    })
  }

  const outTradeNo = buildOpen91OutTradeNo(order)
  const encryptedCards = buildOpen91Cards(cardItems, config)
  const responseData = {
    orderNo: normalized.orderNo,
    outTradeNo,
    orderStatus: 20,
    failCode: 0,
    failReason: '',
    orderCost: buildOpen91OrderCost(0),
    cards: encryptedCards,
  }

  logIntegration('[open-91/query]', '91卡券订单查询返回 cards 已生成', {
    requestId,
    orderNo: normalized.orderNo,
    orderId: order.id,
    outTradeNo,
    cardsEncoding: config.cardsEncoding,
    cardsPlain: cardItems,
    cardsEncrypted: encryptedCards,
    responseData,
  })

  return buildOpen91SuccessResponse(responseData)
}

function resolveOpen91OrderFailReason(order: OrderRow) {
  const payload = parseJsonObject(order?.raw_payload_json)
  return String(payload.manualFailedReason || '').trim()
}

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

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

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