/**
 * 支付相关组合式函数
 */

import { ref } from 'vue'
import { createOrder, pay, getPayResult } from '../api/order.js'

/**
 * 支付相关功能
 * @returns {Object}
 */
export function usePayment() {
  const loading = ref(false)
  const paymentError = ref('')
  
  /**
   * 创建订单
   * @param {Object} params - 订单参数
   * @param {number} params.orderType - 订单类型：1测评订单 2规划订单
   * @param {number} params.productId - 产品ID
   * @param {Object} [params.assessmentInfo] - 测评信息（测评订单时必填）
   * @param {Object} [params.plannerInfo] - 规划预约信息（规划订单时必填）
   * @param {number} [params.inviteCodeId] - 邀请码ID
   * @returns {Promise<Object|null>}
   */
  async function handleCreateOrder(params) {
    loading.value = true
    paymentError.value = ''
    
    try {
      const res = await createOrder(params)
      if (res.code === 0 && res.data) {
        return res.data
      }
      paymentError.value = res.message || '创建订单失败'
      return null
    } catch (e) {
      paymentError.value = e.message || '创建订单失败'
      return null
    } finally {
      loading.value = false
    }
  }
  
  /**
   * 发起微信支付
   * @param {number} orderId - 订单ID
   * @returns {Promise<boolean>}
   */
  async function handlePay(orderId) {
    loading.value = true
    paymentError.value = ''
    
    try {
      // 获取支付参数
      const res = await pay(orderId)
      if (res.code !== 0 || !res.data) {
        paymentError.value = res.message || '获取支付参数失败'
        return false
      }
      
      const payParams = res.data
      
      // 调用微信支付
      return new Promise((resolve) => {
        uni.requestPayment({
          provider: 'wxpay',
          timeStamp: payParams.timeStamp,
          nonceStr: payParams.nonceStr,
          package: payParams.package,
          signType: payParams.signType || 'MD5',
          paySign: payParams.paySign,
          success: () => {
            resolve(true)
          },
          fail: (err) => {
            if (err.errMsg && err.errMsg.includes('cancel')) {
              paymentError.value = '支付已取消'
            } else {
              paymentError.value = '支付失败'
            }
            resolve(false)
          }
        })
      })
    } catch (e) {
      paymentError.value = e.message || '支付失败'
      return false
    } finally {
      loading.value = false
    }
  }
  
  /**
   * 查询支付结果
   * @param {number} orderId - 订单ID
   * @param {number} [maxRetry=3] - 最大重试次数
   * @param {number} [interval=1000] - 重试间隔（毫秒）
   * @returns {Promise<Object|null>}
   */
  async function checkPayResult(orderId, maxRetry = 3, interval = 1000) {
    for (let i = 0; i < maxRetry; i++) {
      try {
        const res = await getPayResult(orderId)
        if (res.code === 0 && res.data) {
          if (res.data.paid) {
            return res.data
          }
        }
        
        // 等待后重试
        if (i < maxRetry - 1) {
          await new Promise(resolve => setTimeout(resolve, interval))
        }
      } catch (e) {
        console.error('查询支付结果失败:', e)
      }
    }
    
    return null
  }
  
  /**
   * 完整支付流程
   * @param {Object} orderParams - 订单参数
   * @returns {Promise<{success: boolean, orderId?: number, error?: string}>}
   */
  async function processPayment(orderParams) {
    // 1. 创建订单
    const order = await handleCreateOrder(orderParams)
    if (!order) {
      return { success: false, error: paymentError.value }
    }
    
    // 2. 发起支付
    const paySuccess = await handlePay(order.orderId)
    if (!paySuccess) {
      return { success: false, orderId: order.orderId, error: paymentError.value }
    }
    
    // 3. 查询支付结果
    const result = await checkPayResult(order.orderId)
    if (result && result.paid) {
      return { success: true, orderId: order.orderId, assessmentRecordId: order.assessmentRecordId }
    }
    
    return { success: false, orderId: order.orderId, error: '支付结果确认失败' }
  }
  
  return {
    loading,
    paymentError,
    createOrder: handleCreateOrder,
    pay: handlePay,
    checkPayResult,
    processPayment
  }
}

export default usePayment