// pages/registration/registration.js
const app = getApp()
const { graphqlRequest } = require('../../lib/utils')
const { uploadFile, chooseAndUploadImage } = require('../../lib/upload')
const cosUtil = require('../../lib/cosUtil')

Page({
  data: {
    activityId: '',
    activity: null,
    loading: false,
    
    // 表单数据
    formData: {
      name: '',
      phone: '',
      gender: null,
      birthDate: '',
      education: '',
      regionId: null,
      projectName: '',
      description: '',
      introduction: '',
      avatarUrl: '',
      avatarMediaId: ''
    },
    
    // 表单验证
    errors: {},
    
    // 选择器数据
    genderOptions: ['男', '女'],
    genderIndex: -1,
    educationOptions: ['高中', '大专', '本科', '硕士', '博士'],
    educationIndex: -1,
    regions: [],
    regionIndex: -1,
    today: new Date().toISOString().split('T')[0], // 今天的日期，用于限制生日选择
    isSubmitting: false,
    
    // 头像上传状态
    avatarUploading: false,
    avatarUploadProgress: 0,
    
    // 本地头像临时文件
    localAvatarPath: '', // 本地选择的头像文件路径，提交时才上传
    
    // 附件上传
    attachments: [], // 附件列表
    maxAttachments: 8, // 最大附件数量
    
    // 文件类型配置
    fileTypeConfig: {
      image: {
        extensions: ['jpg', 'jpeg', 'png', 'gif', 'webp'],
        maxSize: 10 * 1024 * 1024, // 10MB
        icon: '🖼️'
      },
      video: {
        extensions: ['mp4', 'avi', 'mov', 'wmv', 'flv', '3gp'],
        maxSize: 200 * 1024 * 1024, // 200MB
        icon: '🎬'
      },
      pdf: {
        extensions: ['pdf'],
        maxSize: 50 * 1024 * 1024, // 50MB
        icon: '📄'
      },
      word: {
        extensions: ['doc', 'docx'],
        maxSize: 50 * 1024 * 1024, // 50MB
        icon: '📝'
      },
      excel: {
        extensions: ['xls', 'xlsx'],
        maxSize: 50 * 1024 * 1024, // 50MB
        icon: '📊'
      },
      ppt: {
        extensions: ['ppt', 'pptx'],
        maxSize: 50 * 1024 * 1024, // 50MB
        icon: '📽️'
      },
      text: {
        extensions: ['txt'],
        maxSize: 10 * 1024 * 1024, // 10MB
        icon: '📄'
      }
    }
  },

  onLoad(options) {
    console.log('📥 registration页面接收到的参数:', options)
    if (options.activityId || options.id) {
      const activityId = options.activityId || options.id
      console.log('🎯 设置activityId:', activityId)
      this.setData({
        activityId: activityId
      })
      this.loadActivityInfo()
    } else {
      console.log('❌ 没有接收到activityId参数')
    }
    
    // 从全局数据获取用户信息预填充
    this.prefillUserInfo()
    
    // 加载区域数据
    this.loadRegions()
  },

  // 加载活动信息
  async loadActivityInfo() {
    try {
      this.setData({ loading: true })
      
      const query = `
        query GetActivity($id: ID!) {
          activity(id: $id) {
            id
            name
            description
            signupDeadline
            matchTime
            address
            playerMax
            state
          }
        }
      `
      
      console.log('🔍 查询活动信息，activityId:', this.data.activityId)
      const result = await graphqlRequest(query, { id: this.data.activityId })
      console.log('📊 GraphQL查询结果:', result)
      
      if (result && result.activity) {
        console.log('✅ 活动信息加载成功:', result.activity)
        this.setData({
          activity: result.activity
        })
        
        // 根据活动要求初始化表单
        this.initFormByRequirements()
      } else {
        // 活动不存在或查询失败
        wx.showModal({
          title: '提示',
          content: '活动信息不存在或已失效',
          showCancel: false,
          success: () => {
            wx.navigateBack()
          }
        })
      }
    } catch (error) {
      console.error('加载活动信息失败:', error)
      wx.showModal({
        title: '网络错误',
        content: '加载活动信息失败，请检查网络连接',
        confirmText: '重试',
        cancelText: '返回',
        success: (res) => {
          if (res.confirm) {
            this.loadActivityInfo()
          } else {
            wx.navigateBack()
          }
        }
      })
    } finally {
      this.setData({ loading: false })
    }
  },

  // 加载区域数据
  async loadRegions() {
    try {
      console.log('🔄 开始加载区域数据...')
      const query = `
        query {
          allRegions {
            id
            name
            pid
            leafFlag
          }
        }
      `
      
      const result = await graphqlRequest(query)
      console.log('📊 区域数据查询结果:', result)
      
      if (result && result.allRegions) {
        console.log(`📍 总区域数量: ${result.allRegions.length}`)
        // 只显示leaf_flag=true的区域（叶子节点区域）
        const leafRegions = result.allRegions.filter(region => region.leafFlag === true)
        console.log(`🍃 叶子节点区域数量: ${leafRegions.length}`)
        console.log('🍃 叶子节点区域列表:', leafRegions.map(r => `${r.name}(${r.id})`))
        
        this.setData({
          regions: leafRegions
        })
        console.log('✅ 区域数据设置完成')
      } else {
        console.warn('⚠️ 未获取到区域数据')
      }
    } catch (error) {
      console.error('❌ 加载区域数据失败:', error)
      // 区域数据加载失败不影响主要功能，只记录错误
    }
  },

  // 预填充用户信息
  prefillUserInfo() {
    const userInfo = app.globalData.userInfo
    if (userInfo) {
      this.setData({
        'formData.name': userInfo.name || '',
        'formData.phone': userInfo.phone || '',
        'formData.email': userInfo.email || ''
      })
    }
  },

  // 根据活动要求初始化表单
  initFormByRequirements() {
    const { activity } = this.data
    if (!activity) return
    
    // 基本表单验证规则初始化
    const errors = {}
    this.setData({ errors })
  },

  // 表单输入处理
  onInputChange(e) {
    const { field } = e.currentTarget.dataset
    const { value } = e.detail
    
    this.setData({
      [`formData.${field}`]: value
    })
    
    // 清除该字段的错误状态
    if (this.data.errors[field]) {
      this.setData({
        [`errors.${field}`]: false
      })
    }
    
    // 实时验证
    this.validateField(field, value)
  },

  // 性别选择
  onGenderChange(e) {
    const index = e.detail.value
    this.setData({
      genderIndex: index,
      'formData.gender': index
    })
  },

  // 学历选择
  onEducationChange(e) {
    const index = e.detail.value
    this.setData({
      educationIndex: index,
      'formData.education': this.data.educationOptions[index]
    })
  },

  // 区域选择
  onRegionChange(e) {
    const index = e.detail.value
    const region = this.data.regions[index]
    this.setData({
      regionIndex: index,
      'formData.regionId': region ? region.id : null
    })
  },

  // 生日选择
  onBirthDateChange(e) {
    const birthDate = e.detail.value
    this.setData({
      'formData.birthDate': birthDate
    })
    
    // 清除该字段的错误状态
    if (this.data.errors.birthDate) {
      this.setData({
        'errors.birthDate': false
      })
    }
  },

  // 获取手机号授权
  async onGetPhoneNumber(e) {
    console.log('获取手机号授权:', e.detail)
    
    if (e.detail.errMsg === 'getPhoneNumber:ok') {
      try {
        console.log('=== 手机号获取调试信息 ===')
        console.log('微信返回的code:', e.detail.code)
        console.log('code长度:', e.detail.code ? e.detail.code.length : 0)
        
        let phoneNumber = null
        
        // 使用新版API直接通过code获取手机号
        if (e.detail.code) {
          console.log('🚀 使用新版API获取手机号')
          console.log('code:', e.detail.code)
          
          // 调用新版API直接通过code获取手机号
          const response = await graphqlRequest(`
            mutation GetPhoneNumberByCode($code: String!) {
              getPhoneNumberByCode(code: $code) {
                phoneNumber
                purePhoneNumber
                countryCode
              }
            }
          `, {
            code: e.detail.code
          })
          
          if (response.getPhoneNumberByCode) {
            phoneNumber = response.getPhoneNumberByCode.phoneNumber
            console.log('✅ 新版API获取手机号成功:', phoneNumber)
          } else {
            throw new Error('获取手机号失败，请重试')
          }
        } else {
          throw new Error('缺少获取手机号所需的code参数')
        }
        
        if (phoneNumber) {
          this.setData({
            'formData.phone': phoneNumber
          })
          
          // 清除手机号错误状态
          if (this.data.errors.phone) {
            this.setData({
              'errors.phone': false
            })
          }
          
          console.log('✅ 手机号获取成功:', phoneNumber)
          wx.showToast({
            title: '手机号获取成功',
            icon: 'success'
          })
        } else {
          throw new Error('获取手机号失败')
        }
      } catch (error) {
        console.error('获取手机号失败:', error)
        wx.showToast({
          title: '获取手机号失败',
          icon: 'error'
        })
      }
    } else {
      console.log('用户拒绝授权手机号')
      wx.showToast({
        title: '需要手机号授权',
        icon: 'none'
      })
    }
  },



  // 清除手机号
  onClearPhone() {
    this.setData({
      'formData.phone': ''
    })
  },

  // 选择头像（只做本地预览，不立即上传）
  async onChooseAvatar() {
    try {
      const res = await wx.chooseMedia({
        count: 1,
        mediaType: ['image'],
        sourceType: ['album', 'camera'],
        sizeType: ['compressed']
      })

      if (res.tempFiles && res.tempFiles.length > 0) {
        const tempFile = res.tempFiles[0]
        
        // 检查文件类型 - 使用文件扩展名判断，因为iOS下fileType属性可能不存在
        const getFileExtension = (filePath) => {
          return filePath.split('.').pop().toLowerCase()
        }
        
        const fileExtension = getFileExtension(tempFile.tempFilePath)
        const allowedExtensions = ['jpg', 'jpeg', 'png', 'gif', 'webp']
        
        if (!allowedExtensions.includes(fileExtension)) {
          wx.showToast({
            title: '请选择JPG、PNG或WebP格式的图片',
            icon: 'none',
            duration: 3000
          })
          return
        }
        
        // 检查文件大小（限制为5MB）
        if (tempFile.size > 5 * 1024 * 1024) {
          wx.showToast({
            title: '图片大小不能超过5MB',
            icon: 'none',
            duration: 3000
          })
          return
        }

        // 检查图片尺寸
        try {
          const imageInfo = await wx.getImageInfo({
            src: tempFile.tempFilePath
          })
          
          // 建议最小尺寸为200x200
          if (imageInfo.width < 200 || imageInfo.height < 200) {
            const result = await wx.showModal({
              title: '图片尺寸提示',
              content: '建议上传尺寸不小于200x200的图片，当前图片尺寸为' + imageInfo.width + 'x' + imageInfo.height + '，是否继续？',
              confirmText: '继续',
              cancelText: '重新选择'
            })
            
            if (!result.confirm) {
              return
            }
          }
        } catch (imageError) {
          console.warn('获取图片信息失败:', imageError)
        }

        // 只保存本地路径，用于预览，不立即上传
        this.setData({
          localAvatarPath: tempFile.tempFilePath
        })

        // 清除错误状态
        if (this.data.errors.avatar) {
          this.setData({
            'errors.avatar': false
          })
        }

        wx.showToast({
          title: '头像选择成功，提交时将自动上传',
          icon: 'success',
          duration: 2000
        })
      }
    } catch (error) {
      console.error('头像选择失败:', error)
      
      wx.showToast({
        title: '头像选择失败，请重试',
        icon: 'none',
        duration: 3000
      })
    }
  },

  // 删除头像
  async onDeleteAvatar() {
    try {
      const hasLocalAvatar = !!this.data.localAvatarPath
      const hasUploadedAvatar = !!this.data.formData.avatarUrl
      
      const result = await wx.showModal({
        title: '删除头像',
        content: hasLocalAvatar ? '确定要删除当前选择的头像吗？' : '确定要删除当前头像吗？删除后需要重新选择。',
        confirmText: '删除',
        confirmColor: '#ff4757',
        cancelText: '取消'
      })

      if (result.confirm) {
        // 如果是本地头像，直接清空
        if (hasLocalAvatar) {
          this.setData({
            localAvatarPath: ''
          })
          
          wx.showToast({
            title: '头像已删除',
            icon: 'success'
          })
          return
        }

        // 如果是已上传的头像，需要删除服务器文件
        if (hasUploadedAvatar) {
          // 显示删除进度
          wx.showLoading({
            title: '正在删除...',
            mask: true
          })

          // 如果有COS文件，尝试删除
          if (this.data.formData.avatarMediaId) {
            try {
              await cosUtil.deleteFile(this.data.formData.avatarMediaId)
            } catch (deleteError) {
              console.warn('删除COS文件失败:', deleteError)
              // 即使删除COS文件失败，也继续清空本地数据
            }
          }

          // 清空头像数据
          this.setData({
            'formData.avatarUrl': '',
            'formData.avatarMediaId': ''
          })

          wx.hideLoading()
          wx.showToast({
            title: '头像已删除',
            icon: 'success'
          })
        }
      }
    } catch (error) {
      console.error('删除头像失败:', error)
      wx.hideLoading()
      wx.showToast({
        title: '删除失败，请重试',
        icon: 'none',
        duration: 2000
      })
    }
  },

  // 选择附件
  async onChooseAttachment() {
    try {
      if (this.data.attachments.length >= this.data.maxAttachments) {
        wx.showToast({
          title: `最多只能上传${this.data.maxAttachments}个附件`,
          icon: 'none'
        })
        return
      }

      const result = await wx.chooseMessageFile({
        count: this.data.maxAttachments - this.data.attachments.length,
        type: 'all'
      })

      if (result.tempFiles && result.tempFiles.length > 0) {
        for (const file of result.tempFiles) {
          await this.uploadAttachment(file)
        }
      }
    } catch (error) {
      console.error('选择附件失败:', error)
      if (error.errMsg && !error.errMsg.includes('cancel')) {
        wx.showToast({
          title: '选择文件失败',
          icon: 'none'
        })
      }
    }
  },

  // 添加附件（不立即上传）
  async uploadAttachment(file) {
    try {
      // 验证文件
      const validation = this.validateAttachment(file)
      if (!validation.valid) {
        wx.showToast({
          title: validation.message,
          icon: 'none',
          duration: 3000
        })
        return
      }

      // 创建附件对象（只保存本地信息，不上传）
      const attachment = {
        id: Date.now() + Math.random(),
        name: file.name,
        size: file.size,
        sizeText: this.formatFileSize(file.size),
        type: validation.type,
        path: file.path,
        uploading: false,
        uploaded: false,
        progress: 0,
        error: null,
        url: '',
        mediaId: ''
      }

      // 添加到附件列表
      const attachments = [...this.data.attachments, attachment]
      this.setData({ attachments })

      wx.showToast({
        title: '文件已添加',
        icon: 'success'
      })

    } catch (error) {
      console.error('处理附件失败:', error)
      wx.showToast({
        title: '处理失败',
        icon: 'error'
      })
    }
  },

  // 上传所有附件
  async uploadAllAttachments() {
    const attachments = this.data.attachments.filter(attachment => !attachment.uploaded)
    
    if (attachments.length === 0) {
      return // 没有需要上传的附件
    }
    
    wx.showLoading({
      title: '正在上传附件...',
      mask: true
    })
    
    try {
      for (let i = 0; i < attachments.length; i++) {
        const attachment = attachments[i]
        
        // 更新上传状态
        const updatedAttachments = this.data.attachments.map(item => {
          if (item.id === attachment.id) {
            return { ...item, uploading: true, progress: 0 }
          }
          return item
        })
        this.setData({ attachments: updatedAttachments })
        
        try {
          const uploadResult = await cosUtil.uploadFile(attachment.path, {
            onProgress: (progress) => {
              // 更新上传进度
              const progressAttachments = this.data.attachments.map(item => {
                if (item.id === attachment.id) {
                  return { ...item, progress: Math.round(progress.percent) }
                }
                return item
              })
              this.setData({ attachments: progressAttachments })
            }
          })
          
          // 上传成功
          const successAttachments = this.data.attachments.map(item => {
            if (item.id === attachment.id) {
              return {
                ...item,
                uploading: false,
                uploaded: true,
                progress: 100,
                url: uploadResult.url,
                mediaId: uploadResult.key,
                error: null
              }
            }
            return item
          })
          this.setData({ attachments: successAttachments })
          
        } catch (uploadError) {
          console.error('上传附件失败:', uploadError)
          
          // 更新错误状态
          const errorAttachments = this.data.attachments.map(item => {
            if (item.id === attachment.id) {
              return {
                ...item,
                uploading: false,
                uploaded: false,
                error: '上传失败'
              }
            }
            return item
          })
          this.setData({ attachments: errorAttachments })
          
          throw new Error(`附件 ${attachment.name} 上传失败`)
        }
      }
      
    } finally {
      wx.hideLoading()
    }
  },

  // 删除附件
  async onDeleteAttachment(e) {
    try {
      const index = e.currentTarget.dataset.index
      const attachment = this.data.attachments[index]

      const result = await wx.showModal({
        title: '删除附件',
        content: `确定要删除"${attachment.name}"吗？`,
        confirmText: '删除',
        confirmColor: '#ff4757',
        cancelText: '取消'
      })

      if (result.confirm) {
        wx.showLoading({
          title: '正在删除...',
          mask: true
        })

        // 如果有COS文件，尝试删除
        if (attachment.mediaId) {
          try {
            await cosUtil.deleteFile(attachment.mediaId)
          } catch (deleteError) {
            console.warn('删除COS文件失败:', deleteError)
          }
        }

        // 从列表中移除
        const attachments = this.data.attachments.filter((_, i) => i !== index)
        this.setData({ attachments })

        wx.hideLoading()
        wx.showToast({
          title: '删除成功',
          icon: 'success'
        })
      }
    } catch (error) {
      console.error('删除附件失败:', error)
      wx.hideLoading()
      wx.showToast({
        title: '删除失败',
        icon: 'error'
      })
    }
  },

  // 验证附件
  validateAttachment(file) {
    const fileName = file.name.toLowerCase()
    const fileExtension = fileName.split('.').pop()
    const fileSize = file.size

    // 查找文件类型
    let fileType = 'other'
    let config = null

    for (const [type, typeConfig] of Object.entries(this.data.fileTypeConfig)) {
      if (typeConfig.extensions.includes(fileExtension)) {
        fileType = type
        config = typeConfig
        break
      }
    }

    if (!config) {
      return {
        valid: false,
        message: `不支持的文件格式：${fileExtension.toUpperCase()}`
      }
    }

    // 检查文件大小
    if (fileSize > config.maxSize) {
      return {
        valid: false,
        message: `文件过大，${fileType === 'video' ? '视频' : fileType === 'image' ? '图片' : '文档'}文件不能超过${this.formatFileSize(config.maxSize)}`
      }
    }

    return {
      valid: true,
      type: fileType,
      config: config
    }
  },

  // 格式化文件大小
  formatFileSize(bytes) {
    if (bytes === 0) return '0 B'
    const k = 1024
    const sizes = ['B', 'KB', 'MB', 'GB']
    const i = Math.floor(Math.log(bytes) / Math.log(k))
    return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i]
  },

  // 字段验证
  validateField(field, value) {
    let isValid = true
    let errorMsg = ''
    
    switch (field) {
      case 'phone':
        const phoneReg = /^1[3-9]\d{9}$/
        if (value && !phoneReg.test(value)) {
          isValid = false
          errorMsg = '请输入正确的手机号'
        }
        break
      case 'avatar':
        // 如果活动要求头像，则验证头像是否已上传
        if (this.data.activity && this.data.activity.requireAvatar) {
          if (!this.data.formData.avatarUrl || !this.data.formData.avatarMediaId) {
            isValid = false
            errorMsg = '请上传头像'
          }
        }
        break
      case 'email':
        const emailReg = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
        if (value && !emailReg.test(value)) {
          isValid = false
          errorMsg = '请输入正确的邮箱地址'
        }
        break
      case 'idCard':
        const idCardReg = /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/
        if (value && !idCardReg.test(value)) {
          isValid = false
          errorMsg = '请输入正确的身份证号'
        }
        break
    }
    
    if (!isValid) {
      this.setData({
        [`errors.${field}`]: errorMsg
      })
    }
    
    return isValid
  },



  // 表单验证
  validateForm() {
    const { formData } = this.data;
    const errors = {};

    // 必填字段验证
    if (!formData.name.trim()) {
      errors.name = '请输入姓名';
    }

    if (!formData.phone.trim()) {
      errors.phone = '请输入手机号';
    } else if (!/^1[3-9]\d{9}$/.test(formData.phone)) {
      errors.phone = '请输入正确的手机号';
    }

    if (formData.gender === null) {
      errors.gender = '请选择性别';
    }

    // 区域验证（可选）
    // 暂时不强制要求区域选择
    
    // 头像验证（可选）
    // 暂时不强制要求头像上传

    if (!formData.projectName.trim()) {
      errors.projectName = '请输入项目名称';
    }

    if (!formData.description.trim()) {
      errors.description = '请输入项目描述';
    }

    this.setData({ errors });
    return Object.keys(errors).length === 0;
  },

  // 提交前上传头像
  async uploadAvatarBeforeSubmit() {
    if (!this.data.localAvatarPath) {
      return
    }

    try {
      // 显示上传进度
      this.setData({
        avatarUploading: true,
        avatarUploadProgress: 0
      })

      // 上传到COS
      const uploadResult = await cosUtil.uploadAvatar(this.data.localAvatarPath, {
        onProgress: (progress) => {
          this.setData({
            avatarUploadProgress: Math.round(progress.percent)
          })
        }
      })

      // 上传成功，更新表单数据
      this.setData({
        'formData.avatarUrl': uploadResult.url,
        'formData.avatarMediaId': uploadResult.key,
        localAvatarPath: '', // 清空本地路径
        avatarUploading: false,
        avatarUploadProgress: 0
      })

      console.log('头像上传成功:', uploadResult)

    } catch (error) {
      this.setData({
        avatarUploading: false,
        avatarUploadProgress: 0
      })
      
      console.error('头像上传失败:', error)
      
      // 根据错误类型显示不同的提示
      let errorMessage = '头像上传失败'
      if (error.message) {
        if (error.message.includes('网络')) {
          errorMessage = '网络连接失败，请检查网络后重试'
        } else if (error.message.includes('权限')) {
          errorMessage = '上传权限不足，请联系管理员'
        } else if (error.message.includes('空间')) {
          errorMessage = '存储空间不足，请稍后重试'
        }
      }
      
      throw new Error(errorMessage)
    }
  },

  async onSubmit() {
    if (this.data.isSubmitting) return
    
    // 表单验证
    if (!this.validateForm()) {
      wx.showToast({
        title: '请检查表单信息',
        icon: 'none'
      })
      return
    }
    
    this.setData({ isSubmitting: true })
    
    try {
      const { formData } = this.data
      
      // 使用页面参数中的activityId，而不是从activity对象中获取
      const activityId = this.data.activityId
      
      // 准备提交数据（不包含文件）
      const submitData = {
        activityId,
        playerInfo: {
          name: formData.name,
          phone: formData.phone,
          gender: formData.gender,
          birthDate: formData.birthDate,
          education: formData.education,
          introduction: formData.introduction,
          avatarMediaId: null // 先不传头像
        },
        regionId: formData.regionId,
        projectName: formData.projectName,
        description: formData.description
      }
      
      // 第一步：先提交注册数据到后台，获得注册ID
      const result = await this.submitRegistration(submitData)
      
      if (result.success && result.registrationId) {
        // 第二步：使用返回的ID信息上传头像和附件
        await this.uploadFilesAfterRegistration({
          registrationId: result.registrationId,
          playerId: result.playerId,
          userId: result.userId,
          activityPlayerId: result.activityPlayerId
        })
        
        wx.showToast({
          title: '报名成功',
          icon: 'success'
        })
        
        setTimeout(() => {
          wx.navigateBack()
        }, 1500)
      } else {
        throw new Error(result.message || '提交失败')
      }
      
    } catch (error) {
      console.error('提交失败:', error)
      wx.showToast({
        title: error.message || '提交失败，请重试',
        icon: 'none'
      })
    } finally {
      this.setData({ isSubmitting: false })
    }
  },

  // 提交报名数据到后端（不包含文件）
  async submitRegistration(submitData) {
    const mutation = `
      mutation SubmitActivityRegistration($input: ActivityRegistrationInput!) {
        submitActivityRegistration(input: $input) {
          success
          message
          registrationId
          playerId
          userId
          activityPlayerId
        }
      }
    `;

    const input = {
      activityId: parseInt(submitData.activityId),
      playerInfo: {
        name: submitData.playerInfo.name,
        phone: submitData.playerInfo.phone,
        gender: submitData.playerInfo.gender || 0,
        birthDate: submitData.playerInfo.birthDate || null,
        education: submitData.playerInfo.education || '',
        introduction: submitData.playerInfo.introduction || '',
        avatarMediaId: null // 先不传头像
      },
      regionId: submitData.regionId || null,
      projectName: submitData.projectName || '',
      description: submitData.description || '',
      attachmentMediaIds: [] // 先不传附件
    };

    const result = await graphqlRequest(mutation, { input });
    
    if (result && result.submitActivityRegistration) {
      return result.submitActivityRegistration;
    } else {
      throw new Error('提交失败');
    }
  },

  // 注册成功后上传文件
  async uploadFilesAfterRegistration(idInfo) {
    try {
      // 上传头像（如果有）
      if (this.data.localAvatarPath) {
        await this.uploadAvatarWithRegistrationId(idInfo)
      }
      
      // 上传附件（如果有）
      if (this.data.attachments.length > 0) {
        await this.uploadAttachmentsWithRegistrationId(idInfo)
      }
    } catch (error) {
      console.error('文件上传失败:', error)
      // 文件上传失败不影响注册成功，只是提示用户
      wx.showToast({
        title: '文件上传失败，但报名已成功',
        icon: 'none',
        duration: 3000
      })
    }
  },

  // 使用注册ID上传头像
  async uploadAvatarWithRegistrationId(idInfo) {
    try {
      this.setData({
        avatarUploading: true,
        avatarUploadProgress: 0
      })

      // 第一步：上传到COS
      const uploadResult = await cosUtil.uploadAvatar(this.data.localAvatarPath, 'avatar.jpg', (progress) => {
        this.setData({
          avatarUploadProgress: Math.round(progress.percent)
        })
      })

      // 第二步：保存媒体记录到数据库
      await this.saveMediaRecord({
        targetType: 7, // USER_AVATAR
        targetId: idInfo.userId,
        url: uploadResult.url,
        fileName: uploadResult.fileName || 'avatar.jpg',
        fileSize: uploadResult.fileSize,
        mediaType: 1 // 图片
      })

      this.setData({
        avatarUploading: false,
        avatarUploadProgress: 0
      })

      console.log('头像上传成功:', uploadResult)
    } catch (error) {
      this.setData({
        avatarUploading: false,
        avatarUploadProgress: 0
      })
      console.error('头像上传失败:', error)
      throw error
    }
  },

  // 使用注册ID上传附件
  async uploadAttachmentsWithRegistrationId(idInfo) {
    for (let i = 0; i < this.data.attachments.length; i++) {
      const attachment = this.data.attachments[i]
      if (!attachment.uploaded && attachment.localPath) {
        try {
          // 第一步：上传到COS
          const uploadResult = await cosUtil.uploadFile(attachment.localPath, 'attachment', attachment.name || 'attachment', (progress) => {
            this.setData({
              [`attachments[${i}].uploadProgress`]: Math.round(progress.percent)
            })
          })

          // 第二步：保存媒体记录到数据库
          await this.saveMediaRecord({
            targetType: 5, // ACTIVITY_PLAYER_SUBMISSION
            targetId: idInfo.activityPlayerId,
            url: uploadResult.url,
            fileName: uploadResult.fileName || attachment.name,
            fileSize: uploadResult.fileSize,
            mediaType: this.getMediaType(attachment.name) // 根据文件扩展名判断类型
          })

          // 更新附件状态
          this.setData({
            [`attachments[${i}].uploaded`]: true,
            [`attachments[${i}].mediaId`]: uploadResult.key,
            [`attachments[${i}].url`]: uploadResult.url,
            [`attachments[${i}].uploadProgress`]: 0
          })

          console.log(`附件${i + 1}上传成功:`, uploadResult)
        } catch (error) {
          console.error(`附件${i + 1}上传失败:`, error)
          throw error
        }
      }
    }
  },

  // 保存媒体记录到数据库
  async saveMediaRecord(mediaData) {
    const mutation = `
      mutation SaveMedia($input: MediaInput!) {
        saveMedia(input: $input) {
          id
          url
          fileName
        }
      }
    `
    
    const variables = {
      input: {
        targetType: mediaData.targetType,
        targetId: mediaData.targetId,
        url: mediaData.url,
        fileName: mediaData.fileName,
        fileSize: mediaData.fileSize,
        mediaType: mediaData.mediaType
      }
    }
    
    try {
      const result = await app.graphqlRequest(mutation, variables)
      console.log('媒体记录保存成功:', result.saveMedia)
      return result.saveMedia
    } catch (error) {
      console.error('媒体记录保存失败:', error)
      throw error
    }
  },

  // 根据文件名获取媒体类型
  getMediaType(fileName) {
    if (!fileName) return 1 // 默认图片
    
    const ext = fileName.toLowerCase().split('.').pop()
    const imageExts = ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp']
    const videoExts = ['mp4', 'avi', 'mov', 'wmv', 'flv', 'mkv']
    const audioExts = ['mp3', 'wav', 'aac', 'flac', 'ogg']
    const docExts = ['pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'txt']
    
    if (imageExts.includes(ext)) return 1 // 图片
    if (videoExts.includes(ext)) return 2 // 视频
    if (audioExts.includes(ext)) return 3 // 音频
    if (docExts.includes(ext)) return 4 // 文档
    
    return 5 // 其他
  }

})