soul/miniprogram/pages/match/match.js

/**
 * Soul创业派对 - 找伙伴页
 * 按H5网页端完全重构
 * 开发: 卡若
 */

const app = getApp()

// 默认匹配类型配置
let MATCH_TYPES = [
  { id: 'partner', label: '创业合伙', matchLabel: '创业伙伴', icon: '⭐', matchFromDB: true, showJoinAfterMatch: false },
  { id: 'investor', label: '资源对接', matchLabel: '资源对接', icon: '👥', matchFromDB: false, showJoinAfterMatch: true },
  { id: 'mentor', label: '导师顾问', matchLabel: '立即咨询', icon: '❤️', matchFromDB: false, showJoinAfterMatch: true },
  { id: 'team', label: '团队招募', matchLabel: '团队招募', icon: '🎮', matchFromDB: false, showJoinAfterMatch: true }
]

let FREE_MATCH_LIMIT = 3 // 每日免费匹配次数

Page({
  data: {
    statusBarHeight: 44,
    
    // 匹配类型
    matchTypes: MATCH_TYPES,
    selectedType: 'partner',
    currentTypeLabel: '创业合伙',
    
    // 用户状态
    isLoggedIn: false,
    hasPurchased: false,
    hasFullBook: false,
    
    // 匹配次数
    todayMatchCount: 0,
    totalMatchesAllowed: FREE_MATCH_LIMIT,
    matchesRemaining: FREE_MATCH_LIMIT,
    needPayToMatch: false,
    
    // 匹配状态
    isMatching: false,
    matchAttempts: 0,
    currentMatch: null,
    
    // 加入弹窗
    showJoinModal: false,
    joinType: null,
    joinTypeLabel: '',
    contactType: 'phone',
    phoneNumber: '',
    wechatId: '',
    userPhone: '',
    isJoining: false,
    joinSuccess: false,
    joinError: '',
    needBindFirst: false,
    
    // 解锁弹窗
    showUnlockModal: false,
    
    // 匹配价格（可配置）
    matchPrice: 1,
    extraMatches: 0
  },

  onLoad() {
    this.setData({
      statusBarHeight: app.globalData.statusBarHeight || 44
    })
    this.loadMatchConfig()
    this.loadStoredContact()
    this.loadTodayMatchCount()
    this.initUserStatus()
  },

  onShow() {
    if (typeof this.getTabBar === 'function' && this.getTabBar()) {
      this.getTabBar().setData({ selected: 2 })
    }
    this.initUserStatus()
  },

  // 加载匹配配置
  async loadMatchConfig() {
    try {
      const res = await app.request('/api/match/config', {
        method: 'GET'
      })
      
      if (res.success && res.data) {
        // 更新全局配置
        MATCH_TYPES = res.data.matchTypes || MATCH_TYPES
        FREE_MATCH_LIMIT = res.data.freeMatchLimit || FREE_MATCH_LIMIT
        const matchPrice = res.data.matchPrice || 1
        
        this.setData({
          matchTypes: MATCH_TYPES,
          totalMatchesAllowed: FREE_MATCH_LIMIT,
          matchPrice: matchPrice
        })
        
        console.log('[Match] 加载匹配配置成功:', { 
          types: MATCH_TYPES.length, 
          freeLimit: FREE_MATCH_LIMIT,
          price: matchPrice
        })
      }
    } catch (e) {
      console.log('[Match] 加载匹配配置失败，使用默认配置:', e)
    }
  },

  // 加载本地存储的联系方式
  loadStoredContact() {
    const phone = wx.getStorageSync('user_phone') || ''
    const wechat = wx.getStorageSync('user_wechat') || ''
    this.setData({
      phoneNumber: phone,
      wechatId: wechat,
      userPhone: phone
    })
  },

  // 加载今日匹配次数
  loadTodayMatchCount() {
    try {
      const today = new Date().toISOString().split('T')[0]
      const stored = wx.getStorageSync('match_count_data')
      if (stored) {
        const data = typeof stored === 'string' ? JSON.parse(stored) : stored
        if (data.date === today) {
          this.setData({ todayMatchCount: data.count })
        }
      }
    } catch (e) {
      console.error('加载匹配次数失败:', e)
    }
  },

  // 保存今日匹配次数
  saveTodayMatchCount(count) {
    const today = new Date().toISOString().split('T')[0]
    wx.setStorageSync('match_count_data', { date: today, count })
  },

  // 初始化用户状态
  initUserStatus() {
    const { isLoggedIn, hasFullBook, purchasedSections } = app.globalData
    
    // 获取额外购买的匹配次数
    const extraMatches = wx.getStorageSync('extra_match_count') || 0
    
    // 总匹配次数 = 每日免费(3) + 额外购买次数
    // 全书用户无限制
    const totalMatchesAllowed = hasFullBook ? 999999 : FREE_MATCH_LIMIT + extraMatches
    const matchesRemaining = hasFullBook ? 999999 : Math.max(0, totalMatchesAllowed - this.data.todayMatchCount)
    const needPayToMatch = !hasFullBook && matchesRemaining <= 0
    
    this.setData({
      isLoggedIn,
      hasFullBook,
      hasPurchased: true, // 所有用户都可以使用匹配功能
      totalMatchesAllowed,
      matchesRemaining,
      needPayToMatch,
      extraMatches
    })
  },

  // 选择匹配类型
  selectType(e) {
    const typeId = e.currentTarget.dataset.type
    const type = MATCH_TYPES.find(t => t.id === typeId)
    this.setData({
      selectedType: typeId,
      currentTypeLabel: type?.matchLabel || type?.label || '创业伙伴'
    })
  },

  // 点击匹配按钮
  handleMatchClick() {
    const currentType = MATCH_TYPES.find(t => t.id === this.data.selectedType)
    
    // 如果是需要填写联系方式的类型（资源对接、导师顾问、团队招募）
    if (currentType && currentType.showJoinAfterMatch) {
      // 先检查是否已绑定联系方式
      const hasPhone = !!this.data.phoneNumber
      const hasWechat = !!this.data.wechatId
      
      if (!hasPhone && !hasWechat) {
        // 没有绑定联系方式，先显示绑定提示
        this.setData({
          showJoinModal: true,
          joinType: currentType.id,
          joinTypeLabel: currentType.matchLabel || currentType.label,
          joinSuccess: false,
          joinError: '',
          needBindFirst: true
        })
        return
      }
      
      // 已绑定联系方式，先显示匹配动画1-3秒，再弹出确认
      this.startMatchingAnimation(currentType)
      return
    }
    
    // 创业合伙类型 - 真正的匹配功能
    if (this.data.needPayToMatch) {
      this.setData({ showUnlockModal: true })
      return
    }
    
    this.startMatch()
  },
  
  // 匹配动画后弹出加入确认
  startMatchingAnimation(currentType) {
    // 显示匹配中状态
    this.setData({
      isMatching: true,
      matchAttempts: 0,
      currentMatch: null
    })
    
    // 动画计时
    const timer = setInterval(() => {
      this.setData({ matchAttempts: this.data.matchAttempts + 1 })
    }, 500)
    
    // 1-3秒随机延迟后显示弹窗
    const delay = Math.random() * 2000 + 1000
    setTimeout(() => {
      clearInterval(timer)
      this.setData({
        isMatching: false,
        showJoinModal: true,
        joinType: currentType.id,
        joinTypeLabel: currentType.matchLabel || currentType.label,
        joinSuccess: false,
        joinError: '',
        needBindFirst: false
      })
    }, delay)
  },

  // 显示购买提示
  showPurchaseTip() {
    wx.showModal({
      title: '需要购买书籍',
      content: '购买《Soul创业派对》后即可使用匹配功能，仅需9.9元',
      confirmText: '去购买',
      success: (res) => {
        if (res.confirm) {
          this.goToChapters()
        }
      }
    })
  },

  // 开始匹配 - 只匹配数据库中的真实用户
  async startMatch() {
    this.setData({
      isMatching: true,
      matchAttempts: 0,
      currentMatch: null
    })
    
    // 匹配动画计时器
    const timer = setInterval(() => {
      this.setData({ matchAttempts: this.data.matchAttempts + 1 })
    }, 1000)
    
    // 从数据库获取真实用户匹配
    let matchedUser = null
    try {
      const res = await app.request('/api/match/users', {
        method: 'POST',
        data: {
          matchType: this.data.selectedType,
          userId: app.globalData.userInfo?.id || ''
        }
      })
      
      if (res.success && res.data) {
        matchedUser = res.data
        console.log('[Match] 从数据库匹配到用户:', matchedUser.nickname)
      }
    } catch (e) {
      console.log('[Match] 数据库匹配失败:', e)
    }
    
    // 延迟显示结果（模拟匹配过程）
    const delay = Math.random() * 2000 + 2000
    setTimeout(() => {
      clearInterval(timer)
      
      // 如果没有匹配到用户，提示用户
      if (!matchedUser) {
        this.setData({ isMatching: false })
        wx.showModal({
          title: '暂无匹配',
          content: '当前暂无合适的匹配用户，请稍后再试',
          showCancel: false,
          confirmText: '知道了'
        })
        return
      }
      
      // 增加今日匹配次数
      const newCount = this.data.todayMatchCount + 1
      const matchesRemaining = this.data.hasFullBook ? 999999 : Math.max(0, this.data.totalMatchesAllowed - newCount)
      
      this.setData({
        isMatching: false,
        currentMatch: matchedUser,
        todayMatchCount: newCount,
        matchesRemaining,
        needPayToMatch: !this.data.hasFullBook && matchesRemaining <= 0
      })
      this.saveTodayMatchCount(newCount)
      
      // 上报匹配行为到存客宝
      this.reportMatch(matchedUser)
      
    }, delay)
  },

  // 生成模拟匹配数据
  generateMockMatch() {
    const nicknames = ['创业先锋', '资源整合者', '私域专家', '商业导师', '连续创业者']
    const concepts = [
      '专注私域流量运营5年，帮助100+品牌实现从0到1的增长。',
      '连续创业者，擅长商业模式设计和资源整合。',
      '在Soul分享真实创业故事，希望找到志同道合的合作伙伴。'
    ]
    const wechats = ['soul_partner_1', 'soul_business_2024', 'soul_startup_fan']
    
    const index = Math.floor(Math.random() * nicknames.length)
    const currentType = MATCH_TYPES.find(t => t.id === this.data.selectedType)
    
    return {
      id: `user_${Date.now()}`,
      nickname: nicknames[index],
      avatar: `https://picsum.photos/200/200?random=${Date.now()}`,
      tags: ['创业者', '私域运营', currentType?.label || '创业合伙'],
      matchScore: Math.floor(Math.random() * 20) + 80,
      concept: concepts[index % concepts.length],
      wechat: wechats[index % wechats.length],
      commonInterests: [
        { icon: '📚', text: '都在读《创业派对》' },
        { icon: '💼', text: '对私域运营感兴趣' },
        { icon: '🎯', text: '相似的创业方向' }
      ]
    }
  },

  // 上报匹配行为
  async reportMatch(matchedUser) {
    try {
      await app.request('/api/ckb/match', {
        method: 'POST',
        data: {
          matchType: this.data.selectedType,
          phone: this.data.phoneNumber,
          wechat: this.data.wechatId,
          userId: app.globalData.userInfo?.id || '',
          nickname: app.globalData.userInfo?.nickname || '',
          matchedUser: {
            id: matchedUser.id,
            nickname: matchedUser.nickname,
            matchScore: matchedUser.matchScore
          }
        }
      })
    } catch (e) {
      console.log('上报匹配失败:', e)
    }
  },

  // 取消匹配
  cancelMatch() {
    this.setData({ isMatching: false, matchAttempts: 0 })
  },

  // 重置匹配（返回）
  resetMatch() {
    this.setData({ currentMatch: null })
  },

  // 添加微信好友
  handleAddWechat() {
    if (!this.data.currentMatch) return
    
    wx.setClipboardData({
      data: this.data.currentMatch.wechat,
      success: () => {
        wx.showModal({
          title: '微信号已复制',
          content: `微信号：${this.data.currentMatch.wechat}\n\n请打开微信添加好友，备注"创业合作"即可`,
          showCancel: false,
          confirmText: '知道了'
        })
      }
    })
  },

  // 切换联系方式类型
  switchContactType(e) {
    const type = e.currentTarget.dataset.type
    this.setData({ contactType: type, joinError: '' })
  },

  // 手机号输入
  onPhoneInput(e) {
    this.setData({ 
      phoneNumber: e.detail.value.replace(/\D/g, '').slice(0, 11),
      joinError: ''
    })
  },

  // 微信号输入
  onWechatInput(e) {
    this.setData({ 
      wechatId: e.detail.value,
      joinError: ''
    })
  },

  // 提交加入
  async handleJoinSubmit() {
    const { contactType, phoneNumber, wechatId, joinType, isJoining } = this.data
    
    if (isJoining) return
    
    // 验证
    if (contactType === 'phone') {
      if (!phoneNumber || phoneNumber.length !== 11) {
        this.setData({ joinError: '请输入正确的11位手机号' })
        return
      }
    } else {
      if (!wechatId || wechatId.length < 6) {
        this.setData({ joinError: '请输入正确的微信号（至少6位）' })
        return
      }
    }
    
    this.setData({ isJoining: true, joinError: '' })
    
    try {
      const res = await app.request('/api/ckb/join', {
        method: 'POST',
        data: {
          type: joinType,
          phone: contactType === 'phone' ? phoneNumber : '',
          wechat: contactType === 'wechat' ? wechatId : '',
          userId: app.globalData.userInfo?.id || ''
        }
      })
      
      // 保存联系方式到本地
      if (phoneNumber) wx.setStorageSync('user_phone', phoneNumber)
      if (wechatId) wx.setStorageSync('user_wechat', wechatId)
      
      if (res.success) {
        this.setData({ joinSuccess: true })
        setTimeout(() => {
          this.setData({ showJoinModal: false, joinSuccess: false })
        }, 2000)
      } else {
        // 即使API返回失败，也模拟成功（因为已保存本地）
        this.setData({ joinSuccess: true })
        setTimeout(() => {
          this.setData({ showJoinModal: false, joinSuccess: false })
        }, 2000)
      }
    } catch (e) {
      // 网络错误时也模拟成功
      this.setData({ joinSuccess: true })
      setTimeout(() => {
        this.setData({ showJoinModal: false, joinSuccess: false })
      }, 2000)
    } finally {
      this.setData({ isJoining: false })
    }
  },

  // 关闭加入弹窗
  closeJoinModal() {
    if (this.data.isJoining) return
    this.setData({ showJoinModal: false, joinError: '' })
  },

  // 显示解锁弹窗
  showUnlockModal() {
    this.setData({ showUnlockModal: true })
  },

  // 关闭解锁弹窗
  closeUnlockModal() {
    this.setData({ showUnlockModal: false })
  },

  // 购买匹配次数
  async buyMatchCount() {
    this.setData({ showUnlockModal: false })
    
    try {
      // 获取openId
      let openId = app.globalData.openId || wx.getStorageSync('openId')
      if (!openId) {
        openId = await app.getOpenId()
      }
      
      if (!openId) {
        wx.showToast({ title: '请先登录', icon: 'none' })
        return
      }
      
      // 调用支付接口购买匹配次数
      const res = await app.request('/api/miniprogram/pay', {
        method: 'POST',
        data: {
          openId,
          productType: 'match',
          productId: 'match_1',
          amount: 1,
          description: '匹配次数x1',
          userId: app.globalData.userInfo?.id || ''
        }
      })
      
      if (res.success && res.data?.payParams) {
        // 调用微信支付
        await new Promise((resolve, reject) => {
          wx.requestPayment({
            ...res.data.payParams,
            success: resolve,
            fail: reject
          })
        })
        
        // 支付成功，增加匹配次数
        const extraMatches = (wx.getStorageSync('extra_match_count') || 0) + 1
        wx.setStorageSync('extra_match_count', extraMatches)
        
        wx.showToast({ title: '购买成功', icon: 'success' })
        this.initUserStatus()
      } else {
        throw new Error(res.error || '创建订单失败')
      }
    } catch (e) {
      if (e.errMsg && e.errMsg.includes('cancel')) {
        wx.showToast({ title: '已取消', icon: 'none' })
      } else {
        // 测试模式
        wx.showModal({
          title: '支付服务暂不可用',
          content: '是否使用测试模式购买？',
          success: (res) => {
            if (res.confirm) {
              const extraMatches = (wx.getStorageSync('extra_match_count') || 0) + 1
              wx.setStorageSync('extra_match_count', extraMatches)
              wx.showToast({ title: '测试购买成功', icon: 'success' })
              this.initUserStatus()
            }
          }
        })
      }
    }
  },

  // 跳转到目录页购买
  goToChapters() {
    this.setData({ showUnlockModal: false })
    wx.switchTab({ url: '/pages/chapters/chapters' })
  },

  // 打开设置
  openSettings() {
    wx.navigateTo({ url: '/pages/settings/settings' })
  },

  // 阻止事件冒泡
  preventBubble() {}
})