// pages/profile/index.js
Page({
  // 分享给朋友/群聊
  onShareAppMessage() {
    return {
      title: '鸡蛋贸易平台 - 个人中心，查看我的信息',
      path: '/pages/profile/index',
      imageUrl: '/images/你有好蛋.png'
    }
  },

  // 分享到朋友圈
  onShareTimeline() {
    return {
      title: '鸡蛋贸易平台 - 个人中心，查看我的信息',
      query: '',
      imageUrl: '/images/你有好蛋.png'
    }
  },

  data: {
    userInfo: {},
    userType: '',
    userTags: [],
    needPhoneAuth: false, // 是否需要重新授权手机号
    locationInfo: '', // 位置信息
    hasLocationAuth: false // 是否已经授权位置
  },

  onLoad() {
    this.loadUserInfo();
    this.checkLocationAuth();
  },

  onShow() {
    this.loadUserInfo();
    this.checkLocationAuth();
    // 更新自定义tabBar状态
    if (typeof this.getTabBar === 'function' && this.getTabBar()) {
      this.getTabBar().setData({
        selected: 4
      });
    }
    // 更新全局tab状态
    const app = getApp();
    app.updateCurrentTab('profile');
  },

  // 加载用户信息
  loadUserInfo() {
    console.log('开始加载用户信息')
    const app = getApp()

    // 从本地存储获取用户信息
    const localUserInfo = wx.getStorageSync('userInfo') || {}
    if (app.globalData.userInfo) {
      this.setData({ userInfo: app.globalData.userInfo })
    } else {
      app.globalData.userInfo = localUserInfo
      this.setData({
        userInfo: localUserInfo,
        needPhoneAuth: !localUserInfo.phoneNumber
      })
    }

    // 加载用户类型和标签
    const userId = wx.getStorageSync('userId')
    const openid = wx.getStorageSync('openid')
    console.log('加载用户信息 - userId:', userId, 'openid:', openid ? '已获取' : '未获取')

    if (userId && openid) {
      // 从服务器获取最新的用户信息，确保身份由数据库决定
      this.refreshUserInfoFromServer(openid, userId)

      // 确保users存储结构存在
      let users = wx.getStorageSync('users')
      if (!users) {
        users = {}
        wx.setStorageSync('users', users)
      }

      if (!users[userId]) {
        users[userId] = { type: '' }
        wx.setStorageSync('users', users)
      }

      // 先显示本地存储的用户类型，但会被服务器返回的最新值覆盖
      const user = users[userId]
      const currentType = this.formatUserType(user.type)
      this.setData({ userType: currentType })
      console.log('加载用户信息 - 当前本地存储的用户类型:', currentType)

      // 先使用本地存储的用户类型更新标签，后续会被服务器返回的最新值覆盖
      this.updateUserTags(userId, user.type)
    }
  },

  // 更新用户标签
  updateUserTags(userId, userType) {
    // 确保tags存储结构存在
    let tags = wx.getStorageSync('tags')
    if (!tags) {
      tags = {}
      wx.setStorageSync('tags', tags)
    }

    if (!tags[userId]) {
      tags[userId] = []
      wx.setStorageSync('tags', tags)
    }

    const userTags = tags[userId] || []
    console.log('加载用户信息 - 原始标签:', userTags)

    // 使用indexOf替代includes以解决Babel兼容性问题
    let firstCategoryTag = []

    // 查找第一个偏好品类标签
    for (let i = 0; i < userTags.length; i++) {
      if (userTags[i].indexOf('偏好品类') !== -1) {
        firstCategoryTag = [userTags[i]]
        break
      }
    }

    // 合并保留的标签
    let filteredTags = [...firstCategoryTag]

    // 始终根据当前用户类型显示对应的身份标签
    if (userType && userType !== '') {
      let identityLabel = '身份:not_set'

      switch (userType) {
        case 'buyer': identityLabel = '身份:买家'; break
        case 'seller': identityLabel = '身份:卖家'; break
      }
      filteredTags.push(identityLabel)
      console.log('加载用户信息 - 根据当前用户类型显示身份标签:', identityLabel)
    }

    console.log('加载用户信息 - 过滤后的标签:', filteredTags)
    this.setData({ userTags: filteredTags })
  },

  // 从服务器刷新用户信息并同步身份数据
  refreshUserInfoFromServer(openid, userId) {
    const API = require('../../utils/api.js')

    API.getUserInfo(openid).then(res => {
      console.log('从服务器获取用户信息成功:', res)

      if (res.success && res.data) {
        const serverUserInfo = res.data

        // 更新本地用户信息
        const app = getApp()
        const updatedUserInfo = {
          ...app.globalData.userInfo,
          ...serverUserInfo
        }

        app.globalData.userInfo = updatedUserInfo
        wx.setStorageSync('userInfo', updatedUserInfo)
        this.setData({ userInfo: updatedUserInfo })

        // 同步更新用户身份信息（当前身份由数据库决定）
        if (serverUserInfo.type) {
          this.syncUserTypeFromServer(userId, serverUserInfo.type)
        }

        console.log('用户信息已更新，昵称:', updatedUserInfo.name, '手机号:', updatedUserInfo.phoneNumber, '身份:', serverUserInfo.type)
      }
    }).catch(err => {
      console.error('从服务器获取用户信息失败:', err)
      // 如果getUserInfo失败，尝试使用validateUserLogin作为备选
      API.validateUserLogin().then(res => {
        console.log('使用validateUserLogin获取用户信息成功:', res)

        if (res.success && res.data) {
          const serverUserInfo = res.data

          // 更新本地用户信息
          const app = getApp()
          const updatedUserInfo = {
            ...app.globalData.userInfo,
            ...serverUserInfo
          }

          app.globalData.userInfo = updatedUserInfo
          wx.setStorageSync('userInfo', updatedUserInfo)
          this.setData({ userInfo: updatedUserInfo })

          // 同步更新用户身份信息（当前身份由数据库决定）
          if (serverUserInfo.type) {
            this.syncUserTypeFromServer(userId, serverUserInfo.type)
          }

          console.log('用户信息已更新(备选方案):', updatedUserInfo)
        }
      }).catch(validateErr => {
        console.error('从服务器获取用户信息失败(包括备选方案):', validateErr)
        // 如果服务器请求失败，继续使用本地缓存的信息
      })
    })
  },

  // 从服务器同步用户身份信息
  syncUserTypeFromServer(userId, serverType) {
    if (!userId || !serverType) {
      console.error('同步用户身份信息失败: 参数不完整')
      return
    }

    console.log('从服务器同步用户身份信息:', { userId, serverType })

    // 更新本地存储的用户身份
    let users = wx.getStorageSync('users') || {}
    if (!users[userId]) {
      users[userId] = {}
    }

    // 如果当前类型是 Colleague，直接返回，不允许从服务器同步覆盖
    if (users[userId].type === 'Colleague') {
      console.log('当前用户是 Colleague 类型，不允许从服务器同步覆盖用户类型')
      return
    }

    // 移除serverType中的customer（如果存在）
    let processedServerType = serverType.replace(/,?customer/g, '').replace(/^,|,$/g, '')

    // 构建新的用户类型
    let newUserType = processedServerType

    // 只有当新构建的用户类型与本地不同时才更新
    if (users[userId].type !== newUserType) {
      users[userId].type = newUserType
      wx.setStorageSync('users', users)

      // 更新全局用户类型
      const app = getApp()
      app.globalData.userType = newUserType

      // 更新页面显示的用户类型
      this.setData({
        userType: this.formatUserType(newUserType)
      })

      console.log('用户身份已从服务器同步并保留客服标识:', newUserType)
    } else {
      console.log('用户身份与服务器一致，无需更新:', newUserType)
    }

    // 更新用户标签，确保传入正确的参数
    this.updateUserTags(userId, newUserType)
  },

  // 格式化用户类型显示
  formatUserType(type) {
    switch (type) {
      case 'buyer': return '买家';
      case 'seller': return '卖家';
      case 'both': return '买卖家';
      case 'buyer+seller': return '买卖家';
      default: return type || 'not_set';
    }
  },

  // 设置为买家
  setAsBuyer() {
    this.switchUserType('buyer', 'buyer')
  },

  // 设置为卖家
  setAsSeller() {
    this.switchUserType('seller', 'seller')
  },

  // 切换用户类型的通用方法
  switchUserType(newType, typeName) {
    const userId = wx.getStorageSync('userId')
    const openid = wx.getStorageSync('openid')

    if (!userId || !openid) {
      wx.navigateTo({ url: '/pages/index/index' })
      return
    }

    // 显示操作中的提示
    wx.showLoading({ title: 'Switching...' })

    // 引入API服务
    const API = require('../../utils/api.js')

    // 使用API更新用户类型，确保与服务器同步
    API.updateUserType(newType).then(res => {
      console.log('用户类型更新成功:', res)

      // 更新页面显示
      const app = getApp()
      this.setData({
        userType: this.formatUserType(app.globalData.userType)
      })

      // 更新用户标签
      this.updateUserTags(userId, app.globalData.userType)

      wx.showToast({
        title: `Switched to ${typeName}`,
        icon: 'success',
        duration: 2000
      })
    }).catch(err => {
      console.error('用户类型更新失败:', err)
      wx.showToast({
        title: 'Failed to switch, please retry',
        icon: 'none',
        duration: 2000
      })
    }).finally(() => {
      wx.hideLoading()
    })
  },

  // 上传用户类型到服务器
  uploadUserTypeToServer(openid, userId, userInfo, type) {
    // 引入API服务
    const API = require('../../utils/api.js')

    // 构造上传数据
    const uploadData = {
      userId: userId,
      openid: openid,
      ...userInfo,
      type: type,
      timestamp: Date.now()
    }

    // 调用API上传用户信息
    API.uploadUserInfo(uploadData).then(res => {
      console.log('用户类型更新成功:', res)
    }).catch(err => {
      console.error('用户类型更新失败:', err)
      wx.showToast({
        title: '身份更新失败，请重试',
        icon: 'none',
        duration: 2000
      })
    })
  },
  // 处理手机号授权结果
  async onPhoneNumberResult(e) {
    console.log('手机号授权结果:', e)

    // 首先检查用户是否拒绝授权
    if (e.detail.errMsg !== 'getPhoneNumber:ok') {
      console.log('用户拒绝授权手机号')
      wx.showToast({
        title: '您已拒绝授权，操作已取消',
        icon: 'none'
      })
      // 直接返回，取消所有后续操作
      return
    }

    wx.showLoading({
      title: '登录中...',
      mask: true
    })

    try {
      // 引入API服务
      const API = require('../../utils/api.js')

      // 1. 先执行微信登录获取code
      const loginRes = await new Promise((resolve, reject) => {
        wx.login({
          success: resolve,
          fail: reject
        })
      })

      if (!loginRes.code) {
        throw new Error('获取登录code失败')
      }

      console.log('获取登录code成功:', loginRes.code)

      // 2. 使用code换取openid
      const openidRes = await API.getOpenid(loginRes.code)

      // 增强版响应处理逻辑，支持多种返回格式
      let openid = null;
      let userId = null;
      let sessionKey = null;

      // 优先从data字段获取数据
      if (openidRes && openidRes.data && typeof openidRes.data === 'object') {
        openid = openidRes.data.openid || openidRes.data.OpenID || null;
        userId = openidRes.data.userId || openidRes.data.userid || null;
        sessionKey = openidRes.data.session_key || openidRes.data.sessionKey || null;
      }

      // 如果data为空或不存在，尝试从响应对象直接获取
      if (!openid && openidRes && typeof openidRes === 'object') {
        console.warn('服务器返回格式可能不符合预期，data字段为空或不存在，但尝试从根对象提取信息:', openidRes);
        openid = openidRes.openid || openidRes.OpenID || null;
        userId = openidRes.userId || openidRes.userid || null;
        sessionKey = openidRes.session_key || openidRes.sessionKey || null;
      }

      // 检查服务器状态信息
      const isSuccess = openidRes && (openidRes.success === true || openidRes.code === 200);

      if (!openid) {
        throw new Error('获取openid失败: ' + (openidRes && openidRes.message ? openidRes.message : '未知错误'))
      }

      // 存储openid和session_key
      wx.setStorageSync('openid', openid)
      if (sessionKey) {
        wx.setStorageSync('sessionKey', sessionKey)
      }

      // 确保始终使用从服务器获取的正式用户ID，不再生成临时ID
      if (userId) {
        wx.setStorageSync('userId', userId)
      } else {
        const app = getApp();
        if (app.globalData.userInfo && app.globalData.userInfo.userId) {
          const serverUserId = String(app.globalData.userInfo.userId);
          wx.setStorageSync('userId', serverUserId);
          userId = serverUserId;
          console.log('使用从全局获取的正式用户ID:', serverUserId);
        } else {
          console.warn('未找到有效的用户ID，请确保用户已授权登录');
        }
      }

      console.log('获取openid成功并存储:', openid)

      // 3. 上传手机号加密数据到服务器解密
      const phoneData = {
        ...e.detail,
        openid: openid,
        sessionKey: sessionKey || ''
      }

      console.log('准备上传手机号加密数据到服务器')
      const phoneRes = await API.uploadPhoneNumberData(phoneData)

      // 改进手机号解密结果的处理逻辑
      if (!phoneRes || (!phoneRes.success && !phoneRes.phoneNumber)) {
        // 如果服务器返回格式不标准但包含手机号，也接受
        if (!(phoneRes && phoneRes.phoneNumber)) {
          throw new Error('获取手机号失败: ' + (phoneRes && phoneRes.message ? phoneRes.message : '未知错误'))
        }
      }

      // 检查是否有手机号冲突
      const hasPhoneConflict = phoneRes.phoneNumberConflict || false
      const isNewPhone = phoneRes.isNewPhone || true
      const phoneNumber = phoneRes.phoneNumber || null

      console.log('手机号解密结果:', {
        phoneNumber: phoneNumber,
        hasPhoneConflict: hasPhoneConflict,
        isNewPhone: isNewPhone
      })

      // 4. 获取用户微信名称和头像
      let userProfile = null;
      try {
        userProfile = await new Promise((resolve, reject) => {
          wx.getUserProfile({
            desc: '用于完善会员资料',
            success: resolve,
            fail: reject
          });
        });
        console.log('获取用户信息成功:', userProfile);
      } catch (err) {
        console.warn('获取用户信息失败:', err);
        // 如果获取失败，使用默认值
      }

      // 5. 创建用户信息
      const app = getApp()
      const existingUserInfo = app.globalData.userInfo || wx.getStorageSync('userInfo') || {}
      const userInfo = {
        // 优先使用最新获取的微信头像和昵称，如果没有获取到则使用本地存储的
        name: (userProfile ? (userProfile.userInfo.name || userProfile.userInfo.nickName) : existingUserInfo.name) || '微信用户',
        avatarUrl: (userProfile ? userProfile.userInfo.avatarUrl : existingUserInfo.avatarUrl) || 'https://mmbiz.qpic.cn/mmbiz/icTdbqWNOwNRna42FI242Lcia07jQodd2FJGIYQfG0LAJGFxM4FbnQP6yfMxBgJ0F3YRqJCJ1aPAK2dQagdusBZg/0',
        gender: (userProfile ? userProfile.userInfo.gender : existingUserInfo.gender) || 0,
        country: (userProfile ? userProfile.userInfo.country : existingUserInfo.country) || '',
        province: (userProfile ? userProfile.userInfo.province : existingUserInfo.province) || '',
        city: (userProfile ? userProfile.userInfo.city : existingUserInfo.city) || '',
        language: (userProfile ? userProfile.userInfo.language : existingUserInfo.language) || 'zh_CN',
        phoneNumber: phoneNumber
      }

      // 6. 获取用户类型
      const users = wx.getStorageSync('users') || {}
      let currentUserType = users[userId] && users[userId].type ? users[userId].type : ''

      // 如果没有用户类型，尝试从全局获取
      if (!currentUserType) {
        currentUserType = app.globalData.userType || ''
      }

      // 7. 保存用户信息并等待上传完成
      console.log('开始保存用户信息并上传到服务器...')
      await this.uploadUserInfoToServer(userInfo, userId, currentUserType)
      console.log('用户信息保存并上传完成')

      // 更新本地和全局用户信息
      app.globalData.userInfo = userInfo
      wx.setStorageSync('userInfo', userInfo)

      // 更新页面状态
      this.setData({
        needPhoneAuth: false,
        userInfo: userInfo
      })

      // 重新加载用户信息以更新UI
      this.loadUserInfo()

      wx.hideLoading()

      // 根据服务器返回的结果显示不同的提示
      if (hasPhoneConflict) {
        wx.showModal({
          title: '登录成功',
          content: '您的手机号已被其他账号绑定',
          showCancel: false,
          confirmText: '我知道了',
          success(res) {
            if (res.confirm) {
              console.log('用户点击了我知道了');
            }
          }
        });
      } else {
        const that = this;
        wx.showModal({
          title: '登录成功',
        content: '🥚 允许获取位置，为你优先展示附近新鲜鸡蛋供应商、自提门店及精准配送时效，无需手动填地址，位置信息仅用于优化购物体验，隐私有保障，放心开启～',
          showCancel: true,
          cancelText: '取消',
          confirmText: '允许',
          success(res) {
            if (res.confirm) {
              console.log('用户点击了允许');
              // 调用位置授权函数
              that.requestLocationAuth();
            } else if (res.cancel) {
              console.log('用户点击了取消');
              // 关闭弹窗，不执行任何操作
            }
          }
        });
      }

    } catch (error) {
      wx.hideLoading()
      console.error('登录过程中发生错误:', error)

      // 更具体的错误提示
      let errorMsg = '登录失败，请重试'
      if (error.message.includes('网络')) {
        errorMsg = '网络连接失败，请检查网络后重试'
      } else if (error.message.includes('服务器')) {
        errorMsg = '服务器连接失败，请稍后重试'
      } else if (error.message.includes('openid')) {
        errorMsg = '获取登录信息失败，请重试'
      } else if (error.message.includes('手机号')) {
        errorMsg = '获取手机号失败，请重试'
      }

      wx.showToast({
        title: errorMsg,
        icon: 'none',
        duration: 3000
      })

      // 清除可能已经保存的不完整信息
      try {
        wx.removeStorageSync('openid')
        wx.removeStorageSync('sessionKey')
        wx.removeStorageSync('userId')
      } catch (e) {
        console.error('清除临时登录信息失败:', e)
      }
    }
  },

  // 上传用户信息到服务器
  uploadUserInfoToServer(userInfo, userId, type) {
    // 返回Promise以便调用者可以进行错误处理
    return new Promise((resolve, reject) => {
      try {
        // 引入API服务
        const API = require('../../utils/api.js')

        // 获取openid
        const openid = wx.getStorageSync('openid')

        // 验证必要参数
        if (!userId || !openid) {
          const error = new Error('缺少必要的用户信息');
          console.error('用户信息上传失败:', error);
          reject(error);
          return;
        }

        // 构造上传数据（包含所有必要字段，包括phoneNumber和头像URL）
        const uploadData = {
          userId: userId,
          openid: openid,
          name: userInfo.name,
          avatarUrl: userInfo.avatarUrl, // 添加头像URL字段
          phoneNumber: userInfo.phoneNumber, // 添加phoneNumber字段，满足服务器要求
          type: type,
          timestamp: Date.now()
        }

        // 调用API上传用户信息
        API.uploadUserInfo(uploadData).then(res => {
          console.log('用户信息上传成功:', res)
          resolve(res);
        }).catch(err => {
          console.error('用户信息上传失败:', err)
          reject(err);
        })
      } catch (error) {
        console.error('上传用户信息时发生异常:', error);
        reject(error);
      }
    });
  },

  // 修改用户名称
  onEditName() {
    const currentName = this.data.userInfo.name || '未登录';

    wx.showModal({
      title: '修改用户名称',
      editable: true,
      placeholderText: '请输入新的名称最多10个字符',
      confirmText: '确认',
      cancelText: '取消',
      success: (res) => {
        if (res.confirm) {
          // 移除首尾空格并过滤多余空格
          let newName = res.content.trim();
          newName = newName.replace(/\s+/g, ' ');

          // 验证昵称不能为空
          if (!newName) {
            wx.showToast({
              title: '名称不能为空',
              icon: 'none',
              duration: 2000
            });
            return;
          }

          // 验证昵称长度
          if (newName.length > 10) {
            wx.showToast({
              title: '名称长度不能超过10个字符',
              icon: 'none',
              duration: 2000
            });
            return;
          }

          // 检查名称是否变化
          if (newName === currentName) {
            wx.showToast({
              title: '名称未变化',
              icon: 'none',
              duration: 2000
            });
            return;
          }

          // 显示加载提示
          wx.showLoading({
            title: '正在更新...',
            mask: true
          });

          // 更新用户信息
          this.updateName(newName).finally(() => {
            // 无论成功失败，都隐藏加载提示
            wx.hideLoading();
          });
        }
      }
    });
  },

  // 检查位置授权状态
  checkLocationAuth() {
    const that = this;
    wx.getSetting({
      success(res) {
        if (res.authSetting['scope.userLocation']) {
          // 用户已经授权位置
          that.setData({ hasLocationAuth: true });
          that.getUserLocation();
        } else {
          // 用户未授权位置
          that.setData({ hasLocationAuth: false });
        }
      }
    });
  },

  // 请求位置授权
  requestLocationAuth() {
    const that = this;
    wx.authorize({
      scope: 'scope.userLocation',
      success() {
        // 授权成功
        that.setData({ hasLocationAuth: true });
        that.getUserLocation();
      },
      fail() {
        // 授权失败，弹出模态框引导用户重新授权
        wx.showModal({
          title: '需要位置授权',
          content: '请在设置中开启位置授权，以便我们为您提供相关服务',
          showCancel: true,
          cancelText: '取消',
          confirmText: '去授权',
          success: (res) => {
            if (res.confirm) {
              // 打开设置页面让用户手动开启授权
              wx.openSetting({
                success: (settingRes) => {
                  if (settingRes.authSetting['scope.userLocation']) {
                    // 用户在设置中开启了位置授权
                    that.setData({ hasLocationAuth: true });
                    that.getUserLocation();
                  } else {
                    // 用户在设置中仍未开启位置授权
                    that.setData({ hasLocationAuth: false });
                    wx.showToast({
                      title: '您已拒绝位置授权',
                      icon: 'none'
                    });
                  }
                },
                fail: () => {
                  that.setData({ hasLocationAuth: false });
                  wx.showToast({
                    title: '打开设置失败',
                    icon: 'none'
                  });
                }
              });
            } else {
              // 用户点击了取消
              that.setData({ hasLocationAuth: false });
            }
          }
        });
      }
    });
  },

  // 获取用户当前位置
  getUserLocation() {
    const that = this;

    // 先检查位置授权状态
    wx.getSetting({
      success(res) {
        if (res.authSetting['scope.userLocation']) {
          // 用户已经授权位置
          wx.showLoading({ title: '获取位置中...' });
          wx.getLocation({
            type: 'gcj02',
            success(res) {
              const latitude = res.latitude;
              const longitude = res.longitude;
              // 将位置信息存储到本地
              wx.setStorageSync('userLocation', { latitude, longitude });

              // 检查openid是否存在
              let openid = wx.getStorageSync('openid');
              if (!openid) {
                // 尝试从用户信息中获取openid
                const globalUserInfo = wx.getStorageSync('userInfo');
                openid = globalUserInfo?.openid;
              }

              // 确保openid存在
              if (!openid) {
                console.error('位置上传失败: 未找到openid');
                wx.hideLoading();
                wx.showToast({
                  title: '位置上传失败，请先登录',
                  icon: 'none',
                  duration: 2000
                });
                return;
              }

              // 调用逆地理编码API获取详细地址，然后统一上传
              that.reverseGeocode(latitude, longitude, openid);
            },
            fail() {
              wx.hideLoading();
              wx.showToast({
                title: '获取位置失败',
                icon: 'none'
              });
            }
          });
        } else {
          // 用户未授权位置，调用请求授权函数
          that.requestLocationAuth();
        }
      }
    });
  },

  // 逆地理编码获取详细地址并上传到数据库
  reverseGeocode(latitude, longitude, openid) {
    const that = this;
    wx.request({
      url: `https://apis.map.qq.com/ws/geocoder/v1/?location=${latitude},${longitude}&key=OB4BZ-D4W3U-B7VVO-4PJWW-6TKDJ-WPB77`,
      success(res) {
        wx.hideLoading();
        if (res.data.status === 0) {
          const address = res.data.result.address;
          that.setData({ locationInfo: address });
          // 将地址信息保存到本地存储
          wx.setStorageSync('locationInfo', address);

          // 保存地址信息到数据库
          const api = require('../../utils/api.js');
          const locationUpdateData = {
            openid: openid,
            latitude: latitude,
            longitude: longitude,
            address: address
          };

          console.log('保存地址到数据库:', locationUpdateData);

          // 调用API保存地址信息
          api.request('/api/user/update-location', 'POST', locationUpdateData)
            .then(res => {
              console.log('地址保存成功:', res);
              // 显示上传成功提示
              wx.showToast({
                title: '位置更新成功',
                icon: 'success',
                duration: 1500
              });
            }).catch(err => {
              console.error('地址保存失败:', err);
              // 显示上传失败提示
              wx.showToast({
                title: '位置上传失败',
                icon: 'none',
                duration: 2000
              });
            });
        } else {
          wx.showToast({
            title: '获取地址失败',
            icon: 'none'
          });
        }
      },
      fail() {
        wx.hideLoading();
        wx.showToast({
          title: '获取地址失败',
          icon: 'none'
        });
      }
    });
  },

  // 更新用户名称
  updateName(newName) {
    return new Promise((resolve, reject) => {
      try {
        // 更新本地和全局用户信息
        const app = getApp();
        const updatedUserInfo = {
          ...this.data.userInfo,
          name: newName
        };

        // 保存到本地存储和全局状态
        app.globalData.userInfo = updatedUserInfo;
        wx.setStorageSync('userInfo', updatedUserInfo);

        // 更新页面显示
        this.setData({
          userInfo: updatedUserInfo
        });

        // 更新服务器信息
        const userId = wx.getStorageSync('userId');
        const currentUserType = this.data.userType;

        // 如果有用户ID，则上传到服务器
        if (userId) {
          // 使用Promise链处理上传
          this.uploadUserInfoToServer(updatedUserInfo, userId, currentUserType)
            .then(() => {
              wx.showToast({
                title: '名称修改成功',
                icon: 'success',
                duration: 2000
              });
              resolve();
            })
            .catch((err) => {
              console.error('服务器同步失败，但本地已更新:', err);
              // 即使服务器同步失败，本地也已成功更新
              wx.showToast({
                title: '本地更新成功，服务器同步稍后进行',
                icon: 'none',
                duration: 3000
              });
              resolve(); // 即使服务器失败，也视为成功，因为本地已经更新
            });
        } else {
          // 没有用户ID，只更新本地
          console.warn('没有用户ID，仅更新本地用户名称');
          wx.showToast({
            title: '名称修改成功',
            icon: 'success',
            duration: 2000
          });
          resolve();
        }
      } catch (error) {
        console.error('更新用户名称失败:', error);
        wx.showToast({
          title: '更新失败，请稍后重试',
          icon: 'none',
          duration: 2000
        });
        reject(error);
      }
    });
  },

  // 跳转到收藏页面
  goToFavorites() {
    wx.switchTab({
      url: '/pages/favorites/index'
    });
  },

})