cfc/cfc-frontend/utils/api.js

import config from '@/config.js'

const BASE_URL = config.API_BASE_URL
const LANGGRAPH_URL = config.LANGGRAPH_BASE_URL

var _redirectingToLogin = false

function _clearAuthAndRedirect() {
  if (_redirectingToLogin) return
  _redirectingToLogin = true
  uni.removeStorageSync('token')
  uni.removeStorageSync('userId')
  uni.removeStorageSync('currentRole')
  uni.removeStorageSync('role')
  uni.removeStorageSync('nickname')
  uni.removeStorageSync('userName')
  uni.removeStorageSync('currentChildId')
  uni.showToast({ title: '登录已过期，请重新登录', icon: 'none' })
  setTimeout(function() {
    uni.reLaunch({ url: '/pages/login/login' })
    _redirectingToLogin = false
  }, 1500)
}

const request = (url, method = 'POST', data = {}, options = {}) => {
  // Append query params from options to URL if provided (e.g., { guideId } for GET requests)
  if (options && Object.keys(options).length > 0) {
    const separator = url.includes('?') ? '&' : '?'
    const query = Object.entries(options)
      .filter(([_, v]) => v !== undefined && v !== null && v !== '')
      .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
      .join('&')
    if (query) url = url + separator + query
  }
  var fullUrl = BASE_URL + url
  const token = uni.getStorageSync('token')
  // 过滤空字符串 ID 字段，防止后端 Long.valueOf("") 抛 NumberFormatException
  var body = data
  if (data && typeof data === 'object' && !Array.isArray(data)) {
    body = {}
    var hasFiltered = false
    for (var bk in data) {
      if (Object.prototype.hasOwnProperty.call(data, bk)) {
        var bv = data[bk]
        if (bv === '' && /(?:Id|ID|_id)$/.test(bk)) {
          hasFiltered = true
          continue
        }
        body[bk] = bv
      }
    }
    if (!hasFiltered) body = data
  }
  
  return new Promise((resolve, reject) => {
    uni.request({
      url: fullUrl,
      method: method,
      data: body,
      header: {
        'Content-Type': 'application/json',
        'Authorization': token ? `Bearer ${token}` : ''
      },
      success: (res) => {
        if (res.statusCode === 401 || res.data.code === 401) {
          console.warn('[API] 401 ' + method + ' ' + fullUrl)
          _clearAuthAndRedirect()
          reject(res.data)
          return
        }
        // 5001: 用户无家庭 — resolve 带标记，不 reject；由组件层各自渲染 FamilyEmptyState
        if (res.data.code === 5001) {
          console.warn('[API] 5001 ' + method + ' ' + fullUrl + ' — 无家庭')
          try {
            var _app = typeof getApp === 'function' ? getApp() : null
            if (_app && _app.$store) {
              _app.$store.commit('markNoFamily')
            }
          } catch (e) {}
          var _noFamilyResp = Object.assign({}, res.data, { noFamily: true })
          resolve(_noFamilyResp)
          return
        }
        if (res.data.code === 200) {
          resolve(res.data)
        } else {
          console.warn('[API] 失败 ' + method + ' ' + fullUrl + ' code=' + res.data.code + ' msg=' + (res.data.message || ''))
          uni.showToast({
            title: res.data.message || '请求失败',
            icon: 'none'
          })
          reject(res.data)
        }
      },
      fail: (err) => {
        console.error('[API] 网络错误 ' + method + ' ' + fullUrl, err)
        uni.showToast({
          title: '网络请求失败',
          icon: 'none'
        })
        reject(err)
      }
    })
  })
}

//  LangGraph 适配层（含 Dify fallback） 
//
// langgraphRequest() 是 AI 对话/分析的统一入口：
//   1. 先尝试调用 LangGraph 适配层（/api/v1/chat/completion 或 /api/v1/analysis/run）
//   2. 若 LangGraph 不可达（网络错误/超时/非 2xx），自动回退到 Dify（/api/ai/*）
//
// 参数：
//   langgraphPath  - LangGraph 端点路径（如 '/api/v1/chat/completion'）
//   langgraphBody  - 发给 LangGraph 的请求体（DifyChatRequest / DifyAnalysisRequest）
//   difyFallbackPath - Dify 回退端点路径（如 '/api/ai/chat/send'）
//   difyFallbackData  - 发给 Dify 的请求体（原 request() 的 data 参数）
//   difyFallbackMethod - Dify 回退请求方法（默认 'POST'）
//   difyFallbackOptions - Dify 回退请求 options（同 request() 的 options）
//   transform - 可选，把 LangGraph 响应转成页面期望的 { code, data, ... } 结构
//
// 返回 Promise，resolve 形态与 request() 一致：{ code: 200, data: {...}, message: ... }
const langgraphRequest = (opts) => {
  var langgraphPath = opts.langgraphPath
  var langgraphBody = opts.langgraphBody || {}
  var difyFallbackPath = opts.difyFallbackPath
  var difyFallbackData = opts.difyFallbackData || {}
  var difyFallbackMethod = opts.difyFallbackMethod || 'POST'
  var difyFallbackOptions = opts.difyFallbackOptions || {}
  var transform = opts.transform

  return new Promise((resolve, reject) => {
    var token = uni.getStorageSync('token')

    uni.request({
      url: LANGGRAPH_URL + langgraphPath,
      method: 'POST',
      data: langgraphBody,
      header: {
        'Content-Type': 'application/json',
        'Authorization': token ? ('Bearer ' + token) : ''
      },
      timeout: 30000,
      success: (res) => {
        // LangGraph 不可用（非 2xx）→ 回退 Dify
        if (res.statusCode < 200 || res.statusCode >= 300) {
          _fallbackToDify(difyFallbackPath, difyFallbackMethod, difyFallbackData, difyFallbackOptions, resolve, reject)
          return
        }
        // LangGraph 成功 → 转成页面期望的 { code: 200, data: {...} } 结构
        var lgData = res.data || {}
        var pageData = transform ? transform(lgData) : lgData
        resolve({ code: 200, message: 'ok', data: pageData })
      },
      fail: (err) => {
        console.warn('[API] LangGraph不可达，回退Dify ' + LANGGRAPH_URL + langgraphPath, err)
        // LangGraph 网络错误 → 回退 Dify
        _fallbackToDify(difyFallbackPath, difyFallbackMethod, difyFallbackData, difyFallbackOptions, resolve, reject)
      }
    })
  })
}

// 内部：Dify 回退（复用 request()，保持原有鉴权/错误处理/重定向逻辑）
function _fallbackToDify(path, method, data, options, resolve, reject) {
  request(path, method, data, options).then(resolve).catch(reject)
}

// 登录模块
export const wechatLogin = (code, userInfo, phoneCode) => {
  var data = { code: code, nickname: userInfo.nickname, avatar: userInfo.avatar }
  if (phoneCode) {
    data.phoneCode = phoneCode
  }
  return request('/api/auth/wechat-login', 'POST', data)
}

// 发送验证码
export const sendCode = (data) => {
  return request('/api/auth/send-code', 'POST', data)
}

// 手机号码验证码登录
export const phoneLogin = (data) => {
  return request('/api/auth/phone-login', 'POST', data)
}

//  街道地址相关 

// 获取所有省份
export const getProvinces = () => {
  return request('/api/streets/provinces')
}

// 根据父级ID获取子级地址
export const getStreetChildren = (parentId) => {
  return request(`/api/streets/children/${parentId}`)
}

// 根据ID获取地址详情
export const getStreetById = (id) => {
  return request(`/api/streets/${id}`)
}

// 获取地址完整路径
export const getStreetPath = (id) => {
  return request(`/api/streets/${id}/path`)
}

// 搜索地址
export const searchStreet = (keyword) => {
  return request('/api/streets/search', 'POST', { keyword })
}

// 区域匹配
export const matchByStreet = (streetId) => {
  return request(`/api/streets/${streetId}/match`)
}

// 按区域统计
export const getStreetStats = (level = 4) => {
  return request('/api/streets/stats', 'POST', { level })
}

// 获取家庭详情（含地址信息）
export const getFamilyDetail = (id) => {
  return request(`/api/admin/families/${id}`)
}

// 更新家庭地址
export const updateFamilyAddress = (data) => {
  return request(`/api/admin/families/update`, 'POST', data)
}

// 按街道ID列表统计家庭数量
export const countFamiliesByStreetIds = (streetIds) => {
  return request('/api/admin/families/count', 'POST', { streetIds: streetIds.join(',') })
}

// 按街道ID列表统计成长规划师数量
export const countTeachersByStreetIds = (streetIds) => {
  return request('/api/admin/teachers/count', 'POST', { streetIds: streetIds.join(',') })
}

// 微信手机号登录（新版）
export const wechatPhoneLogin = (data) => {
  return request('/api/auth/wechat-phone-login', 'POST', data)
}

// 获取平台公告
export const getNotices = () => {
  return request('/api/notices/list', 'GET')
}

// 微信静默登录
export const silentLogin = (code) => {
  return request('/api/auth/silent-login', 'POST', { code })
}

// 通过openid自动登录
export const autoLogin = (openid) => {
  return request('/api/auth/auto-login', 'POST', { openid })
}

export const setPassword = (password) => {
  return request('/api/auth/set-password', 'POST', { password })
}

export const verifyPassword = (password) => {
  return request('/api/auth/verify-password', 'POST', { password })
}

// 检查手机号是否已注册
export const checkPhone = (phone) => {
  return request('/api/auth/check-phone', 'POST', { phone })
}

// 校验本地 token 是否仍有效（App 启动时调用；401 由 request 封装统一处理跳转登录）
export const verifyToken = () => {
  return request('/api/auth/verify', 'POST')
}

// 直接注册（测试环境）
export const directRegister = (data) => {
  return request('/api/auth/direct-register', 'POST', data)
}

// 用户模块
export const getUserInfo = () => {
	return request('/api/user/info', 'POST')
}

export const updateUserInfo = (data) => {
	return request('/api/user/update', 'POST', data)
}

// 个人成就统计（我的页面核心数据）
export const getProfileStats = () => {
	return request('/api/user/profile-stats', 'POST')
}

// 就地补充信息回写（活动报名等场景按需补充后自动回写个人资料）
export const backfillProfile = (data) => {
	return request('/api/user/profile/backfill', 'POST', data)
}

export const joinFamily = (inviteCode) => {
	return request('/api/user/join-family', 'POST', { inviteCode })
}

export const createFamily = (name) => {
	return request('/api/family/user/create-family', 'POST', { name })
}

// 确保家庭已存在：无家庭则自动创建（默认名）
export const ensureFamily = () => {
	var ui = uni.getStorageSync('userInfo') || {}
	if (ui.familyId) return Promise.resolve({ alreadyExists: true, familyId: ui.familyId })
	var name = (ui.nickname || '用户') + '的家庭'
	return createFamily(name).then(function(res) {
		if (res && res.code === 200 && res.data) {
			ui.familyId = res.data
			uni.setStorageSync('userInfo', ui)
			try { getApp().$store.commit('setFamilyId', res.data) } catch (e) {}
			uni.showToast({ title: '家庭创建成功', icon: 'success' })
			return { created: true, familyId: res.data }
		}
		throw new Error((res && res.message) || '创建失败')
	}).catch(function(err) {
		uni.showToast({ title: err.message || '网络异常', icon: 'none' })
		return { failed: true, error: err }
	})
}

// 统一家庭成员列表接口（唯一入口，替代 getFamilyMembers / getVisibleFamilyMembers / listFamilyMembers）
// params: { visibleOnly: true } 仅返回 show_to_family=1 成员; { includeFamily: true } 附带 familyId/familyName/inviteCode/creatorId
export const getFamilyMemberList = (params) => {
	return request('/api/family/member/list', 'POST', params || {})
}

// 获取以指定成员为中心的所有成员关系（关系类型+信任/亲密度/沟通评分）
export const getPairwiseRelationships = (centerMemberId) => {
	return request('/api/family/relationship/pairwise', 'POST', { centerMemberId })
}

// 更新成员可见性
export const updateMemberVisibility = (memberId, memberType, showToFamily) => {
	return request('/api/family/user/members/update-visibility', 'POST', { memberId, memberType, showToFamily })
}

export const switchMode = (mode) => {
	return request('/api/user/switch-mode', 'POST', { mode })
}

export const switchToChild = (memberId) => {
	return request('/api/user/switch-to-child', 'POST', { memberId })
}

export const switchBackToParent = () => {
	return request('/api/user/switch-back-to-parent', 'POST', {})
}

export const switchBackVerify = (password) => {
	return request('/api/family/user/switch-back-verify', 'POST', { password })
}

export const getUserRoles = () => {
	return request('/api/user/roles', 'POST')
}

export const switchRole = (role) => {
	return request('/api/user/switch-role', 'POST', { role })
}

// 会员模块
export const getMembershipLevels = () => {
	return request('/api/membership/levels', 'POST')
}

export const getMembershipPlans = () => {
	return request('/api/membership/plans', 'POST')
}

export const getMyMembership = () => {
	return request('/api/membership/my', 'POST')
}

export const getCurrentLevel = () => {
	return request('/api/membership/current', 'POST')
}

export const createOrder = (levelCode, paymentType, period, couponId) => {
	var data = { levelCode: levelCode, paymentType: paymentType }
	if (period) {
		data.period = period
	}
	if (couponId) {
		data.couponId = couponId
	}
	return request('/api/membership/orders', 'POST', data)
}

export const nextOrder = (orderNo) => {
	return request('/api/membership/orders/continue', 'POST', { orderNo: orderNo })
}

export const getAuthorizations = () => {
	return request('/api/parent/authorizations', 'POST')
}

export const getChildren = () => {
  return request('/api/family/member/list', 'POST', {})
}

export const getParentDashboard = () => {
  return request('/api/parent/dashboard', 'POST')
}

export const getSystemBalance = (memberId) => {
  return request('/api/points/system-balance', 'POST', { memberId })
}

export const createChild = (data) => {
  return request('/api/family/user/children', 'POST', data)
}

export const updateChild = (memberId, data) => {
  return request('/api/family/user/children/update', 'POST', Object.assign({}, data, { memberId: memberId }))
}

// 家庭成员模块（统一添加成员）
export const addFamilyMember = (data) => {
  return request('/api/family/member/add', 'POST', data)
}

// 用户同意记录
export const recordConsent = (data) => {
  return request('/api/consent/record', 'POST', data)
}
export const withdrawConsent = (data) => {
  return request('/api/consent/withdraw', 'POST', data)
}
export const getConsentStatus = () => {
  return request('/api/consent/status', 'POST')
}

// 数据使用授权
export const getDataPermission = () => {
  return request('/api/data-permission/get', 'POST')
}
export const updateDataPermission = (data) => {
  return request('/api/data-permission/update', 'POST', data)
}

export const switchToFamilyMember = (memberId, source) => {
  return request('/api/family/member/switch', 'POST', { memberId, source })
}

export const kickFamilyMemberById = (memberId) => {
  return request('/api/family/member/kick', 'POST', { memberId })
}

export const updateFamilyMember = (data) => {
  return request('/api/family/member/update', 'POST', data)
}

// 任务模块
export const createTask = (data) => {
  return request('/api/tasks', 'POST', data)
}

export const getTodayTasks = (memberId) => {
  return request('/api/tasks/today', 'POST', { memberId })
}

export const getPendingReviewTasks = () => {
  return request('/api/tasks/pending-review', 'POST')
}

export const approveTask = (taskId) => {
  return request(`/api/tasks/${taskId}/review`, 'POST', { approved: true })
}

export const rejectTask = (taskId) => {
  return request(`/api/tasks/${taskId}/review`, 'POST', { approved: false })
}

export const completeTask = (taskId, memberId, photoUrl) => {
  return request(`/api/tasks/${taskId}/complete`, 'POST', { memberId, photoUrl })
}

export const reviewTask = (taskId, data) => {
  return request(`/api/tasks/${taskId}/review`, 'POST', data)
}

export const getTaskHistory = (memberId, page = 1, size = 10) => {
  return request('/api/tasks/history', 'POST', { memberId, page, size })
}

export const deleteTask = (taskId) => {
  return request(`/api/tasks/${taskId}`, 'DELETE')
}

export const batchCompleteTasks = (taskIds) => {
  return request('/api/tasks/batch-complete', 'POST', { taskIds })
}

export const batchDeleteTasks = (taskIds) => {
  return request('/api/tasks/batch-delete', 'POST', { taskIds })
}

// 积分模块
export const getPointsBalance = (memberId) => {
  return request('/api/points/balance', 'POST', { memberId })
}

export const getPointsLogs = (memberId, page = 1, size = 10) => {
  return request('/api/points/logs', 'POST', { memberId, page, size })
}

export const adjustPoints = (memberId, amount, reason, password) => {
  return request('/api/points/adjust', 'POST', { memberId, amount, reason, password })
}

// 奖励模块
export const createReward = (data) => {
  return request('/api/rewards', 'POST', data)
}

export const getWishlist = (memberId) => {
  return request('/api/rewards/wishlist', 'POST', { memberId })
}

export const exchangeReward = (rewardId, memberId) => {
  return request(`/api/rewards/${rewardId}/exchange`, 'POST', { memberId })
}

export const approveReward = (rewardId, approved) => {
  return request(`/api/rewards/${rewardId}/approve`, 'POST', { approved })
}

export const getRewardTemplates = () => {
  return request('/api/rewards/templates', 'POST')
}

export const getExchangeHistory = (memberId, page = 1, size = 10) => {
  return request('/api/rewards/exchange-history', 'POST', { memberId, page, size })
}

// ===
// 家长任务模块（孩子分配给家长的任务）
// ===
export const getTodayParentTasks = () => {
  return request('/api/tasks/today-parent', 'POST')
}

export const completeParentTask = (taskId) => {
  return request(`/api/tasks/${taskId}/complete-parent`, 'POST', {})
}

// ===
// 家庭成员任务分配模块
// ===
export const getMyPendingTasks = (memberId) => {
  return request('/api/tasks/my-pending', 'POST', { memberId })
}

export const acceptTask = (taskId, memberId) => {
  return request('/api/tasks/accept', 'POST', { taskId, memberId })
}

// ===
// 家长心愿单模块
// ===
export const createParentWishlist = (data) => {
  return request('/api/parent/wishlist', 'POST', data)
}

export const getParentWishlist = () => {
  return request('/api/parent/wishlist/list', 'POST')
}

export const getFamilyWishlist = () => {
  return request('/api/parent/wishlist/family', 'POST')
}

export const exchangeParentWishlist = (id) => {
  return request(`/api/parent/wishlist/${id}/exchange`, 'POST', {})
}

// 家长审批孩子的心愿并填写积分
export const approveParentWishlist = (id, pointsRequired) => {
  return request(`/api/parent/wishlist/${id}/approve`, 'POST', { pointsRequired })
}

// ===
// 家长心愿管理模块
// ===
export const getPendingWishes = () => {
  return request('/api/wishes/pending', 'POST', {})
}

export const getWishes = (params) => {
  return request('/api/wishes/list', 'POST', params)
}

export const setWishPrice = (wishId, points) => {
  return request(`/api/wishes/${wishId}/price`, 'POST', { pointsRequired: points })
}

export const rejectWish = (wishId, reason) => {
  return request(`/api/wishes/${wishId}/reject`, 'POST', { reason })
}

export const approveWishExchange = (wishId, approved) => {
  return request(`/api/wishes/${wishId}/approve-exchange`, 'POST', { approved })
}

export const markWishFulfilled = (wishId) => {
  return request(`/api/wishes/${wishId}/fulfill`, 'POST', {})
}

export const createWish = (data) => {
  return request('/api/wishes/create', 'POST', data)
}

export const getWishById = (id) => {
  return request(`/api/wishes/${id}`, 'POST', {})
}

export const requestWishExchange = (id) => {
  return request(`/api/wishes/${id}/exchange`, 'POST', {})
}

export const confirmWishReceived = (id) => {
  return request(`/api/wishes/${id}/confirm`, 'PUT', {})
}

export const cancelWish = (id, reason) => {
  return request(`/api/wishes/${id}`, 'DELETE', { reason })
}

// ===
// 成长规划师/任务模板模块
// ===
// 生成绑定邀请
export const generateBindInvite = () => {
  return request('/api/guide/bind/invite', 'POST')
}

// 获取绑定的家庭列表
export const getBoundFamilies = () => {
  return request('/api/guide/families', 'POST')
}

// 确认绑定家庭
export const confirmBind = (data) => {
  return request('/api/guide/bind/confirm', 'POST', data)
}

// 解除绑定
export const unbindFamily = (id) => {
  return request(`/api/guide/bind/${id}`, 'DELETE')
}

// 创建任务模板
export const createPackage = (data) => {
  return request('/api/packages', 'POST', data)
}

// 更新任务模板
export const updatePackage = (id, data) => {
  return request(`/api/packages/${id}`, 'PUT', data)
}

// 获取任务模板详情
export const getPackage = (id) => {
  return request(`/api/packages/${id}`, 'POST')
}

// 获取我的任务模板列表
export const getMyPackages = () => {
  return request('/api/packages', 'POST')
}

// 提交审核
export const submitPackageForReview = (id) => {
  return request(`/api/packages/${id}/submit`, 'POST')
}

// 发布/下架
export const publishPackage = (id, publish) => {
  return request(`/api/packages/${id}/publish`, 'POST', {}, { publish })
}

// 添加任务项
export const addPackageItem = (packageId, data) => {
  return request(`/api/packages/${packageId}/items`, 'POST', data)
}

// 更新任务项
export const updatePackageItem = (itemId, data) => {
  return request(`/api/packages/items/${itemId}`, 'PUT', data)
}

// 删除任务项
export const deletePackageItem = (itemId) => {
  return request(`/api/packages/items/${itemId}`, 'DELETE')
}

// 获取任务模板任务项
export const getPackageItems = (packageId) => {
  return request(`/api/packages/${packageId}/items`, 'POST')
}

// 获取公开任务模板列表
export const getPublicPackages = (category) => {
  return request('/api/market/packages', 'POST', { category })
}

// 通过分享码获取任务模板
export const getPackageByShareCode = (code) => {
  return request(`/api/market/share/${code}`, 'POST')
}

// 购买并应用任务模板
export const purchasePackage = (packageId, data) => {
  return request(`/api/market/packages/${packageId}/purchase`, 'POST', data)
}

// 获取我的任务计划
export const getMyPlans = () => {
  return request('/api/market/plans', 'POST')
}

// 获取计划详情
export const getPlanDetail = (id) => {
  return request(`/api/market/plans/${id}`, 'POST')
}

// 取消计划
export const cancelPlan = (id) => {
  return request(`/api/market/plans/${id}/cancel`, 'POST')
}

// 确认绑定成长规划师
export const acceptBind = (data) => {
  return request('/api/bind/accept', 'POST', data)
}

// 获取绑定的成长规划师列表
export const getBoundGuides = () => {
  return request('/api/bind/guides', 'POST')
}

// 成长规划师注册
export const registerGuide = (data) => {
  return request('/api/guide/register', 'POST', data)
}

// 生成邀请码
export const generateInviteCode = () => {
  return request('/api/guide/invite-code/generate', 'POST')
}

// 获取邀请码列表
export const getInviteCodes = () => {
  return request('/api/guide/invite-codes', 'GET')
}

// 验证邀请码
export const validateInviteCode = (code) => {
  return request('/api/guide/invite-code/validate', 'GET', null, { code })
}

export const checkTeamInviteStatus = (inviteCode) => {
  return request('/api/guide/team/check-status', 'POST', { inviteCode })
}

export const joinTeamByInvite = (inviteCode) => {
  return request('/api/guide/team/join-by-invite', 'POST', { inviteCode })
}

export const leaveCurrentTeam = () => {
  return request('/api/guide/team/leave', 'POST')
}

// 获取下级成长规划师列表
export const getChildGuides = () => {
  return request('/api/guide/child-guides', 'GET')
}

// 获取所有下级成长规划师
export const getAllChildGuides = () => {
  return request('/api/guide/all-child-guides', 'GET')
}

// 获取上级成长规划师
export const getParentGuide = () => {
  return request('/api/guide/parent-guide', 'GET')
}

// ===== 训练方案管理 =====
export const getTrainingPlanList = (memberId) => {
  return request('/api/guide/training-plans/list', 'POST',
    memberId ? { memberId } : {})
}

export const getTrainingPlanDetail = (planId) => {
  return request('/api/guide/training-plans/detail', 'POST', { planId })
}

export const createTrainingPlan = (memberId, title, description) => {
  return request('/api/guide/training-plans/create', 'POST', { memberId, title, description })
}

export const updateTrainingPlan = (planId, title, description) => {
  return request('/api/guide/training-plans/update', 'POST', { planId, title, description })
}

export const addTrainingPlanItem = (item) => {
  return request('/api/guide/training-plans/items/add', 'POST', item)
}

export const updateTrainingPlanItem = (item) => {
  return request('/api/guide/training-plans/items/update', 'POST', item)
}

export const deleteTrainingPlanItem = (itemId) => {
  return request('/api/guide/training-plans/items/delete', 'POST', { itemId })
}

export const generatePlanFromRecommendations = (memberId) => {
  return request('/api/guide/training-plans/generate-from-recommendations', 'POST', { memberId })
}

export const deleteTrainingPlan = (planId) => {
  return request('/api/guide/training-plans/delete', 'POST', { planId })
}

// ===== 活动管理 =====
export const getGuideActivityList = (status) => {
  return request('/api/guide/activities/list', 'POST', status ? { status } : {})
}

export const getGuideActivityDetail = (activityId) => {
  return request('/api/guide/activities/detail', 'POST', { activityId })
}

export const createActivity = (activity) => {
  return request('/api/guide/activities/create', 'POST', activity)
}

export const updateActivity = (activity) => {
  return request('/api/guide/activities/update', 'POST', activity)
}

export const publishActivity = (activityId) => {
  return request('/api/guide/activities/publish', 'POST', { activityId })
}

export const cancelActivity = (activityId) => {
  return request('/api/guide/activities/cancel', 'POST', { activityId })
}

export const deleteActivity = (activityId) => {
  return request('/api/guide/activities/delete', 'POST', { activityId })
}

// 添加成长规划师任务模板
export const addGuidePackage = (guideId, packageId, price, commissionRate) => {
  return request('/api/guide/package/add', 'POST', { guideId, packageId, price, commissionRate })
}

// 获取成长规划师套餐列表
export const getGuidePackages = (guideId) => {
  return request('/api/guide/packages', 'GET', null, { guideId })
}

// 获取成长规划师套餐定价
export const getGuidePackage = (guideId, packageId) => {
  return request('/api/guide/package/' + packageId, 'GET', null, { guideId })
}

// 更新成长规划师套餐价格
export const updateGuidePackagePrice = (guideId, packageId, price) => {
  return request('/api/guide/package/' + packageId, 'PUT', { guideId, price })
}

// 删除成长规划师套餐
export const deleteGuidePackage = (guideId, packageId) => {
  return request('/api/guide/package/' + packageId, 'DELETE', null, { guideId })
}

// 获取套餐价格
export const getPackagePrice = (packageId, guideId, inviteCode) => {
  return request('/api/package/price', 'GET', null, { packageId, guideId, inviteCode })
}

// 获取可用的成长规划师列表
export const getAvailableGuides = (packageId) => {
  return request('/api/package/available-guides', 'GET', null, { packageId })
}

// 创建套餐订单
export const createPackageOrder = (data) => {
  return request('/api/package/order/create', 'POST', data)
}

// 获取订单状态
export const getOrderStatus = (orderNo) => {
  return request('/api/payment/order/status/' + orderNo, 'GET')
}

// 创建微信支付订单
export const createWechatPayOrder = (orderNo, description, amount) => {
  return request('/api/payment/wechat/create', 'POST', { orderNo, description, amount })
}

// 创建支付宝订单
export const createAlipayOrder = (orderNo, description, amount) => {
  return request('/api/payment/alipay/create', 'POST', { orderNo, description, amount })
}

// 处理微信支付回调
export const handleWechatCallback = (params) => {
  return request('/api/payment/wechat/callback', 'POST', params)
}

// 澶勭悊鏀粯瀹濆洖璋?
export const handleAlipayCallback = (params) => {
  return request('/api/payment/alipay/callback', 'POST', params)
}

// 获取我的测评报告
export const getMyAssessmentResults = () => {
  return request('/api/dan-assessment/my-results', 'POST', {})
}

// 获取下级成长规划师的测评报告
export const getChildAssessmentResults = () => {
  return request('/api/dan-assessment/child-results', 'POST', {})
}

// 获取测评报告详情
export const getAssessmentResult = (id) => {
  return request('/api/dan-assessment/result/' + id, 'POST')
}

// 创建测评预约
export const createAssessmentAppointment = (data) => {
  return request('/api/dan-assessment/appointment/create', 'POST', data)
}

// 支付测评订单
export const payAssessmentOrder = (orderNo, payType) => {
  return request('/api/dan-assessment/order/pay', 'POST', { orderNo, payType })
}

//  虚拟支付 

// 创建测评订单（返回 AssessmentOrder，含 orderNo）
export const createAssessmentOrder = (data) => {
  return request('/api/dan-assessment/order/create', 'POST', data)
}

// 获取测评订单详情（轮询支付状态用；status: pending/paid/cancelled/refunded）
export const getAssessmentOrderDetail = (orderNo) => {
  return request('/api/dan-assessment/order/detail', 'POST', null, { orderNo })
}

// 虚拟支付参数薄包装（决策#7：各链路下单接口内联返回 VirtualPayParamsDTO，无独立端点）
// ASSESSMENT → 测评订单支付（/order/pay 内联返回 DTO；testMode 返回 null）
// MEMBERSHIP/SUBSCRIPTION → 下单接口已内联返回，调用方直接使用下单返回值，此处透传 orderNo
export const createVirtualPayOrder = (orderNo, goodsType) => {
  if (goodsType === 'ASSESSMENT') {
    return payAssessmentOrder(orderNo, 'wechat')
  }
  return Promise.resolve({ orderNo: orderNo, goodsType: goodsType })
}

// 虚拟支付失败上报（诊断用）：wx.requestVirtualPayment fail 时 fire-and-forget 上报到后端，
// 让支付失败原因在后端日志可见（正式版小程序前端 console 无法远程查看）。
// 独立 uni.request 实现，不弹 toast、不影响主流程。
export const reportVirtualPayError = (outTradeNo, errCode, errMsg, scene) => {
  try {
    uni.request({
      url: BASE_URL + '/api/internal/virtual-pay/error-report',
      method: 'POST',
      data: {
        outTradeNo: outTradeNo,
        errCode: errCode,
        errMsg: errMsg,
        scene: scene
      },
      header: { 'Content-Type': 'application/json' },
      success: function(res) {
        if (res.data && res.data.code !== 200) console.warn('[虚拟支付] 失败上报接口异常', res.data)
      },
      fail: function() { /* 上报失败静默处理，不打扰用户 */ }
    })
  } catch (e) { /* 上报异常静默处理 */ }
}

// 拉起微信小程序虚拟支付（官方 API 形态；基础库 2.19.2+，回调风格）
// params = VirtualPayParamsDTO { orderInfo, sign, signature }
export const requestVirtualPayment = (params, callbacks) => {
  if (!wx.canIUse('requestVirtualPayment')) {
    if (callbacks && callbacks.fail) {
      callbacks.fail({ errMsg: '当前微信版本不支持虚拟支付' })
    }
    return
  }
  var dto = params || {}
  wx.requestVirtualPayment({
    signData: JSON.stringify(dto.orderInfo || {}),
    paySig: dto.sign || '',
    signature: dto.signature || '',
    mode: 'short_series_goods',
    success: function(res) { if (callbacks && callbacks.success) callbacks.success(res) },
    fail: function(err) {
      console.error('[虚拟支付] wx.requestVirtualPayment fail', err, 'signData=', JSON.stringify(dto.orderInfo || {}))
      var orderNo = dto.orderInfo && dto.orderInfo.outTradeNo
      reportVirtualPayError(orderNo, err && err.errCode, err && err.errMsg, 'requestVirtualPayment')
      if (callbacks && callbacks.fail) callbacks.fail(err)
    }
  })
}

// 虚拟支付环境（官方仅 0=正式/1=沙箱；signData 内 env 由后端按 virtual-pay-env 生成）
// 本函数为计划保留的工具函数（日志/调试用）；develop→1（沙箱）、trial→1（沙箱）、release→0（正式）
export const getVirtualPaymentEnv = () => {
  try {
    var info = uni.getAccountInfoSync()
    var env = info.miniProgram && info.miniProgram.envVersion
    if (env === 'develop' || env === 'trial') return 1
    return 0
  } catch (e) {
    return 0
  }
}

// 记录测评结果
export const recordAssessmentResult = (data) => {
  return request('/api/dan-assessment/result/record', 'POST', data)
}

// 鎵撳崱妯″潡
export const getStreakProgress = (memberId) => {
  return request(`/api/streak/progress/${memberId}`, 'POST')
}

// 浠诲姟鎻愰啋
export const getTasksNeedReminder = (memberId) => {
  return request(`/api/task-reminders/reminder/${memberId}`, 'POST')
}

export const getUpcomingTasks = (memberId, minutes = 60) => {
  return request(`/api/task-reminders/upcoming/${memberId}`, 'POST', { minutes })
}

export const getOverdueTasks = (memberId) => {
  return request(`/api/task-reminders/overdue/${memberId}`, 'POST')
}

// 灏忔父鎴忔ā鍧?
export const getMiniGameList = () => {
  return request('/api/mini-game/list', 'POST')
}

export const getMiniGameByCode = (gameCode) => {
  return request(`/api/mini-game/${gameCode}`, 'POST')
}

export const completeMiniGame = (memberId, gameCode, completionTime, score) => {
  return request('/api/mini-game/complete', 'POST', { 
    memberId, 
    gameCode, 
    completionTime, 
    score 
  })
}

// 娓告垙璁板綍
export const saveGameRecord = (params) => {
  return request('/api/game/record', 'POST', params)
}

export const getGameHistory = (params) => {
  return request('/api/game/history', 'POST', params)
}

export const getGameBestScores = (params) => {
  return request('/api/game/best', 'POST', params)
}

export const getGameStats = (params) => {
  return request('/api/game/stats', 'POST', params)
}

export const getGameLeaderboard = (params) => {
  return request('/api/game/leaderboard', 'POST', params)
}

// 邀请码相关
export const getInviteCode = () => {
  return request('/api/family/invite-code', 'GET')
}

export const generateFamilyInviteCode = () => {
  return request('/api/family/invite-code/generate', 'POST')
}

export const bindGuideFamily = (inviteCode) => {
  return request('/api/family/guide-bind', 'POST', { inviteCode })
}

export const registerWithInviteCode = (data) => {
  return request('/api/auth/register-with-invite', 'POST', data)
}

// 成长记录
export const createGrowthRecord = (data) => {
  // 如果包含 alsoPurchaseAssessment 字段，使用合并接口
  if (data.alsoPurchaseAssessment) {
    return request('/api/growth/record/create-with-order', 'POST', data)
  }
  return request('/api/growth/record/create', 'POST', data)
}
export const getGrowthRecordList = () => {
  return request('/api/growth/record/list', 'POST')
}
export const getChildRecords = (memberId) => {
  return request('/api/growth/record/child/' + memberId, 'POST')
}
export const getGrowthRecordDetail = (id) => {
  return request('/api/growth/record/' + id, 'POST')
}
export const deleteGrowthRecord = (id) => {
  return request('/api/growth/record/' + id + '/delete', 'POST')
}

export const uploadAndParseReport = (filePath) => {
  return new Promise((resolve, reject) => {
    const token = uni.getStorageSync('token')
    uni.uploadFile({
      url: BASE_URL + '/api/growth/record/upload-and-parse',
      filePath: filePath,
      name: 'file',
      header: {
        'Authorization': token ? 'Bearer ' + token : ''
      },
      success: (res) => {
        const data = JSON.parse(res.data)
        if (data.code === 200) {
          resolve(data)
        } else {
          console.warn('[API] 上传失败 ' + BASE_URL + '/api/growth/record/upload-and-parse' + ' code=' + data.code + ' msg=' + (data.message || ''))
          reject(data)
        }
      },
      fail: (err) => {
        console.error('[API] 上传网络错误 ' + BASE_URL + '/api/growth/record/upload-and-parse', err)
        reject(err)
      }
    })
  })
}

export const createGrowthRecordFromUpload = (data) => {
  return request('/api/growth/record/create-from-upload', 'POST', data)
}

export const createGrowthSupplement = (data) => {
  return request('/api/growth/record/supplement', 'POST', data)
}

export const checkGrowthDuplicate = (data) => {
  return request('/api/growth/record/check-duplicate', 'POST', data)
}

export const getGrowthSupplements = (id) => {
  return request('/api/growth/record/' + id + '/supplements', 'POST')
}

// 成长规划师模块API
export const getTeamMembers = () => {
  return request('/api/guide/team/members', 'POST')
}

export const getTeamStats = () => {
  return request('/api/guide/team/stats', 'POST')
}

export const getGuideMessages = () => {
  return request('/api/guide/messages/list', 'POST')
}

export const getGuideOrders = () => {
  return request('/api/guide/orders/list', 'POST')
}

export const getOrderStats = () => {
  return request('/api/guide/orders/stats', 'POST')
}

// 任务完成率统计
export const getChildCompletionStats = (params) => {
  return request('/api/stats/child-completion', 'POST', params)
}

export const getFamilyCompletionStats = (params) => {
  return request('/api/stats/family-completion', 'POST', params)
}

export const generateInviteCard = (type, refId) => {
  if (type === 'child') {
    return request('/api/invite-card/generate', 'POST', { type, refId })
  }
  return request('/api/invite-card/generate', 'POST', { type })
}

export const verifyInviteCard = (code) => {
  return request('/api/invite-card/verify', 'POST', { code })
}

export const acceptInviteCard = (code, phone) => {
  return request('/api/invite-card/accept', 'POST', { code, phone })
}

// 瑙勫垝甯堥個璇峰闀?
export const generateParentInvite = () => {
  return request('/api/guide/parent-invite/generate', 'POST', {})
}

export const acceptParentInvite = (code) => {
  return request('/api/guide/parent-invite/accept', 'POST', { code })
}

// 踢出家庭成员（仅管理员）
export const kickFamilyMember = (targetUserId) => {
  return request('/api/family/user/kick', 'POST', { targetUserId })
}

// 家庭邀请二维码
export const generateFamilyInviteQrCode = () => {
  return request('/api/family/invite/qrcode', 'POST')
}

// ===== 瀹跺涵閭€璇凤紙浠ょ墝鐗堬紝鏀寔鎵爜娴侊級 =====

// 鐢熸垚瀹跺涵閭€璇凤紙鍚皬绋嬪簭鐮佹垨浜岀淮鐮侊級
export const generateFamilyInvite = () => {
  return request('/api/family/invite/generate', 'POST')
}

// 楠岃瘉閭€璇蜂护鐗?
export const validateInvitation = (token) => {
  return request('/api/family/invite/validate', 'POST', { token })
}

// 接受邀请（加入家庭）
export const acceptInvitation = (token, familyRole, mergeFamily) => {
  return request('/api/family/invite/accept', 'POST', { token, familyRole, mergeFamily: !!mergeFamily })
}

export const generateQrCodeFromText = (content) => {
  return request('/api/common/qrcode', 'POST', { content })
}

// 检查当前用户家庭状态
export const checkUserFamily = () => {
  return request('/api/family/invite/check-family', 'POST')
}

// 杞瀹跺涵绠＄悊鍛?
export const transferFamilyAdmin = (newAdminId) => {
  return request('/api/family/invite/transfer-admin', 'POST', { newAdminId })
}

// 通过邀请码申请加入家庭（需管理员审批）
export const requestJoinByCode = (inviteCode, familyRole) => {
  return request('/api/family/invite/request-join-by-code', 'POST', { inviteCode: inviteCode, familyRole: familyRole || '' })
}

// 查询待审批加入请求（管理员）
export const getPendingJoinRequests = () => {
  return request('/api/family/invite/pending-requests', 'POST', {})
}

// 审批加入请求（管理员）
export const approveJoinRequest = (requestId, comment) => {
  return request('/api/family/invite/approve-request', 'POST', { requestId: requestId, comment: comment || '' })
}

// 拒绝加入请求（管理员）
export const rejectJoinRequest = (requestId, comment) => {
  return request('/api/family/invite/reject-request', 'POST', { requestId: requestId, comment: comment || '' })
}

// 查询我的加入请求
export const getMyJoinRequest = () => {
  return request('/api/family/invite/my-request', 'POST', {})
}

// 取消我的加入请求
export const cancelMyJoinRequest = (requestId) => {
  return request('/api/family/invite/cancel-request', 'POST', { requestId: requestId })
}

// ===== 家庭加入请求 API 别名（供组件统一引用）=====
export const getPendingFamilyRequests = () => {
  return request('/api/family/invite/pending-requests', 'POST', {})
}
export const approveFamilyJoinRequest = (requestId) => {
  return request('/api/family/invite/approve-request', 'POST', { requestId: requestId })
}
export const rejectFamilyJoinRequest = (requestId) => {
  return request('/api/family/invite/reject-request', 'POST', { requestId: requestId })
}
export const getMyPendingRequest = () => {
  return request('/api/family/invite/my-request', 'POST', {})
}

// ===== AI 聊天 =====
export const aiSendMessage = (data) => {
  var query = data && data.query ? data.query : ''
  var conversationId = data && data.conversationId ? data.conversationId : ''
  var userId = uni.getStorageSync('userId') || ''
  var langgraphBody = {
    query: query,
    user: userId,
    user_id: userId,
    conversation_id: conversationId,
    response_mode: 'blocking',
    bot_name: 'AI管家'
  }
  var inputs = {}
  if (data && data.reportId) {
    inputs.report_id = data.reportId
  }
  if (data && data.healthStatus) {
    inputs.health_status = data.healthStatus
  }
  if (data && data.dietPrefs) {
    inputs.diet_preferences = data.dietPrefs
  }
  if (Object.keys(inputs).length > 0) {
    langgraphBody.inputs = inputs
  }
  return langgraphRequest({
    langgraphPath: '/api/v1/chat/completion',
    langgraphBody: langgraphBody,
    difyFallbackPath: '/api/ai/chat/send',
    difyFallbackData: data,
    transform: function(lgRes) {
      var content = ''
      if (lgRes && lgRes.choices && lgRes.choices.length > 0) {
        var msg = lgRes.choices[0].message
        if (msg && msg.content) { content = msg.content }
      }
      return {
        answer: content,
        conversationId: conversationId,
        recommendations: [],
        tasks: []
      }
    }
  })
}

export const aiGetConversations = () => {
  return request('/api/ai/chat/conversations', 'POST', {})
}

export const aiGetMessages = (params) => {
  return request('/api/ai/chat/messages', 'POST', params)
}

export const aiDeleteConversation = (id) => {
  return request('/api/ai/chat/conversations/' + id + '/delete', 'POST', {})
}

// 营养助手（基于体检报告）
export const aiSendNutritionMessage = (data) => {
  var query = data && data.query ? data.query : ''
  var conversationId = data && data.conversationId ? data.conversationId : ''
  var reportId = data && data.reportId ? data.reportId : null
  var userId = uni.getStorageSync('userId') || ''
  var langgraphBody = {
    query: query,
    user: userId,
    user_id: userId,
    conversation_id: conversationId,
    response_mode: 'blocking',
    bot_name: '营养助手'
  }
  if (reportId) {
    langgraphBody.inputs = { report_id: reportId }
  }
  return langgraphRequest({
    langgraphPath: '/api/v1/analysis/run',
    langgraphBody: langgraphBody,
    difyFallbackPath: '/api/ai/nutrition/send',
    difyFallbackData: data,
    transform: function(lgRes) {
      var content = ''
      if (lgRes && lgRes.choices && lgRes.choices.length > 0) {
        var msg = lgRes.choices[0].message
        if (msg && msg.content) { content = msg.content }
      }
      return {
        answer: content,
        conversationId: conversationId,
        recommendations: [],
        tasks: []
      }
    }
  })
}

// 健康教练
export const aiSendHealthCoachMessage = (data) => {
  var query = data && data.query ? data.query : ''
  var conversationId = data && data.conversationId ? data.conversationId : ''
  var userId = uni.getStorageSync('userId') || ''
  var langgraphBody = {
    query: query,
    user: userId,
    user_id: userId,
    conversation_id: conversationId,
    response_mode: 'blocking',
    bot_name: '健康教练'
  }
  if (data && data.memberId) {
    langgraphBody.inputs = { child_id: data.memberId }
  }
  return langgraphRequest({
    langgraphPath: '/api/v1/health/coach',
    langgraphBody: langgraphBody,
    difyFallbackPath: '/api/ai/chat/send',
    difyFallbackData: data,
    transform: function(lgRes) {
      var content = ''
      if (lgRes && lgRes.choices && lgRes.choices.length > 0) {
        var msg = lgRes.choices[0].message
        if (msg && msg.content) { content = msg.content }
      }
      return {
        answer: content,
        conversationId: conversationId,
        recommendations: [],
        tasks: []
      }
    }
  })
}

// 健康管家（健康知识库检索 + 个性化建议 + 任务生成）
export const aiSendHealthButlerMessage = (data) => {
  var query = data && data.query ? data.query : ''
  var conversationId = data && data.conversationId ? data.conversationId : ''
  var userId = uni.getStorageSync('userId') || ''
  var memberId = data && data.memberId ? data.memberId : null
  var langgraphBody = {
    query: query,
    user: userId,
    user_id: userId,
    conversation_id: conversationId,
    response_mode: 'blocking',
    bot_name: '健康管家'
  }
  var inputs = {}
  if (memberId) { inputs.child_id = memberId }
  if (data && data.reportId) { inputs.report_id = data.reportId }
  if (data && data.focus) { inputs.focus = data.focus }
  if (Object.keys(inputs).length > 0) { langgraphBody.inputs = inputs }
  return langgraphRequest({
    langgraphPath: '/api/v1/health/butler',
    langgraphBody: langgraphBody,
    difyFallbackPath: '/api/ai/chat/send',
    difyFallbackData: data,
    transform: function(lgRes) {
      var content = ''
      if (lgRes && lgRes.choices && lgRes.choices.length > 0) {
        var msg = lgRes.choices[0].message
        if (msg && msg.content) { content = msg.content }
      }
      var tasks = []
      var metadata = lgRes && lgRes.metadata
      if (metadata && metadata.tasks) { tasks = metadata.tasks }
      return {
        answer: content,
        conversationId: conversationId,
        recommendations: [],
        tasks: tasks
      }
    }
  })
}

//  幸福邻里部落 - 服务商模块 

// 提交服务商入驻申请
export const vendorApply = (data) => {
  return request('/api/vendor/apply', 'POST', data)
}

// 查询入驻审核状态
export const vendorStatus = () => {
  return request('/api/vendor/status', 'POST', {})
}

export const nutritionistApply = (data) => {
  return request('/api/nutritionist/apply', 'POST', data)
}

export const nutritionistStatus = () => {
  return request('/api/nutritionist/status', 'POST', {})
}

export const butlerApply = (data) => {
  return request('/api/butler/apply', 'POST', data)
}

// 获取服务商信息
export const vendorInfo = () => {
  return request('/api/vendor/info', 'POST', {})
}

//  幸福邻里部落 - 商品系统 

// 获取公开配置（pages/health/report-upload 依赖此函数读取 report_upload_category_id）
export const getPublicConfig = (key) => {
  return request('/api/config/public/value', 'POST', { key: key })
}

// 商品分类树（公开）— pages/shop/index 依赖此函数加载分类，缺失会导致 onLoad 中断
export const goodsCategory = () => {
  return request('/api/shop/category/tree', 'POST', {})
}

// 商品列表（公开）
export const productList = (params) => {
  return request('/api/product/list', 'POST', params)
}

// 商品详情（公开）
export const productDetail = (params) => {
  return request('/api/product/detail', 'POST', params)
}

// 商品规格映射（公开）
export const productSpecMap = (params) => {
  return request('/api/product/spec/map', 'POST', params)
}

// 商品SKU列表
export const productSkuList = (params) => {
  return request('/api/product/sku/list', 'POST', params)
}

// 服务商发布商品
export const productCreate = (params) => {
  return request('/api/product/create', 'POST', params)
}

// 服务商更新商品
export const productUpdate = (params) => {
  return request('/api/product/update', 'POST', params)
}

// 服务商查询自己的商品
export const productMy = (params) => {
  return request('/api/product/my', 'POST', params)
}

// 服务商上架/下架商品
export const productShelve = (params) => {
  return request('/api/product/shelve', 'POST', params)
}

// 创建订单
export const productOrderCreate = (params) => {
  return request('/api/product/order/create', 'POST', params)
}

// 支付订单
export const productOrderPay = (params) => {
  return request('/api/product/order/pay', 'POST', params)
}

// 取消订单
export const productOrderCancel = (params) => {
  return request('/api/product/order/cancel', 'POST', params)
}

// 我的订单
export const productOrderMy = (params) => {
  return request('/api/product/order/my', 'POST', params)
}

export const productOrderCounts = () => {
  return request('/api/product/order/my/counts', 'POST', {})
}

// 订单详情
export const productOrderDetail = (params) => {
  return request('/api/product/order/detail', 'POST', params)
}

// 服务商查询收到的订单
export const productOrderVendor = (params) => {
  return request('/api/product/order/vendor', 'POST', params)
}

// 服务商确认订单完成
export const productOrderConfirm = (params) => {
  return request('/api/product/order/confirm', 'POST', params)
}

// 用户申请订单退款
export const productOrderRefundApply = (params) => {
  return request('/api/product/order/refund/apply', 'POST', params)
}

// 管理员：商品待审核列表
export const adminProductPending = (params) => {
  return request('/api/admin/product/pending', 'POST', params)
}

// 管理员：商品列表
export const adminProductList = (params) => {
  return request('/api/admin/product/list', 'POST', params)
}

// 管理员：商品审核
export const adminProductReview = (params) => {
  return request('/api/admin/product/review', 'POST', params)
}

// 管理员：订单列表
export const adminOrderList = (params) => {
  return request('/api/admin/order/list', 'POST', params)
}

// 管理员：系统配置列表
export const adminConfigList = (params) => {
  return request('/api/admin/config/list', 'POST', params)
}

// 管理员：系统配置更新
export const adminConfigUpdate = (params) => {
  return request('/api/admin/config/update', 'POST', params)
}

// 管理员：获取所有配置
export const adminConfigAll = (params) => {
  return request('/api/admin/config/all', 'POST', params)
}


//  统计报表
export const getChildOverview = (memberId) => {
  return request('/api/stats/child/overview', 'POST', { memberId })
}

export const getFamilySummary = () => {
  return request('/api/stats/family/summary', 'POST', {})
}

export const getPointsRanking = () => {
  return request('/api/stats/points/ranking', 'POST', {})
}

//  鍕嬬珷绯荤粺 
export const getActiveBadges = () => {
  return request('/api/badges/list', 'POST')
}

export const getAllBadges = () => {
  return request('/api/badges/all', 'POST')
}

export const getBadgeDetail = (id) => {
  return request('/api/badges/detail', 'POST', { id })
}

export const getChildBadges = (memberId) => {
  return request('/api/badges/child/list', 'POST', { memberId })
}

export const toggleBadgeFavorite = (memberId, badgeId) => {
  return request('/api/badges/favorite', 'POST', { memberId, badgeId })
}

export const getChildBadgeStats = (memberId) => {
  return request('/api/badges/statistics/child', 'POST', { memberId })
}

export const getFamilyBadgeRanking = () => {
  return request('/api/badges/ranking/family', 'POST', {})
}

// ===== 内容区块权限 =====
export const getVisibleSections = (data) => request('/api/content-sections/visible', 'POST', data)

//  分佣裂变系统 

// 获取/创建我的邀请码
export const getReferralCode = () => {
  return request('/api/invite/code', 'POST')
}

// 获取邀请二维码
export const getInviteQrCode = () => {
  return request('/api/invite/qrcode', 'POST')
}

export const getShareQrCode = (page, scene) => {
  return request('/api/share/qrcode', 'POST', { page, scene })
}

// 绑定推荐人
export const bindReferral = (referralCode) => {
  return request('/api/invite/bind', 'POST', { referralCode })
}

// 我的邀请列表
export const getReferralList = (page = 1, size = 10) => {
  return request('/api/invite/list', 'POST', { page, size })
}

// 邀请统计
export const getReferralSummary = () => {
  return request('/api/invite/summary', 'POST')
}

// 浣ｉ噾鎬昏
export const getCommissionSummary = () => {
  return request('/api/commission/summary', 'POST')
}

// 浣ｉ噾鏄庣粏
export const getCommissionList = (page = 1, size = 20, status) => {
  var params = { page: page, size: size }
  if (status) {
    params.status = status
  }
  return request('/api/commission/list', 'POST', params)
}

// 鐢宠鎻愮幇
export const applyWithdrawal = (amount, accountInfo) => {
  return request('/api/withdrawal/apply', 'POST', { amount, accountInfo })
}

// 鎻愮幇璁板綍
export const getWithdrawalHistory = (page = 1, size = 10) => {
  return request('/api/withdrawal/history', 'POST', { page, size })
}

//  浜旇鑳介噺娌欑洏 

// 获取家庭能量沙盘数据（家庭五维+ 每个成员的个人数据）
// 兼容旧版：自动解包新格式，返回旧版 EnergySandboxDTO 格式
export const getFamilyEnergySandbox = () => {
  return request('/api/energy/sandbox', 'POST', {}).then(function(res) {
    if (res && res.data) {
      // 新格式：解锁后返回 {locked, view, personalData/familyData}
      if (!res.data.locked) {
        if (res.data.view === 'personal' && res.data.personalData) {
          res.data = res.data.personalData
        } else if (res.data.view === 'family' && res.data.familyData) {
          res.data = res.data.familyData
        }
      }
    }
    return res
  })
}

// 获取能量沙盘（支持 personal/family 双视角，含通关门禁，返回原始格式 {locked, view, personalData/familyData, familyUnlocked}）
export const getEnergySandbox = (view) => {
  return request('/api/energy/sandbox', 'POST', { view: view || 'personal' })
}

// 获取用户通关解锁全景（/api/unlock/status）
export const getUnlockStatus = () => {
  return request('/api/unlock/status', 'POST')
}

// ===== 文章内容系统 =====
export const getArticleCategories = () => request('/api/articles/categories', 'POST')
export const getArticleList = (data) => request('/api/articles/list', 'POST', data)
export const getArticleDetail = (data) => request('/api/articles/detail', 'POST', data)
export const getFeaturedArticles = (data) => request('/api/articles/featured', 'POST', data)
export const recordArticleRead = (data) => request('/api/articles/record-read', 'POST', data)
export const reportReadingTime = (data) => request('/api/articles/report-reading-time', 'POST', data)
export const getReadingStats = (memberId) => request('/api/articles/reading-stats', 'POST', { memberId })
export const getDailyTip = () => request('/api/articles/daily-tip', 'POST')
export const getAiQuestions = (data) => request('/api/articles/ai-questions', 'POST', data)
export const submitAnswers = (data) => request('/api/articles/submit-answers', 'POST', data)
export const publishArticle = (data) => request('/api/articles/publish', 'POST', data)
export const getMyPosts = (data) => request('/api/articles/my-posts', 'POST', data)
// 文章评论
export const getArticleComments = (data) => request('/api/articles/comments/list', 'POST', data)
export const createArticleComment = (data) => request('/api/articles/comments/create', 'POST', data)
export const auditArticleComment = (data) => request('/api/articles/comments/audit', 'POST', data)
export const getPendingComments = (data) => request('/api/articles/comments/pending', 'POST', data)
export const getMyComments = (data) => request('/api/articles/comments/my', 'POST', data)
// 文章完成阅读
export const completeArticleRead = (data) => request('/api/articles/complete-read', 'POST', data)
// AI答题
export const generateQuiz = (data) => request('/api/articles/quiz/generate', 'POST', data)
export const submitQuiz = (data) => request('/api/articles/quiz/submit', 'POST', data)

// ===== EMI蹇冪悊鎶ュ憡 =====
export const getEmiReport = (memberId) => request('/api/emireport/latest', 'POST', { memberId })
export const getEmiFamilyReports = (childIds) => request('/api/emireport/family', 'POST', { childIds })
export const getCognitiveChildScores = (memberId) => request('/api/cognitive/child', 'POST', { memberId })
export const getCognitiveFamilyScores = () => request('/api/cognitive/family', 'POST', {})


// ===== 认知测评结果 =====
export const getAssessmentLatestResult = (memberId) => request('/api/assessment/latest-result', 'POST', { memberId })
export const getAssessmentHistory = (memberId, size) => request('/api/assessment/history', 'POST', { memberId, size: size || 5 })

// ===== 测评额度（商城化改造） =====
export const getAssessmentQuotas = () => request('/api/assessment/quota/my-list', 'POST')
export const getAssessmentQuotaDetail = (quotaId) => request('/api/assessment/quota/detail', 'POST', { quotaId })
export const createAssessmentAppointmentWithQuota = (data) => request('/api/assessment/appointment/create', 'POST', data)

// ===== 测评报告上传与指导意见 =====
export const uploadAssessmentReport = (file, memberId, notes) => {
  return new Promise((resolve, reject) => {
    uni.uploadFile({
      url: BASE_URL + '/api/dan-assessment/result/upload',
      filePath: file.path,
      name: 'file',
      formData: { memberId: memberId, notes: notes || '' },
      header: { Authorization: 'Bearer ' + uni.getStorageSync('token') },
      success: (res) => {
        try {
          resolve(JSON.parse(res.data))
        } catch (e) {
          reject(e)
        }
      },
      fail: reject
    })
  })
}
export const saveGuidance = (resultId, items) => request('/api/dan-assessment/result/' + resultId + '/guidance/save', 'POST', { items })
export const getGuidance = (resultId) => request('/api/dan-assessment/result/' + resultId + '/guidance', 'POST')
export const confirmUploadReport = (resultId, data) => request('/api/dan-assessment/result/' + resultId + '/confirm-upload', 'POST', data)

// ===== 认知训练建议（家庭行动清单） =====
export const getCognitiveRecommendations = (memberId) => request('/api/cognitive/recommendations', 'POST', { memberId })
export const createTaskFromRecommendation = (memberId, dimensionKey, taskIndex) =>
  request('/api/cognitive/recommendations/create-task', 'POST', { memberId, dimensionKey, taskIndex })
export const getCognitiveNorms = (memberId) => request('/api/cognitive/norms', 'POST', { memberId })
export const getCognitiveTrend = (memberId, limit) => request('/api/cognitive/trend', 'POST', { memberId, limit: limit || 5 })

// ===== 五维能量系统（账本模式） =====
export const getEnergyOverview = (memberId) => {
  return request('/api/energy/overview', 'POST', { memberId })
}

export const getEnergyLogs = (memberId, dimensionCode, page = 1, size = 10) => {
  return request('/api/energy/logs', 'POST', { memberId, dimensionCode, page, size })
}

export const getWealthDetail = (memberId, memberType) => {
  return request('/api/energy/wealth-detail', 'POST', { memberId, memberType })
}

// ===== 成就徽章 =====
export const getUserBadges = (memberId) => {
  return request('/api/badges/child/list', 'POST', { memberId })
}


// ===== 成长报告 =====
export const getGrowthReport = (memberId) => {
  return request('/api/stats/child/overview', 'POST', { memberId })
}

// ===== 用户行动统计（我的页面） =====
export const getUserActionStats = () => {
  return request('/api/user/action-stats', 'POST')
}

// ===== 热门活动（行Tab） =====
export const getHotActivities = (data) => {
  return request('/api/activities/hot', 'POST', data)
}

// ===== 推荐商品（行Tab） =====
export const getRecommendedProducts = (data) => {
  return request('/api/products/recommend', 'POST', data)
}

//  浼氬憳鍗囩骇涓庣画璐?

// 鍗囩骇浼氬憳
export const upgradeMember = (levelCode) => {
  return request('/api/membership/upgrade', 'POST', { levelCode })
}

// 获取当前会员等级详情
export const getMemberLevel = (levelCode) => {
  return request('/api/membership/level', 'POST', { levelCode })
}

// 获取升级记录
export const getUpgradeRecords = (page = 1, size = 10) => {
  return request('/api/membership/upgrade-records', 'POST', { page, size })
}

//  佣金团队统计 

// 推广团队列表
export const getCommissionTeam = (page = 1, size = 10) => {
  return request('/api/commission/team', 'POST', { page, size })
}

// 推广团队成员列表（分页）
export const getTeamList = (page = 1, size = 20, level = 'ALL') => {
  return request('/api/commission/team/list', 'POST', { page, size, level })
}

// 浣ｉ噾缁熻鏁版嵁
export const getCommissionStats = () => {
  return request('/api/commission/stats', 'POST')
}

// 浣ｉ噾浣欓
export const getCommissionBalance = () => {
  return request('/api/commission/balance', 'POST')
}

// ===== 财富维度 · 财商打卡 =====
export const getCheckinList = (data) => {
  return request('/api/wealth/checkin/list', 'POST', data)
}

export const getCheckinStats = (data) => {
  return request('/api/wealth/checkin/stats', 'POST', data)
}

export const createCheckin = (data) => {
  return request('/api/wealth/checkin/create', 'POST', data)
}

export const deleteCheckin = (id) => {
  return request('/api/wealth/checkin/delete', 'POST', { id })
}

// ===== 财富维度 · 保单管理 =====
export const getInsuranceList = (data) => {
  return request('/api/wealth/insurance/list', 'POST', data)
}

export const getInsuranceDetail = (id) => {
  return request('/api/wealth/insurance/detail', 'POST', { id })
}

export const createInsurance = (data) => {
  return request('/api/wealth/insurance/create', 'POST', data)
}

export const updateInsurance = (data) => {
  return request('/api/wealth/insurance/update', 'POST', data)
}

export const deleteInsurance = (id) => {
  return request('/api/wealth/insurance/delete', 'POST', { id })
}

export const getInsurancePlanning = () => {
  return request('/api/insurance/planning', 'POST', {})
}

// ===== 鍋ュ悍鎵撳崱 =====
export const healthCheckinList = (data) => request('/api/health/checkin/list', 'POST', data)
export const healthCheckinCreate = (data) => request('/api/health/checkin/create', 'POST', data)
export const healthCheckinDelete = (id) => request('/api/health/checkin/delete', 'POST', { id })
export const getSleepList = (data) => request('/api/health/sleep/list', 'POST', data)
export const getExerciseList = (data) => request('/api/health/exercise/list', 'POST', data)
export const getMindCheckinList = (data) => request('/api/mind/checkin/list', 'POST', data)
export const getHealthMealList = (data) => request('/api/health/meal/list', 'POST', data)

// ===== 定期调研 =====
export const getSurveyStatus = (data) => request('/api/survey/status', 'POST', data)
export const getActiveTemplates = () => request('/api/survey/template/active', 'POST', {})
export const submitSurvey = (data) => request('/api/survey/submit', 'POST', data)
export const getSurveyHistory = (data) => request('/api/survey/history', 'POST', data)

// ===== 寰鍔紙P0 鏈夋晥鍚姩锛� =====
export const microActionList = () => request('/api/micro-action/list', 'POST', {})
export const microActionToday = (data) => request('/api/micro-action/today', 'POST', data)
export const microActionComplete = (data) => request('/api/micro-action/complete', 'POST', data)
export const microActionCheckToday = (data) => request('/api/micro-action/check-today', 'POST', data)

// ===== 每日反馈（P1-1 即时多巴胺反馈） =====
export const getTodayFeedback = (data) => request('/api/feedback/today', 'POST', data)
export const markFeedbackRead = (data) => request('/api/feedback/read', 'POST', data)
export const getRecentFeedbacks = (data) => request('/api/feedback/recent', 'POST', data)

// ===== 健康预警（P1-2 健康行为智能预警） =====
export const getActiveAlerts = (data) => request('/api/health/alert/list', 'POST', data)
export const dismissAlert = (data) => request('/api/health/alert/dismiss', 'POST', data)

// ===== 健康积分/等级/时间线（P2-1 身份重塑） =====
export const getHealthScoreInfo = (data) => request('/api/health/score/info', 'POST', data)
export const getHealthStreak = (data) => request('/api/health/score/streak', 'POST', data)
export const getHealthTimeline = (data) => request('/api/health/timeline/list', 'POST', data)

// ===== 家庭健康互动（P2-2 排行榜/点赞/挑战） =====
export const getFamilyRanking = (data) => request('/api/health/family/ranking', 'POST', data)
export const getChallengeList = (data) => request('/api/health/challenge/list', 'POST', data)
export const getChallengeHistory = (data) => request('/api/health/challenge/history', 'POST', data)
export const updateChallengeProgress = (data) => request('/api/health/challenge/progress', 'POST', data)
export const respondChallenge = (data) => request('/api/health/challenge/respond', 'POST', data)
export const createChallenge = (data) => request('/api/health/challenge/create', 'POST', data)
export const updateChallenge = (id, data) => request('/api/health/challenge/update/' + id, 'POST', data)
export const deleteChallenge = (id) => request('/api/health/challenge/delete/' + id, 'POST', data)
export const getChallengeTemplates = () => request('/api/health/challenge/templates', 'POST', {})
export const sendLike = (data) => request('/api/health/interact/like', 'POST', data)

// ===== 健康社区扩散（P3 健康圈/排行/分享） =====
export const getCircleList = (data) => request('/api/health/circle/list', 'POST', data)
export const createCircle = (data) => request('/api/health/circle/create', 'POST', data)
export const joinCircle = (data) => request('/api/health/circle/join', 'POST', data)
export const leaveCircle = (data) => request('/api/health/circle/leave', 'POST', data)
export const getCircleRanking = (data) => request('/api/health/circle/ranking', 'POST', data)
export const getCircleChallengeList = (data) => request('/api/health/circle/challenge/list', 'POST', data)
export const getCircleChallengeHistory = (data) => request('/api/health/circle/challenge/history', 'POST', data)

// ===== 通用圈子（社交圈） =====
export const getMyCircles = (memberId, memberType) => {
  return request('/api/circle/my-circles', 'POST', { memberId: memberId, memberType: memberType || 'child' })
}
export const discoverCircles = (memberId) => {
  return request('/api/circle/discover', 'POST', { memberId: memberId })
}
export const joinGeneralCircle = (circleId, memberId, memberType) => {
  return request('/api/circle/join', 'POST', { circleId: circleId, memberId: memberId, memberType: memberType || 'child' })
}
export const leaveGeneralCircle = (circleId, memberId, memberType) => {
  return request('/api/circle/leave', 'POST', { circleId: circleId, memberId: memberId, memberType: memberType || 'child' })
}

export const getFamilyFootprint = (data) => request('/api/share/family-footprint', 'POST', data)

// ===== 娲诲姩妯″潡锛堢淮搴︾瓫閫夛級 =====
export const getActivityList = (data) => request('/api/activity/list', 'POST', data)
export const getActivityDetail = (id) => request('/api/activity/detail', 'POST', { id })
export const activityCheckin = (data) => request('/api/activity/checkin', 'POST', data)
// 活动报名
export const registerActivity = (data) => request('/api/activity/register', 'POST', data)
export const cancelActivityRegistration = (data) => request('/api/activity/cancel-registration', 'POST', data)
export const getMyActivityRegistrations = (data) => request('/api/activity/my-registrations', 'POST', data)
export const submitActivityFeedback = (data) => request('/api/activity/feedback/submit', 'POST', data)
export const getActivityFeedbackList = (data) => request('/api/activity/feedback/list', 'POST', data)
export const getMyActivityFeedback = (data) => request('/api/activity/feedback/my', 'POST', data)
// 活动报名订单（先支付后报名）
export const createActivityOrder = (data) => request('/api/activity/order/create', 'POST', data)
export const payActivityOrder = (orderNo) => request('/api/activity/order/pay', 'POST', { orderNo: orderNo })
export const handleActivityOrderSuccess = (orderNo) => request('/api/activity/order/handlePaymentSuccess', 'POST', { orderNo: orderNo })
export const getActivityOrderStatus = (orderNo) => request('/api/activity/order/status', 'POST', { orderNo: orderNo })

// ===== 活动管理（管理员端，复用 /api/activity/*） =====
export const adminCreateActivity = (activity) => request('/api/activity/create', 'POST', activity)
export const adminUpdateActivity = (activity) => request('/api/activity/update', 'POST', activity)
export const adminPublishActivity = (id) => request('/api/activity/publish', 'POST', { id })
export const adminEndActivity = (id) => request('/api/activity/end', 'POST', { id })
export const submitActivityForReview = (id) => request('/api/activity/submit-review', 'POST', { id })
// 管理员列表：获取所有活动（含草稿），按 vendorId 过滤自己创建的
export const adminListMyActivities = (data) => request('/api/activity/list', 'POST', data)
// 后台概览列表：获取已发布的活动做统计
export const adminListAllActivities = (data) => request('/api/activity/list', 'POST', data)

export const getSubscriptionPlans = () => request('/api/subscription/plans', 'POST')
export const getMySubscription = () => request('/api/subscription/status', 'POST')
export const createSubscriptionOrder = (data) => request('/api/subscription/create', 'POST', data)
export const setAutoRenew = (data) => request('/api/subscription/auto-renew', 'POST', data)
export const cancelSubscription = (data) => request('/api/subscription/cancel', 'POST', data)
export const checkBenefit = (data) => request('/api/subscription/benefit/check', 'POST', data)

export const getMyPromotionTier = () => request('/api/promotion/my-tier', 'POST')
export const getPromotionTiers = () => request('/api/promotion/tiers', 'POST')
export const getPromotionTeamTree = (data) => request('/api/promotion/team-tree', 'POST', data)
export const getTierHistory = () => request('/api/promotion/tier-history', 'POST')

export const getMyEarnings = () => request('/api/commission/my-earnings', 'POST')
export const getCommissionRecords = (page, size) => request('/api/commission/records', 'POST', { page: page || 1, size: size || 20 })
export const getPpointProducts = () => request('/api/commission/ppoint/products', 'POST')

// ===== 家庭收益（推广中心重构） =====
export const getFamilyEarningsSummary = () => request('/api/earnings/family/summary', 'POST')
export const getFamilyEarningsMembers = () => request('/api/earnings/family/members', 'POST')
export const getFamilyEarningsRecords = (data) => request('/api/earnings/family/records', 'POST', data || {})
export const distributeToMember = (data) => request('/api/earnings/admin/distribute', 'POST', data)
export const toggleMemberBalance = (data) => request('/api/earnings/admin/toggle-member', 'POST', data)
export const withdrawFamilyEarnings = (data) => request('/api/earnings/admin/withdraw', 'POST', data)


// ===== 缁村害浠诲姟锛堝甫 category 绛涢€夛級 =====
export const getTodayTasksByCategory = (memberId, category) => {
  return request('/api/tasks/today', 'POST', { memberId: memberId, category: category })

}
export const getTaskHistoryByCategory = (memberId, category, page, size) => {
  return request('/api/tasks/history', 'POST', { memberId: memberId, category: category, page: page || 1, size: size || 10 })
}

// ===== 维度商品（domain 筛选，使用 productList） =====
export const getProductsByDomain = (domain, page, size) => {
  return productList({ domain: domain, page: page || 1, size: size || 6 })
}


// ===== 鍋ュ悍鎶ュ憡锛堜袱闃舵鍏ュ簱锛?=====
export const getLatestHealthReport = (memberId) => request('/api/health/report/latest', 'POST', { memberId })
export const getHealthIndicatorList = (memberId) => request('/api/health/indicator/list', 'POST', { memberId })


export const createHealthReport = (data) => request('/api/health/report/create', 'POST', data)
export const getReportList = (memberId) => request('/api/health/report/list', 'POST', { memberId })
export const getFamilyReports = () => request('/api/health/reports/family', 'POST', {})
export const getReportDetail = (reportId) => request('/api/health/report/detail', 'POST', { reportId })
// DAN 报告详情（含 blocks）
export const getDanReportDetail = (id) => request('/api/dan-report/' + id, 'POST', {})

export const editHealthReport = (reportId, payload, subjectId) => request('/api/health/report/edit', 'POST', { reportId, payload, subjectId })

export const deleteReport = (reportId) => request('/api/health/report/delete', 'POST', { reportId })

export const queryKnowledgeBase = (itemType, itemName) => request('/api/health/knowledge/query', 'POST', { itemType, itemName })

export const batchQueryKnowledgeBase = (queries) => request('/api/health/knowledge/batch-query', 'POST', { queries })


// 闃舵1锛氫笂浼燩DF鈫掕В鏋愨啋瀛榙raft鈫掕繑鍥瀌raftId+payload+鎴愬憳鍖归厤锛堜笉钀藉簱锛?
export const parseReportPreview = (filePath, memberId, type) => {
  return new Promise((resolve, reject) => {
    const token = uni.getStorageSync('token')
    uni.uploadFile({
      url: BASE_URL + '/api/health/report/parse-preview' + (type ? '?type=' + type : ''),
      filePath: filePath,
      name: 'file',
      formData: {
        memberId: memberId || ''
      },
      header: {
        'Authorization': token ? 'Bearer ' + token : ''
      },
      success: (res) => {
        var data
        try { data = JSON.parse(res.data) } catch (e) { data = res.data }
        if (data && data.code === 200) {
          resolve(data)
        } else {
          console.warn('[API] 解析上传失败 ' + BASE_URL + '/api/health/report/parse-preview' + ' code=' + (data && data.code || '') + ' msg=' + (data && data.message || ''))
          reject(data)
        }
      },
      fail: (err) => {
        console.error('[API] 解析上传网络错误 ' + BASE_URL + '/api/health/report/parse-preview', err)
        reject(err)
      }
    })
  })
}

// 闃舵2锛氱‘璁よ惤搴擄紙鍙€変紶淇敼鍚庣殑payload鍜宻ubjectId锛?

// 阶段2：确认落库（可选传修改后的payload和subjectId）

// 阶段0：仅上传报告文件（不解析），返回 draftId
export const uploadReportOnly = (filePath, type) => {
  return new Promise((resolve, reject) => {
    const token = uni.getStorageSync('token')
    uni.uploadFile({
      url: BASE_URL + '/api/health/report/upload-only' + (type ? '?type=' + type : ''),
      filePath: filePath,
      name: 'file',
      header: {
        'Authorization': token ? 'Bearer ' + token : ''
      },
      success: (res) => {
        var data
        try { data = JSON.parse(res.data) } catch (e) { data = res.data }
        if (data && data.code === 200) {
          resolve(data)
        } else {
          console.warn('[API] 上传失败 ' + BASE_URL + '/api/health/report/upload-only' + ' code=' + (data && data.code || '') + ' msg=' + (data && data.message || ''))
          reject(data)
        }
      },
      fail: (err) => {
        console.error('[API] 上传网络错误 ' + BASE_URL + '/api/health/report/upload-only', err)
        reject(err)
      }
    })
  })
}

// 阶段1：按 draftId 触发解析，返回完整 payload + 成员匹配
export const parseReportDraft = (draftId) => request('/api/health/report/parse', 'POST', { draftId })

export const confirmReportPreview = (data) => request('/api/health/report/confirm', 'POST', data)

// 鏀惧純鑽夌
export const discardReportDraft = (draftId) => request('/api/health/report/discard', 'POST', { draftId })

// ===== 鎶ュ憡璋冪爺闂嵎 =====
export const createReportSurvey = (reportId, memberId) => request('/api/health/survey/create', 'POST', { reportId, memberId })
export const submitReportSurvey = (surveyId, surveyData) => request('/api/health/survey/submit', 'POST', { surveyId, surveyData })
export const getReportSurveyStatus = (reportId) => request('/api/health/survey/status', 'POST', { reportId })

// ===== Report Feedback (gut flora report feedback) =====
export const submitFeedback = (data) => request('/api/health/feedback/submit', 'POST', data)

// ===== 重要关系（联系人） =====
export const getContactList = (data) => request('/api/contact/list', 'POST', data)
export const getContactDetail = (id) => request('/api/contact/detail', 'POST', { id: id })
export const createContact = (data) => request('/api/contact/create', 'POST', data)
export const updateContact = (data) => request('/api/contact/update', 'POST', data)
export const deleteContact = (id) => request('/api/contact/delete', 'POST', { id: id })
export const importPhoneContact = (data) => request('/api/contact/import-phone', 'POST', data)
export const recordContactInteraction = (data) => request('/api/contact/interaction', 'POST', data)

// ===== 椋熻氨鎺ㄨ崘 =====
export const getMealRecommend = (params) => request('/api/meal/recommend', 'POST', params)
export const replaceFood = (data) => request('/api/meal/replace', 'POST', data)
export const logMeal = (data) => request('/api/meal/log', 'POST', data)
export const getMealLogs = (data) => request('/api/meal/logs', 'POST', data)
export const getNutritionSummary = (data) => request('/api/meal/nutrition-summary', 'POST', data)
export const getNutritionProfile = (data) => request('/api/nutrition/profile/get', 'POST', data)
export const saveNutritionProfile = (data) => request('/api/nutrition/profile/save', 'POST', data)

// ===== 钀ュ吇妗ｆ涓庣己涔忓垎鏋?=====
export const getChildNutritionProfile = (memberId) => request('/api/health/nutrition/profile', 'POST', { memberId })

// ===== 家庭天盘 =====
export const getFamilyFortune = () => request('/api/mind/fortune', 'POST')
export const getDeficiencyAnalysis = (memberId) => request('/api/health/nutrition/deficiency', 'POST', { memberId })
export const getDeficiencySummary = (memberId) => request('/api/health/nutrition/deficiency-summary', 'POST', { memberId })
export const getNutritionTrend = (memberId) => request('/api/health/nutrition/trend', 'POST', { memberId })
export const getHealthAnalysis = (memberId) => request('/api/health/analysis', 'POST', { memberId })
export const getNutritionMappings = (data) => request('/api/health/nutrition/mappings', 'POST', data || {})

// ===== 健康维度 =====
export const getDimensionOverview = (data) => request('/api/dimension/overview', 'POST', data)
export const uploadDimensionScore = (data) => request('/api/dimension/upload', 'POST', data)
export const submitDimensionQuestionnaire = (data) => request('/api/dimension/questionnaire', 'POST', data)
export const getDimensionHistory = (data) => request('/api/dimension/history', 'POST', data)

// ===== 健康方案汇总 =====
export const generateHealthPlan = (data) => request('/api/health/plan/generate', 'POST', data)
export const saveHealthPlan = (data) => request('/api/health/plan/save', 'POST', data)
export const getHealthPlanList = (data) => request('/api/health/plan/list', 'POST', data)
export const getHealthPlanDetail = (data) => request('/api/health/plan/detail', 'POST', data)

// ===== 閭€璇烽噷绋嬬 =====
export const getInviteMilestones = () => {
  return request('/api/invite/milestone/list', 'POST')
}
export const claimInviteMilestone = (milestone) => {
  return request('/api/invite/milestone/claim', 'POST', { milestone })
}

//  浼樻儬鍒告ā鍧?
export const getCouponList = () => {
  return request('/api/coupon/list', 'POST')
}

export const getMyCoupons = () => {
  return request('/api/coupon/my', 'POST')
}

export const claimCoupon = (couponId) => {
  return request('/api/coupon/claim', 'POST', { couponId })
}

export const getExchangeableCoupons = () => {
  return request('/api/coupon/exchangeable', 'POST', {})
}

export const getCouponCheckoutList = (data) => {
  return request('/api/coupon/checkout-list', 'POST', data)
}

export const getProductCoupons = (data) => {
  return request('/api/coupon/product', 'POST', data)
}

export const exchangeCoupon = (data) => {
  return request('/api/coupon/exchange', 'POST', data)
}

export const getJoinCouponRules = () => {
  return request('/api/coupon/join-rules', 'POST', {})
}

// ===== 新手任务（Onboarding Rewards） =====
export const getOnboardingProgress = () => {
  return request('/api/onboarding/progress', 'POST')
}
export const claimOnboardingReward = (taskType) => {
  return request('/api/onboarding/claim', 'POST', { taskType })
}

// ===== 成长任务（每日新手任务系统） =====
export const getGrowthTaskList = (type) => {
  return request('/api/growth-task/list', 'POST', { type: type || 'DAILY' })
}

export const claimGrowthTaskReward = (taskLogId) => {
  return request('/api/growth-task/claim', 'POST', { taskLogId })
}

// ===== 推广排行榜 =====
export const getLeaderboardTop = () => {
  return request('/api/leaderboard/top', 'POST')
}

export const getLeaderboardMyRank = () => {
  return request('/api/leaderboard/my-rank', 'POST')
}


// ===== 鏁板闂叧锛堣嚜宸卞嚭棰樿嚜宸辩瓟锛?=====
export const getMathQuizStart = (memberId, age) => {
  return request('/api/wisdom/math/start', 'POST', { memberId, age })

  return request('/api/wisdom/math/start', 'POST', { childId, age })

}

export const verifyMathAnswer = (memberId, expression, userAnswer) => {
  return request('/api/wisdom/math/verify', 'POST', { memberId, expression, userAnswer })
}

export const completeMathQuiz = (data) => {
  return request('/api/wisdom/math/complete', 'POST', data)
}

// ===== 鍏崇郴璐ㄩ噺璇勫垎 =====
export const getRelationshipScores = () => {
  return request('/api/family/relationship/scores', 'POST', {})
}

export const calculateRelationshipScore = (memberId) => {
  return request('/api/family/relationship/calculate', 'POST', { memberId })
}

export const getHealthAlerts = () => {
  return request('/api/family/relationship/health-alerts', 'POST', {})
}

export const getMilestones = (daysAhead) => {
  return request('/api/family/relationship/milestones', 'POST', { daysAhead })
}

// ===== 浜掑姩璁板綍 =====
export const addInteraction = (data) => {
  return request('/api/family/interaction/add', 'POST', data)
}

export const listInteractions = (data) => {
  return request('/api/family/interaction/list', 'POST', data)
}

export const getInteractionTypes = () => {
  return request('/api/family/interaction/types', 'GET', {})
}

// ===== 鍏崇郴闂嵎 =====
export const generateQuestionnaire = (memberId) => {
  return request('/api/family/questionnaire/generate', 'POST', { memberId })
}

export const submitQuestionnaire = (data) => {
  return request('/api/family/questionnaire/submit', 'POST', data)
}

export const getQuestionnaireSnapshot = (memberId) => {
  return request('/api/family/questionnaire/snapshot/' + memberId, 'GET', {})
}

export const getQuestionnaireHistory = (memberId) => {
  return request('/api/family/questionnaire/history/' + memberId, 'GET', {})
}

// ===== 五维家庭自检（P0-1）=====
export const getSelfCheckQuestions = () => {
  return request('/api/family/self-check/questions', 'POST', {})
}

export const submitSelfCheck = (data) => {
  return request('/api/family/self-check/submit', 'POST', data)
}

export const getSelfCheckLatest = () => {
  return request('/api/family/self-check/latest', 'POST', {})
}

export const getSelfCheckHistory = () => {
  return request('/api/family/self-check/history', 'POST', {})
}

// ===== 舌诊相关（两阶段流程） =====
export const parseTonguePreview = (data) => request('/api/health/report/parse-preview?type=tongue', 'POST', data)
export const confirmTongue = (data) => request('/api/health/report/confirm?type=tongue', 'POST', data)
export const discardTongue = (data) => request('/api/health/report/discard?type=tongue', 'POST', data)
// 鎸囨爣瀹氫箟
export const getIndicatorDefinitions = (data) => request('/api/admin/indicator/list', 'POST', data)

export const getPointsExchangeProducts = (data) => request('/api/points/exchange/product/list', 'POST', data)
export const getPointsExchangeProductDetail = (data) => request('/api/points/exchange/product/detail', 'POST', data)
export const submitPointsExchange = (data) => request('/api/points/exchange/submit', 'POST', data)
export const getPointsExchangeRecords = () => request('/api/points/exchange/records', 'POST', {})
export const getPointsExchangeStats = () => request('/api/points/exchange/stats', 'POST', {})

// ===== 购物车 =====
export const cartAdd = (data) => request('/api/cart/add', 'POST', data)
export const cartList = (data) => request('/api/cart/list', 'POST', data)
export const cartUpdate = (data) => request('/api/cart/update', 'POST', data)
export const cartRemove = (data) => request('/api/cart/remove', 'POST', data)
export const cartCount = () => request('/api/cart/count', 'POST', {})

// ===== 我的订单 =====
export const getOrderCounts = () => request('/api/product/order/my/counts', 'POST', {})

// ===== 收货人管理 =====
export const consigneeList = () => request('/api/consignee/list', 'POST', {})
export const consigneeDetail = (id) => request('/api/consignee/detail', 'POST', { id })
export const consigneeSave = (data) => request('/api/consignee/save', 'POST', data)
export const consigneeDelete = (id) => request('/api/consignee/delete', 'POST', { id })

// ===== 地址管理 =====
export const addressList = () => request('/api/user/address/list', 'POST', {})
export const addressDetail = (id) => request('/api/user/address/get', 'POST', { id })
export const addressSave = (data) => {
  var url = data.id ? '/api/user/address/update' : '/api/user/address/create'
  return request(url, 'POST', data)
}
export const addressDelete = (id) => request('/api/user/address/delete', 'POST', { id })
export const addressSetDefault = (id) => request('/api/user/address/setDefault', 'POST', { id })

// ===== 商品购买字段 =====
export const getProductRequiredFields = (productId) => request('/api/product/purchase_fields/required', 'POST', { productId })

// ===== 测评方案 =====
export const listFamilyPlans = (data) => request('/api/guide/plans/family-list', 'POST', data)
export const reviewPlan = (data) => request('/api/guide/plans/review', 'POST', data)
export const activatePlan = (data) => request('/api/guide/plans/activate', 'POST', data)
export const getGuidePlanDetail = (data) => request('/api/guide/plans/detail', 'POST', data)

// ===== 家庭天盘相关 =====
export const tianpanDashboard = (data) => {
  return request('/api/tianpan/dashboard', 'POST', data)
}

export const tianpanMemberDetail = (memberId, data) => {
  return request('/api/tianpan/member/' + memberId, 'POST', data)
}

export const tianpanCompatibility = (data) => {
  return request('/api/tianpan/compatibility', 'POST', data)
}

export const tianpanAnnualEnergy = (data) => {
  return request('/api/tianpan/annual-energy', 'POST', data)
}

export const tianpanDailyFortune = (data) => {
  return request('/api/tianpan/daily-fortune', 'POST', data)
}

export const tianpanRelatedItems = (data) => {
  return request('/api/tianpan/related-items', 'POST', data)
}

// ===== DAN 测评报告上传 =====

/**
 * Phase 1: 上传 DAN 报告 PDF → 解析 → 返回预览草稿
 */
export const danParsePreview = (filePath, dimension, memberId) => {
  return new Promise((resolve, reject) => {
    var token = uni.getStorageSync('token')
    uni.uploadFile({
      url: BASE_URL + '/api/dan-assessment/report/parse-preview',
      filePath: filePath,
      name: 'file',
      formData: {
        dimension: dimension,
        memberId: String(memberId || '')
      },
      header: {
        'Authorization': token ? 'Bearer ' + token : ''
      },
      success: function(res) {
        var data
        try { data = JSON.parse(res.data) } catch (e) { data = res.data }
        if (data && data.code === 200) {
          resolve(data)
        } else {
          console.warn('[API] DAN上传失败 ' + BASE_URL + '/api/dan-assessment/report/parse-preview' + ' code=' + (data && data.code || '') + ' msg=' + (data && data.message || ''))
          reject(data || { message: '解析失败' })
        }
      },
      fail: function(err) {
        console.error('[API] DAN上传网络错误 ' + BASE_URL + '/api/dan-assessment/report/parse-preview', err)
        reject(err)
      }
    })
  })
}

/**
 * Phase 2: 确认并保存 DAN 报告
 */
export const danConfirmReport = (data) => {
  return request('/api/dan-assessment/report/confirm', 'POST', data)
}

/**
 * 获取某孩子某维度的 DAN 报告列表
 */
export const getDanReportByChild = (memberId, dimension) => {
  return request('/api/dan-assessment/report/child', 'POST', { memberId, dimension })
}

export const supplierProducts = (data) => {
  return request('/api/supplier/products', 'POST', data)
}

// === 商品规格 ===
export const productSpecGroups = (productId) => {
  return request('/api/product/spec/groups', 'POST', { productId })
}

// === 推荐系统 - 维度商品 ===
export const getDimensionProducts = (data) => {
  return request('/api/recommend/dimension-products', 'POST', data)
}

// === 推荐系统 - 复购提醒 ===
export const getRepurchaseReminders = (data) => {
  return request('/api/recommend/repurchase-reminders', 'POST', data)
}

export const clickRepurchaseReminder = (id) => {
  return request('/api/recommend/repurchase-reminder/' + id + '/click', 'POST', {})
}

// === KB v3 知识库查询 ===

// 查询菌属功能（支持属级回退）
export const queryBacteriaKnowledge = (name) => {
  return request('/api/health/knowledge/v3/bacteria/query', 'POST', { name })
}

// 批量查询菌属功能
export const batchQueryBacteriaKnowledge = (names) => {
  return request('/api/health/knowledge/v3/bacteria/batch-query', 'POST', { names })
}

// 查询指标调整建议
export const queryIndicatorKnowledge = (name) => {
  return request('/api/health/knowledge/v3/indicator/query', 'POST', { name })
}

// 查询食物营养数据
export const queryFoodKnowledge = (name) => {
  return request('/api/health/knowledge/v3/food/query', 'POST', { name })
}

// 获取KB v3章节数据
export const getKnowledgeSection = (section) => {
  return request('/api/health/knowledge/v3/section', 'POST', { section: section || '' })
}

// 获取我的测评预约列表
export const getMyAppointments = () => {
  var userId = uni.getStorageSync('userId')
  return request('/api/dan-assessment/appointment/user', 'POST', { userId: userId })
}

// 取消测评预约
export const cancelAppointment = (id) => {
  return request('/api/dan-assessment/appointment/cancel', 'POST', { id: id })
}

// 统一报告管理
export const getReportSummaryList = (params) => request('/api/report-summary/list', 'POST', params)
export const getReportSummaryDetail = (id) => request('/api/report-summary/detail/' + id, 'POST', {})
export const downloadReportSummary = (id) => request('/api/report-summary/download/' + id, 'POST', {})

// 服务角色统一申请
export const submitServiceRoleApply = (data) => {
    return request('/api/service-role/apply', 'POST', data)
}

export const getMyServiceRoleApply = () => {
    return request('/api/service-role/my-apply', 'POST', {})
}

export const uploadServiceRoleImage = (filePath) => {
    return new Promise((resolve, reject) => {
        uni.uploadFile({
            url: BASE_URL + '/api/service-role/upload-image',
            filePath: filePath,
            name: 'file',
            header: {
                'Authorization': 'Bearer ' + uni.getStorageSync('token')
            },
            success: (res) => {
                if (res.statusCode === 200) {
                    const data = JSON.parse(res.data)
                    resolve(data)
                } else {
                    reject(new Error('上传失败'))
                }
            },
            fail: reject
        })
    })
}

// 推荐系统
export const getRecommendList = (data) => request('/api/recommend/list', 'POST', data)
export const trackRecommendAction = (data) => request('/api/recommend/track', 'POST', data)

export const getHealthStatus = () => request('/api/health-status/get', 'POST', {})
export const saveHealthStatus = (data) => request('/api/health-status/save', 'POST', data)

// ===== 饮食模块 =====
export const getDietPreferences = (data) => request('/api/diet/preferences/current-member', 'POST', data || {})
export const saveDietPreferences = (data) => request('/api/diet/preferences/save', 'POST', data)
export const getDietIngredients = () => request('/api/diet/ingredients/suggest', 'POST', {})
export const refreshDietIngredients = () => request('/api/diet/ingredients/recommend', 'POST', {})
export const addDietIngredient = (data) => request('/api/diet/ingredients/add', 'POST', data)
export const removeDietIngredient = (data) => request('/api/diet/ingredients/remove', 'POST', data)
export const confirmDietIngredients = (data) => request('/api/diet/ingredients/confirm', 'POST', data)
export const getDietRecommendation = (data) => request('/api/diet/recommendation/today', 'POST', data)
export const generateDietRecommendation = (data) => request('/api/diet/recommendation/generate', 'POST', data)
export const updateDietRecommendation = (data) => request('/api/diet/recommendation/update', 'POST', data)
export const completeDietRecommendation = (data) => request('/api/diet/recommendation/complete', 'POST', data)
export const recognizeDietFood = (data) => request('/api/diet/record/recognize', 'POST', data)
export const saveDietRecord = (data) => request('/api/diet/record/save', 'POST', data)
export const getDietDailyRecords = (data) => request('/api/diet/record/daily', 'POST', data)
export const getDietWeeklyTrend = (data) => request('/api/diet/record/weekly', 'POST', data)
export const getMealConfig = (data) => request('/api/diet/meals/config', 'POST', data)
export const saveMealConfig = (data) => request('/api/diet/meals/config/save', 'POST', data)

// ===== 运动/睡眠/心情 日常记录 =====
export const getExerciseRecords = (data) => request('/api/health/exercise/list', 'POST', data)
export const createExerciseRecord = (data) => request('/api/health/exercise/create', 'POST', data)
export const getSleepRecords = (data) => request('/api/health/sleep/list', 'POST', data)
export const createSleepRecord = (data) => request('/api/health/sleep/create', 'POST', data)
export const getEmotionCheckinList = (data) => request('/api/mind/checkin/list', 'POST', data)
export const getEmotionCheckinLatest = (data) => request('/api/mind/checkin/latest', 'POST', data)
export const createEmotionCheckin = (data) => request('/api/mind/checkin/create', 'POST', data)

// ===== 北京菌群报告 — 菌群功能分析 =====
export const getGutFloraAnalysis = (reportId) => request('/api/nutrition/beijing/analysis', 'POST', { reportId })

// ===== 成长板块推荐 =====
export const getGrowthRecommendations = (category = 'health', limit = 3) =>
  request('/api/growth/recommendations', 'POST', { category, limit })

// ===== 食材戒备匹配 =====
export const getFoodCautionList = () => request('/api/food/recommendation/caution', 'POST', {})

// ===== 家庭平台积分（CF值）=====
export const getFamilyPlatformBalance = () => request('/api/family-platform/balance', 'POST', {})
export const getFamilyPlatformLogs = (data) => request('/api/family-platform/logs', 'POST', data)
export const exchangeCouponByCf = (data) => request('/api/family-platform/exchange-coupon', 'POST', data)

// ── AI 动态问卷 ──
export const aiQSceneList = (data) => request('/api/ai-questionnaire/scene/list', 'POST', data)
export const aiQStart = (data) => request('/api/ai-questionnaire/start', 'POST', data)
export const aiQAnswer = (data) => request('/api/ai-questionnaire/answer', 'POST', data)
export const aiQFinish = (data) => request('/api/ai-questionnaire/finish', 'POST', data)
export const aiQHistory = (data) => request('/api/ai-questionnaire/history', 'POST', data)
export const aiQProfileDetail = (data) => request('/api/ai-questionnaire/profile/detail', 'POST', data)
export const getProfileRecommend = (data) => request('/api/recommend/profile', 'POST', data)

// ===== 改版v1 需求驱动·逐步解锁（C类闭环 C类接口） =====
// 问题域
export const getProblemDomainList = () => request('/api/problem-domain/list', 'POST', {})
// 用户意图
export const getUserIntent = () => request('/api/user-intent/get', 'POST', {})
export const chooseUserIntent = (data) => request('/api/user-intent/choose', 'POST', data)
export const skipUserIntent = () => request('/api/user-intent/skip', 'POST', {})
export const updateUserIntentStage = (journeyStage) => request('/api/user-intent/update-stage', 'POST', { journeyStage })
// 站内通知
export const getNotificationList = () => request('/api/notification/list', 'POST', {})
export const readNotification = (data) => request('/api/notification/read', 'POST', data)
// 专项调研
export const submitProblemSurvey = (data) => request('/api/problem-survey/submit', 'POST', data)
// 获取专项调研问卷（按问题域 code，未绑定模板时后端返回内置默认问卷）
export const getProblemSurveyQuestions = (problemDomainCode) => request('/api/problem-survey/questions', 'POST', { problemDomainCode })
// 套餐详情
export const getProblemPackageDetail = (packageId) => request('/api/problem-package/detail', 'POST', { packageId })
// 方案确认（生成方案任务 + 推进旅程 stage=6，packageId 可省略）
export const confirmProblemPlan = (packageId) => request('/api/problem-package/confirm', 'POST', packageId ? { packageId } : {})
// 物流
export const updateLogistics = (data) => request('/api/logistics/update', 'POST', data)
export const getMyLogistics = () => request('/api/logistics/my', 'POST', {})
// 内容标签过滤
export const getContentByTags = (data) => request('/api/content/by-tags', 'POST', data)

// ===== 今日任务总览（首页卡片聚合：打卡/任务/阅读活动/测评报告） =====
export const getDailyTaskOverview = () => {
  return request('/api/daily-task/overview', 'POST', {})
}