cfc/cfc-frontend/utils/api.js

import config from '@/config.js'

const BASE_URL = config.API_BASE_URL

var _redirectingToLogin = false
var _reloginLock = false
// 续期在途期间收到的其他 401 请求，排队等待续期成功后统一重放（见 _handle401）
var _pending401 = []

// === 请求去重（Dedup）全局安全网 ===
// 同 URL + method + body 在 DEDUP_WINDOW_MS 窗口内复用同一个 Promise，
// 防止 onLoad/onShow 双触发、组件嵌套、双击等场景导致的重复请求。
// 401 续期重放请求传 options._skipDedup=true 跳过去重。
var _dedupMap = {}
var DEDUP_WINDOW_MS = 3000

function _makeDedupKey(method, url, body) {
  var bodyStr = ''
  try { bodyStr = JSON.stringify(body || {}) } catch (e) { bodyStr = '' }
  return method + '|' + url + '|' + bodyStr
}

function _tryDedup(method, fullUrl, body) {
  var key = _makeDedupKey(method, fullUrl, body)
  var cached = _dedupMap[key]
  if (cached && Date.now() - cached.ts < DEDUP_WINDOW_MS) {
    return cached.promise
  }
  return null
}

function _registerDedup(method, fullUrl, body, promise) {
  var key = _makeDedupKey(method, fullUrl, body)
  _dedupMap[key] = { promise: promise, ts: Date.now() }
  var _cleanup = function() {
    // 窗口到期后清理，确保缓存不常驻
    setTimeout(function() {
      if (_dedupMap[key] && _dedupMap[key].promise === promise) {
        delete _dedupMap[key]
      }
    }, DEDUP_WINDOW_MS)
  }
  promise.then(_cleanup, _cleanup)
}

function _clearDedup() {
  _dedupMap = {}
}
export { _clearDedup as clearApiDedup }

// 判断当前是否仍处于「小程序启动窗口」（首屏 splash 尚未切走）。
//
// 背景：pages/login 是分包（pages.json subPackages，root=pages/login），
// 而 pages/splash/index、pages/index-home/index 都在主包。分包页面在首次访问前
// 需要下载并注册；若在 App.onLaunch 阶段就 reLaunch 到未下载的分包，微信会报
// 「Page "pages/login/login" has not been registered yet」。
// 其它 28 处跳登录都是「已渲染页面上的用户点击」，框架已可下载分包，故不受影响。
function _inLaunchWindow() {
  try {
    var pages = typeof getCurrentPages === 'function' ? getCurrentPages() : null
    // 首屏尚未注册：仍在启动窗口
    if (!pages || pages.length === 0) return true
    var cur = pages[pages.length - 1]
    var route = ''
    if (cur) {
      route = cur.route || (cur.$page && cur.$page.route) || ''
    }
    // 还停在 splash：启动窗口内（约 2 秒），不与 splash 自己的 reLaunch 抢路由
    return route === 'pages/splash/index'
  } catch (e) {
    return 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() {
    // 启动窗口内只清登录态、不跳转：让 splash 正常落地首页（主包），
    // 首页按未登录态渲染登录引导，与「首次进入的新用户」路径一致。
    if (_inLaunchWindow()) {
      console.warn('[Auth] 启动窗口内不跳转登录页，交由 splash 落地首页（避免未注册分包页报错）')
      _redirectingToLogin = false
      return
    }
    uni.reLaunch({ url: '/pages/login/login' })
    _redirectingToLogin = false
  }, 1500)
}

// 静默续期成功后回写登录态（token/角色/familyId/openid），保持与 App.vue saveLoginInfo 一致
function _applyLoginData(data) {
  uni.setStorageSync('token', data.token)
  uni.setStorageSync('userId', data.userId)
  uni.setStorageSync('role', data.role)
  uni.setStorageSync('currentRole', data.role)
  uni.setStorageSync('isSwitchedChild', false)
  uni.setStorageSync('isSwitchedTeacher', false)
  if (data.openid) {
    uni.setStorageSync('openid', data.openid)
  }
  uni.setStorageSync('userInfo', {
    nickname: data.nickname,
    userId: data.userId,
    familyId: data.familyId
  })
  try {
    var app = typeof getApp === 'function' ? getApp() : null
    if (app && app.$store) {
      app.$store.commit('setToken', data.token)
      app.$store.commit('setUserInfo', {
        userId: data.userId,
        role: data.role,
        familyId: data.familyId,
        nickname: data.nickname
      })
      app.$store.commit('setFamilyId', data.familyId)
    }
  } catch (e) { /* 非页面环境无 Vuex，静默忽略 */ }
}

// 401 处理：优先静默续期（wx.login code2Session）并重放原请求；续期失败则回退跳登录页
//
// 关键：并发 401 必须「排队」而不是「清登录态」。
// 首页冷启动一次会并发打出多个 401（family/member/list、membership/my、
// onboarding/progress、home/app-library、guide-config/current ...）。
// 早期实现在 _reloginLock 为真时直接调 _clearAuthAndRedirect()，于是：第 1 个 401
// 刚启动 silentRelogin()（wx.login 是异步的），第 2~N 个 401 立刻把 token 从
// storage 抹掉并预约 1500ms 后 reLaunch 到登录页 → 在途的续期还没回调就被打断，
// 表现为「控制台只有 401、一条续期日志都没有、用户被弹回登录页」。
// 续期失败与否只能由发起续期的那一个 401 判断，其它 401 只需排队等结果。
function _handle401(url, method, data, options, resolve, reject, resData) {
  // 已有续期在途：挂起本请求等待重放。绝不能在这里动登录态，否则会毁掉在途续期。
  if (_reloginLock) {
    console.warn('[API] 401 续期在途，挂起请求 ' + url)
    _pending401.push({ url: url, method: method, data: data, options: options, resolve: resolve, reject: reject, resData: resData })
    return
  }
  _reloginLock = true
  var queue = [{ url: url, method: method, data: data, options: options, resolve: resolve, reject: reject, resData: resData }]
  _pending401 = queue

  function flushAll(err) {
    var q = _pending401
    _pending401 = []
    _reloginLock = false
    q.forEach(function (item) {
      if (err) item.reject(err)
      else item.reject(item.resData)
    })
  }

  silentRelogin().then(function(loginData) {
    if (loginData && loginData.token) {
      console.warn('[API] 401 静默续期成功，重放 ' + queue.length + ' 个挂起请求')
      _applyLoginData(loginData)
      // 重放：跳过去重（原 promise 已 reject，缓存已过期），
      // 并带 _noRelogin —— 若重放仍 401 说明刚签发的 token 仍不可用，直接失败，
      // 不能再触发新一轮续期，否则会 ping-pong 死循环。
      var _retryOpts = { _skipDedup: true, _noRelogin: true }
      var left = queue.length
      queue.forEach(function (item) {
        var opts = Object.assign({}, item.options, _retryOpts)
        request(item.url, item.method, item.data, opts).then(function(r) {
          item.resolve(r)
          if (--left === 0) _reloginLock = false
        }, function(e) {
          item.reject(e)
          if (--left === 0) _reloginLock = false
        })
      })
    } else {
      flushAll(resData)
      _clearAuthAndRedirect()
    }
  }).catch(function() {
    flushAll(resData)
    _clearAuthAndRedirect()
  })
}

// 静默续期：uni.login() 取微信签发的一次性 code，服务端 code2Session 换 openid 并签发新 token。
//
// 为什么不能拿本地 openid 直接换 token：openid 是明文标识符而非密钥，它会随登录响应返回、
// 明文存于本地 storage、并可能经日志/截图泄露；凭它签发 token 等同于任何拿到 openid 的人
// 都能完全冒充该账号（旧的 /api/auth/auto-login 就是这么做的，已废弃返回 410）。
// code 则由微信签发、单次使用、5 分钟过期，且能证明调用方持有该微信设备，不可伪造，
// 同样零交互静默完成 —— 这才是「用小程序缓存完成自动登录」的安全实现方式。
//
// 本地 openid 在这里仅作为「本设备此前登录过」的判断依据（决定是否尝试续期），绝不作为凭证上送。
//
// 返回：成功返回 LoginResultDTO 数据对象；本设备从未登录过 / 续期失败返回 null（由调用方决定兜底）
export function silentRelogin() {
  return new Promise(function(resolve) {
    // 无 openid 缓存 = 本设备从未成功登录过，属新用户，不做静默续期（直接引导手动登录）
    var cachedOpenid = uni.getStorageSync('openid')
    if (!cachedOpenid) {
      console.warn('[Auth] 本地无 openid 缓存，跳过静默续期（需手动登录）')
      resolve(null)
      return
    }
    uni.login({
      provider: 'weixin',
      success: function(loginRes) {
        if (!loginRes || !loginRes.code) {
          console.warn('[Auth] uni.login 未返回 code，静默续期跳过')
          resolve(null)
          return
        }
        // _noRelogin：本次请求就是续期请求本身，不能再触发 _handle401 造成递归续期
        silentLogin(loginRes.code, { _noRelogin: true, _skipDedup: true }).then(function(res) {
          if (res && res.data && res.data.token) {
            resolve(res.data)
          } else {
            console.warn('[Auth] 静默续期未返回 token')
            resolve(null)
          }
        }).catch(function(e) {
          console.warn('[Auth] 静默续期请求失败', e && e.code)
          resolve(null)
        })
      },
      fail: function(e) {
        console.warn('[Auth] uni.login 调用失败，静默续期跳过', e)
        resolve(null)
      }
    })
  })
}

const request = (url, method = 'POST', data = {}, options = {}) => {
  // 401 重放时 request(url, method, data, options) 会用同一份 options 再次拼 query，
  // 所以这里必须保存未拼接 query 的原始 path 传给 _handle401，否则重放请求的 URL 会
  // 出现 ?a=1&a=1（query 重复）。fullUrl 仍用拼接后的 url，日志和去重粒度不变。
  var basePath = url
  // Append query params from options to URL if provided (e.g., { guideId } for GET requests)
  // `timeout`/`_skipDedup`/`_noRelogin` 是请求配置项，不是 query 参数，需排除
  if (options && Object.keys(options).length > 0) {
    const separator = url.includes('?') ? '&' : '?'
    const query = Object.entries(options)
      .filter(([k, v]) => k !== 'timeout' && k !== '_skipDedup' && k !== '_noRelogin' && 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
  }

  // === 请求去重：同 URL + method + body 在 3 秒窗口内复用 Promise ===
  // 防止 onLoad/onShow 双触发、组件嵌套、双击等导致的重复请求
  if (!options._skipDedup) {
    var _cached = _tryDedup(method, fullUrl, body)
    if (_cached) {
      // console.log('[API] dedup hit ' + method + ' ' + fullUrl)
      return _cached
    }
  }

  var _promise = new Promise((resolve, reject) => {
    var _reqOpts = {
      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) {
          // _noRelogin：本次请求就是静默续期请求本身（或上层已明确不走自动续期），
          // 直接 reject。否则会再次进入 _handle401 → 递归续期，甚至误清登录态把用户踢出。
          if (options._noRelogin) {
            console.warn('[API] 401 ' + method + ' ' + fullUrl + '（已禁用自动续期，直接失败）')
            reject(res.data)
            return
          }
          console.warn('[API] 401 ' + method + ' ' + fullUrl)
          // 传 basePath（未拼 query）而非 url：_handle401 重放时会用 options 再拼一次
          _handle401(basePath, method, data, options, resolve, 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)
      }
    }
    if (options && options.timeout) _reqOpts.timeout = options.timeout
    uni.request(_reqOpts)
  })

  // 注册去重缓存，3 秒窗口内复用
  if (!options._skipDedup) {
    _registerDedup(method, fullUrl, body, _promise)
  }

  return _promise
}

// 登录模块
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)
}

// 获取平台公告（旧 /api/notices/list 已废弃返回410，改用已发布公告接口）
export const getNotices = () => {
  return request('/api/admin/notices/all', 'POST', {})
}

// 微信静默登录：code 由 uni.login() 签发，服务端 code2Session 换 openid 并签发新 token。
// 这是自动续期的唯一安全通道（可证明设备持有，openid 本身不可作为凭证）。
export const silentLogin = (code, options) => {
  return request('/api/auth/silent-login', 'POST', { code }, options)
}

// 【已废弃 · 不要使用】通过裸 openid 换取 token。
// 后端 /api/auth/auto-login 已改为 410 Gone：openid 是明文标识符而非密钥，
// 凭它签发 token 等同于任何拿到 openid 的人都能完全冒充该账号。
// 保留导出仅为便于排查历史调用，请改用 silentRelogin()（内部走 silentLogin）。
export const autoLogin = (openid) => {
  return request('/api/auth/auto-login', 'POST', { openid }, { _noRelogin: true })
}

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 })
}

// 确保家庭已存在：无家庭则自动创建（默认名）
// 注意：家庭在用户注册时已由后端创建，此函数仅作静默兜底，成功时不弹提示
// （此前弹『家庭创建成功』toast 会误导用户，已移除；错误仍会提示）
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) {}
			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/members}（members 已含家长段与成员段全量）
export const getFamilyMemberList = (params) => {
	return request('/api/family/member/list', 'POST', params || {})
}

// 首页引导浮层配置（管理端可配置家长/孩子引导步骤，无配置时返回 null data）
export const getGuideConfig = () => {
	return request('/api/guide-config/current', 'POST', {})
}

// 引导弹窗配置（guide_popup 表，配置化管理）：查询当前用户应展示的弹窗列表
export const getGuidePopupList = () => {
	return request('/api/guide/popup/list', 'POST', {})
}

// 上报触发行为，返回匹配弹窗
export const reportGuidePopupTrigger = (action, targetPage) => {
	return request('/api/guide/popup/trigger', 'POST', { action, targetPage })
}

// 消费弹窗（点击/关闭上报，防止重复弹出）
export const consumeGuidePopup = (popupId, buttonClicked, memberId) => {
	return request('/api/guide/popup/consume', 'POST', { popupId, buttonClicked, memberId })
}

// 获取以指定成员为中心的所有成员关系（关系类型+信任/亲密度/沟通评分）
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 getMembershipBenefits = (levelCode) => request('/api/membership/benefits', 'POST', { levelCode })

export const getGiftMembershipProgress = () => {
	return request('/api/membership/gift-membership-progress', 'POST')
}

export const getAllQuotaStatus = () => {
	return request('/api/basic-quota/status/all', 'POST')
}

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

export const createOrder = (levelCode, paymentType, period, couponId, openid) => {
	var data = { levelCode: levelCode, paymentType: paymentType }
	if (period) {
		data.period = period
	}
	if (couponId) {
		data.couponId = couponId
	}
	if (openid) {
		data.openid = openid
	}
	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')
}

// @deprecated 别名：统一使用 getFamilyMemberList，避免同 URL 多封装导致重复调用
// @deprecated 使用 getFamilyMemberList 代替。getChildren 与 getFamilyMemberList 调用同一接口 /api/family/member/list，
// 同一页面同时调用两者会导致重复请求。新代码请直接使用 getFamilyMemberList。
export const getChildren = () => getFamilyMemberList({})

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 getTaskListForPicker = (params) => {
  return request('/api/tasks/list', 'POST', params || {})
}

export const getTodayTasks = (memberId, options) => {
  var body = {}
  if (memberId != null && memberId !== '') {
    body.memberId = memberId
  }
  if (options && options.familyWide) {
    body.familyWide = true
  }
  return request('/api/tasks/today', 'POST', body)
}

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, content, contentType) => {
  return request(`/api/tasks/${taskId}/complete`, 'POST', { memberId, photoUrl, content, contentType })
}

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

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

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

export const deleteTask = (taskId) => {
  return request(`/api/tasks/${taskId}`, 'POST', { _method: '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`, 'POST', {})
}

export const cancelWish = (id, reason) => {
  return request(`/api/wishes/${id}`, 'POST', { _method: '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}`, 'POST', { _method: 'DELETE' })
}

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

// 更新任务模板
export const updatePackage = (id, data) => {
  return request('/api/packages/' + id, 'POST', Object.assign({ _method: '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, 'POST', { _method: 'PUT' }, data)
}

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

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


// 获取我的任务计划
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/team/invite-code/generate', 'POST')
}

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

// 验证邀请码
export const validateInviteCode = (code) => {
  return request('/api/guide/invite-code/validate', 'POST', { 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', 'POST', {})
}

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

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

// ===== 训练方案管理 =====
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/my', 'POST', { guideId: guideId })
}

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

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

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

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

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

// 获取健康方案可选的规划师列表（无需 packageId，返回 id/name/isBound 等字段）
export const getAvailableTeachers = (familyId) => {
  return request('/api/health-plan/available-teachers', 'POST', { familyId })
}


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

// 创建微信支付订单
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', 'POST', {})
}

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 validateFamilyCode = (inviteCode) => {
  return request('/api/family/invite/validate-family-code', 'POST', { inviteCode })
}

// 接受邀请（加入家庭）
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 })
}

// 通过邀请码/令牌申请加入家庭（token 路径绑定邀请人，等待邀请人确认；旧码路径管理员兜底）
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 别名（供组件统一引用）=====
// @deprecated 别名：委托到上面的规范函数，确保每个 URL 只有一处 request() 调用
export const getPendingFamilyRequests = () => getPendingJoinRequests()
export const approveFamilyJoinRequest = (requestId) => approveJoinRequest(requestId, '')
export const rejectFamilyJoinRequest = (requestId) => rejectJoinRequest(requestId, '')
export const getMyPendingRequest = () => getMyJoinRequest()

// ===== AI 聊天 =====
export const aiSendMessage = (data) => {
  return request('/api/ai/chat/send', 'POST', data)
}

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) => {
  return request('/api/ai/nutrition/send', 'POST', data)
}

// 健康教练
export const aiSendHealthCoachMessage = (data) => {
  return request('/api/ai/health-coach/send', 'POST', data)
}

// 健康管家（健康知识库检索 + 个性化建议 + 任务生成）
export const aiSendHealthButlerMessage = (data) => {
  return request('/api/ai/butler/send', 'POST', data)
}

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

// 提交服务商入驻申请
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 productOrderReviewUpdate = (params) => {
  return request('/api/product/order/review/update', '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')
}

// 解析 Result 中的邀请码：后端 /api/invite/code 返回 Result<String>（data 为纯字符串邀请码），
// 兼容历史对象结构 { referralCode | code }；解析失败返回 ''
export const extractReferralCode = (res) => {
  if (!res || !res.data) return ''
  var data = res.data
  if (typeof data === 'string') return data
  return data.referralCode || data.code || ''
}

// 获取邀请二维码
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 })
}

// —— 自己的邀请码缓存（模块级，供 bindReferralIfNotSelf 使用）——
let _myReferralCode = ''
let _myReferralCodeReq = null

// 获取/缓存自己的邀请码；请求失败允许下次重试
function getMyReferralCodeCached() {
  if (_myReferralCode) return Promise.resolve(_myReferralCode)
  if (!_myReferralCodeReq) {
    _myReferralCodeReq = getReferralCode().then(function(res) {
      _myReferralCode = extractReferralCode(res)
      return _myReferralCode
    }).catch(function(e) {
      _myReferralCodeReq = null
      throw e
    })
  }
  return _myReferralCodeReq
}

// 绑定推荐人（防"不能邀请自己"打扰）：邀请码是自己的（如点击自己分享的文章/商品/活动链接、自己扫自己的推广码）
// 则静默跳过，返回 { code: 200, skipped: true }，不调后端、不弹业务提示；否则走真实 bindReferral
export const bindReferralIfNotSelf = (referralCode) => {
  return getMyReferralCodeCached().then(function(myCode) {
    if (myCode && String(myCode).toLowerCase() === String(referralCode).toLowerCase()) {
      return { code: 200, skipped: true }
    }
    return bindReferral(referralCode)
  })
}

// 绑定家庭邀请人（首次注册时关联邀请家庭，仅新用户调用）
export const bindFamilyInviter = (familyInviteCode) => {
  return request('/api/family/invite/bind-inviter', 'POST', { familyInviteCode })
}

// 我的邀请列表
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, memberId) => {
  const data = { view: view || 'personal' }
  if (memberId) data.memberId = memberId
  return request('/api/energy/sandbox', 'POST', data)
}

// 获取用户通关解锁全景（/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 submitCognitiveSelfTest = (memberId, dimension, score) => request('/api/cognitive/self-test', 'POST', { memberId, dimension, score })


// ===== 认知测评结果 =====
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 })
}

// ===== 成就徽章 =====
// @deprecated 别名：委托到 getChildBadges，确保 /api/badges/child/list 只有一处封装
export const getUserBadges = (memberId) => getChildBadges(memberId)


// ===== 成长报告 =====
// @deprecated 别名：委托到 getChildOverview，确保 /api/stats/child/overview 只有一处封装
export const getGrowthReport = (memberId) => getChildOverview(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 getTeamConsumption = (maxLevel = 3) => request('/api/commission/team/consumption', 'POST', { maxLevel })

export const getMyReferrer = (memberId) => request('/api/commission/my-referrer', 'POST', memberId ? { memberId } : {})

export const getTeamTree = (maxLevel = 3) => request('/api/commission/team/tree', 'POST', { maxLevel })

// 团队曲线数据
export const getTeamGrowthCurve = (months = 12) => request('/api/commission/team/growth-curve', 'POST', { months })
export const getTeamAllMembersConsumptionCurve = (months = 12) => request('/api/commission/team/consumption-curve', 'POST', { months })
export const getTeamL1ConsumptionCurve = (months = 12) => request('/api/commission/team/l1-consumption-curve', 'POST', { months })

// CF 分佣
export const getCfRate = () => request('/api/commission/cf/rate', 'POST')
export const getCfSummary = () => request('/api/commission/cf/summary', 'POST')
export const getCfList = (page, size) => request('/api/commission/cf/list', 'POST', { page, size })
// CF 转让
export const sendCfTransfer = (toUserId, amount) => request('/api/cf/transfer/send', 'POST', { toUserId, amount })
export const getCfTransferList = (page, size) => request('/api/cf/transfer/list', 'POST', { page, size })

// ===== 财富维度 · 财商打卡 =====
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', {})
}

// 上传保单PDF并AI解析，返回提取字段预览和原始条款
export const uploadPolicy = (filePath) => {
  return new Promise((resolve, reject) => {
    const token = uni.getStorageSync('token')
    uni.uploadFile({
      url: BASE_URL + '/api/wealth/insurance/upload',
      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/wealth/insurance/upload code=' + (data && data.code || '') + ' msg=' + (data && data.message || ''))
          reject(data)
        }
      },
      fail: (err) => {
        console.error('[API] 保单上传网络错误', err)
        reject(err)
      }
    })
  })
}

// ===== 鍋ュ悍鎵撳崱 =====
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 getEmotionIndicators = (memberId) => request('/api/mind/neurotransmitters', 'POST', { memberId })
// 智页面"肠胃与认知"：返回与认知/智力相关的菌群报告指标
export const getGutCognitionIndicators = (memberId) => request('/api/wisdom/gut-cognition', 'POST', { memberId })
// 身体页面"指标告警"：疾病风险(非低风险) + 营养/氨基酸异常指标
export const getBodyAbnormalIndicators = (memberId) => request('/api/health/report/body-abnormal', 'POST', { memberId })

// ===== 定期调研 =====
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)

// ===== DOA 个人目标（家庭打卡个人目标模块） =====
export const createDoaStage = (data) => request('/api/doa/stage/create', 'POST', data)
export const getDoaOverview = () => request('/api/doa/overview', 'POST', {})
export const getDoaStageDetail = (stageId) => request('/api/doa/stage/detail', 'POST', { stageId: stageId })
export const cancelDoaStage = (stageId) => request('/api/doa/stage/cancel', 'POST', { stageId: stageId })
export const submitDoaWeekPlan = (weekId, plan) => request('/api/doa/week/plan', 'POST', { weekId: weekId, plan: plan })
export const submitDoaWeekReview = (data) => request('/api/doa/week/review', 'POST', data)
export const getDoaWeekList = (stageId) => request('/api/doa/week/list', 'POST', { stageId: stageId })

// ===== 健康社区扩散（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 createGeneralCircle = (data) => request('/api/circle/create', 'POST', data)
export const updateCircle = (data) => request('/api/circle/update', 'POST', data)
export const getCircleFeed = (data) => request('/api/circle/feed', 'POST', data)
export const getMultiCircleFeed = (data) => request('/api/circle/feed/multi', 'POST', data)
export const createCirclePost = (data) => request('/api/circle/post/create', 'POST', data)
export const toggleCircleLike = (data) => request('/api/circle/post/like', 'POST', data)
export const addCircleComment = (data) => request('/api/circle/comment/add', 'POST', data)
export const getCircleComments = (data) => request('/api/circle/comment/list', 'POST', data)
export const deleteCirclePost = (data) => request('/api/circle/post/delete', 'POST', data)
export const getCircleMembers = (circleId, memberId) => request('/api/circle/members', 'POST', { circleId: circleId, memberId: memberId })
export const getPendingCircleMembers = (memberId, memberType) => request('/api/circle/pending-members', 'POST', { memberId: memberId, memberType: memberType || 'child' })
export const approveCircleMember = (circleId, memberId, approved, adminMemberId) => request('/api/circle/approve', 'POST', { circleId: circleId, memberId: memberId, approved: approved, adminMemberId: adminMemberId })

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 })

}
// @deprecated 别名：委托到 getTaskHistory（已支持 category 参数），确保 /api/tasks/history 只有一处封装
export const getTaskHistoryByCategory = (memberId, category, page, size) => getTaskHistory(memberId, page || 1, size || 10, category)

// ===== 维度商品（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 getLatestIndicators = (data) => request('/api/health/indicators', 'POST', data)
export const getGutFloraIndicators = (data) => request('/api/health/gut-flora', 'POST', data)


export const createHealthReport = (data) => request('/api/health/report/create', 'POST', data)
// 健康报告列表：memberId 可选，不传时后端返回当前家庭的全部报告
export const getReportList = (memberId, size) => {
  var data = {}
  if (memberId) { data.memberId = memberId }
  if (size) { data.size = size }
  return request('/api/health/report/list', 'POST', data)
}
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', {})
// 报告 payload（编辑回填按需加载）
export const getReportPayload = (reportId) => request('/api/health/report/payload', 'POST', { reportId })

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 downloadReportFile = (reportId) => request('/api/health/report/download', '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, memberId) => {
  return new Promise((resolve, reject) => {
    const token = uni.getStorageSync('token')
    var query = ''
    if (type) query += '?type=' + type
    if (memberId) query += (query ? '&' : '?') + 'memberId=' + memberId
    uni.uploadFile({
      url: BASE_URL + '/api/health/report/upload-only' + query,
      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)
      }
    })
  })
}

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

// 查询异步采集状态（数据采集中→完成后自动入库）
export const getReportCollectStatus = (draftId) => request('/api/health/report/collect/status', 'POST', { draftId })

// 查询当前用户所有"采集中"的草稿
export const getCollectingReports = () => request('/api/health/report/collecting-list', 'POST', {})

// 放弃草稿
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（报告反馈：提交后由 AI 解答，可查看结果） =====
// 提交反馈：{ reportId?, draftId?, type: 'question'|'suggestion', content } → { id, feedbackType, content, aiAnswer, aiStatus, createdAt }
export const submitFeedback = (data) => request('/api/health/feedback/submit', 'POST', data)
// 我的反馈列表（含 AI 解答）：{ reportId? } → List<ReportFeedback>
export const getMyReportFeedbacks = (data) => request('/api/health/feedback/list', '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 getPearlResources = () => request('/api/pearl/resources', 'POST')
export const addPearlResource = (data) => request('/api/pearl/item/add', 'POST', data)
export const deletePearlResource = (data) => request('/api/pearl/item/delete', 'POST', data)
export const getConnectionTypes = () => request('/api/pearl/connection-types', 'POST')
export const addPearlInteraction = (data) => request('/api/pearl/interaction/add', 'POST', data)
export const getPearlInteractionList = (data) => request('/api/pearl/interaction/list', 'POST', data)
export const getPearlReminders = () => request('/api/pearl/reminder/list', 'POST')
export const updatePearlPriority = (data) => request('/api/pearl/item/update-priority', 'POST', data)
export const getAbilityMap = () => request('/api/ability/map', 'POST')

// ===== 章鱼图（关键人拓展） =====
export const getOctopusEffects = (data) => request('/api/octopus/effect/list', 'POST', data)
export const addOctopusEffect = (data) => request('/api/octopus/effect/add', 'POST', data)
export const deleteOctopusEffect = (data) => request('/api/octopus/effect/delete', 'POST', data)

export const addOctopusKeyPerson = (data) => request('/api/octopus/key-person/add', 'POST', data)
export const getOctopusKeyPersons = (data) => request('/api/octopus/key-person/list', 'POST', data)
export const updateOctopusKeyPerson = (data) => request('/api/octopus/key-person/update', 'POST', data)
export const deleteOctopusKeyPerson = (data) => request('/api/octopus/key-person/delete', 'POST', data)
export const getOctopusEffectKeyPersons = (data) => request('/api/octopus/effect/key-persons', 'POST', data)

export const getOctopusAnalysisKeywords = (data) => request('/api/octopus/analysis/keywords', 'POST', data)
export const getOctopusAnalysisSummary = (data) => request('/api/octopus/analysis/summary', 'POST', data)
export const getOctopusExpansionSuggest = (data) => request('/api/octopus/expansion/suggest', '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 getWeekFortune = () => request('/api/mind/fortune/week', 'POST')
export const getMonthFortune = () => request('/api/mind/fortune/month', 'POST')
export const getFortuneReports = () => request('/api/mind/fortune/reports', '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 getInnatePortrait = (data) => request('/api/mind/innate/portrait', 'POST', data)
export const getInnateReading = (data) => request('/api/mind/innate/reading', 'POST', data)
export const getInnateNumsoul = (data) => request('/api/mind/innate/numsoul', 'POST', data)
export const getInnateTrajectory = (data) => request('/api/mind/innate/trajectory', 'POST', data)

// ===== 健康维度 =====
export const getDimensionOverview = (data) => request('/api/dimension/overview', 'POST', data)
export const getRadarData = (data) => request('/api/dimension/radar-data', '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 regenerateSection = (data) => request('/api/health/plan/regenerate-section', 'POST', data)
export const confirmPlan = (data) => request('/api/health/plan/confirm', 'POST', data)
export const saveHealthPlan = (data) => request('/api/health/plan/save', 'POST', data)
// 规划师方案维护
export const getPendingReviewPlans = (data) => request('/api/health/plan/pending-review/list', 'POST', data)
export const updatePlanContent = (data) => request('/api/health/plan/pending-review/update', 'POST', data)
export const approvePlan = (data) => request('/api/health/plan/pending-review/approve', 'POST', data)
export const rejectPlan = (data) => request('/api/health/plan/pending-review/reject', '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 getHealthPlanTasks = (data) => request('/api/health/plan/tasks', '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', 'POST', {})
}

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

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

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

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

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

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 getSelfCheckStatus = () => {
  return request('/api/family/self-check/status', 'POST', {})
}

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

export const generateSelfCheckPlan = (data) => {
  return request('/api/family/self-check/generate-plan', 'POST', data || {})
}

export const getSelfCheckTrendAnalysis = () => {
  return request('/api/family/self-check/trend-analysis', 'POST', {})
}

// ===== MBTI 人格测评 =====
export const getMbtiQuestions = () => request('/api/family/mbti/questions', 'POST', {})
export const submitMbti = (data) => request('/api/family/mbti/submit', 'POST', data)
export const getMbtiLatest = () => request('/api/family/mbti/latest', 'POST', {})
export const getMbtiProfile = (data) => request('/api/family/mbti/profile', 'POST', data)

// ===== 五维手动填分 =====
export const submitManualScore = (data) => request('/api/family/manual-score/submit', 'POST', data)

// ===== 舌诊相关（两阶段流程） =====
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)

// ===== DAN 测评报告相关 =====
export const parseReportDraft = (draftId) => request('/api/health/report/parse', 'POST', { draftId })
export const confirmAssessmentReportConfirmInbox = (resultId, overallScore) => 
  request('/api/dan-assessment/result/' + resultId + '/confirm-inbox', 'POST', { overallScore })
export const getMyAssessmentPlans = (familyId, childId) => 
  request('/api/dan-assessment/result/plans/list', 'POST', { familyId, childId })
// 鎸囨爣瀹氫箟
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 })
}

// 查询疾病知识库（统一知识库 disease/query）
export const queryDiseaseKnowledge = (name) => {
  return request('/api/health/knowledge/unified/disease/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 = (memberId) => request('/api/health-status/get', 'POST', memberId ? { memberId: memberId } : {})
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 searchDietFoods = (keyword) => request('/api/diet/ingredients/search', 'POST', { keyword })
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 regenerateDietRecommendation = (data) => request('/api/diet/recommendation/regenerate', '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 })

// ===== 饮食打卡记录（diet-records 重设计） =====
export const getMealList = (data) => request('/api/health/meal/list', 'POST', data || {})
export const getMealDaily = (data) => request('/api/health/meal/daily', 'POST', data || {})
export const getMealWeekly = (data) => request('/api/health/meal/weekly', 'POST', data || {})
export const getMealAlerts = (data) => request('/api/health/meal/alerts', 'POST', data || {})
export const createMealRecord = (data) => request('/api/health/meal/create', 'POST', data || {})

// ===== 食材戒备匹配 =====
// reportId 可选：传了则按报告返回该次检测的戒备食材（报告详情入口）；
// 不传则按成员最新推荐指数返回（成长页当前戒备入口）
export const getFoodCautionList = (memberId, reportId) => {
  var data = {}
  if (memberId) data.memberId = memberId
  if (reportId) data.reportId = reportId
  return request('/api/food/recommendation/caution', 'POST', data)
}

// ===== 戒备页面家庭成员列表 =====
export const getCautionFamilyMembers = () => request('/api/food/recommendation/members', 'POST', {})

// ===== 戒备食材趋势数据 =====
export const getFoodCautionTrend = (memberId, foodIds) => {
  var data = {}
  if (memberId) data.memberId = memberId
  if (foodIds && foodIds.length) data.foodIds = foodIds
  return request('/api/food/recommendation/trend', 'POST', data)
}

// ===== 健康报告食材推荐（共用 /api/health/foods）=====
export const getHealthFoods = (reportId, memberId) => {
  var data = {}
  if (reportId) data.reportId = reportId
  if (memberId) data.memberId = memberId
  return request('/api/health/foods', 'POST', data)
}

// ===== 家庭平台积分（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)

// ===== 站内通知 =====
export const getNotificationList = () => request('/api/notification/list', 'POST', {})
export const readNotification = (data) => request('/api/notification/read', 'POST', data)

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

// 体脂秤指标保存
export const saveBodyFatMetrics = (data) => {
  return new Promise((resolve, reject) => {
    const token = uni.getStorageSync('token')
    uni.request({
      url: BASE_URL + '/api/health/report/bodyfat-save',
      method: 'POST',
      data: data,
      header: { 'Content-Type': 'application/json', 'Authorization': token ? 'Bearer ' + token : '' },
      success: (res) => {
        if (res.data && res.data.code === 200) {
          resolve(res.data)
        } else {
          reject(res.data || { code: -1, message: '保存失败' })
        }
      },
      fail: (err) => reject(err)
    })
  })
}

// 用户画像
export function getMyProfile() {
  return new Promise((resolve, reject) => {
    const token = uni.getStorageSync('token')
    uni.request({
      url: BASE_URL + '/api/profile/my',
      method: 'POST',
      data: {},
      header: { 'Content-Type': 'application/json', 'Authorization': token ? 'Bearer ' + token : '' },
      success: (res) => {
        if (res.data && res.data.code === 200) {
          resolve(res.data)
        } else {
          reject(res.data || { code: -1, message: '获取画像失败' })
        }
      },
      fail: (err) => reject(err)
    })
  })
}

export function getProfileTrend(days) {
  return new Promise((resolve, reject) => {
    const token = uni.getStorageSync('token')
    uni.request({
      url: BASE_URL + '/api/profile/history',
      method: 'POST',
      data: { days: days || 30 },
      header: { 'Content-Type': 'application/json', 'Authorization': token ? 'Bearer ' + token : '' },
      success: (res) => {
        if (res.data && res.data.code === 200) {
          resolve(res.data)
        } else {
          reject(res.data || { code: -1, message: '获取趋势失败' })
        }
      },
      fail: (err) => reject(err)
    })
  })
}

export const sttTranscribe = (filePath) => {
  return new Promise((resolve, reject) => {
    uni.uploadFile({
      url: BASE_URL + '/api/ai/transcribe',
      filePath: filePath,
      name: 'file',
      header: { 'Authorization': 'Bearer ' + uni.getStorageSync('token') },
      success: (res) => {
        try {
          var data = JSON.parse(res.data)
          if (data.code === 200 && data.data && data.data.text) {
            resolve(data.data.text)
          } else {
            reject(new Error(data.message || '转写失败'))
          }
        } catch (e) {
          reject(new Error('解析响应失败'))
        }
      },
      fail: (err) => {
        reject(new Error('上传失败: ' + (err.errMsg || '')))
      }
    })
  })
}

// 健康启航计划
export function checkPurchase() {
  return new Promise((resolve, reject) => {
    const token = uni.getStorageSync('token')
    uni.request({
      url: config.API_BASE_URL + '/api/purchase/check',
      method: 'POST',
      data: {},
      header: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + token },
      success: (res) => {
        if (res.data && res.data.code === 200) {
          resolve(res.data)
        } else {
          reject(res.data || { code: -1, message: '检查购买状态失败' })
        }
      },
      fail: (err) => reject(err)
    })
  })
}

export function createPurchaseOrder() {
  return new Promise((resolve, reject) => {
    const token = uni.getStorageSync('token')
    uni.request({
      url: config.API_BASE_URL + '/api/purchase/create',
      method: 'POST',
      data: {},
      header: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + token },
      success: (res) => {
        if (res.data && res.data.code === 200) {
          resolve(res.data)
        } else {
          reject(res.data || { code: -1, message: '创建订单失败' })
        }
      },
      fail: (err) => reject(err)
    })
  })
}

export function confirmPurchase(data) {
  return new Promise((resolve, reject) => {
    const token = uni.getStorageSync('token')
    uni.request({
      url: config.API_BASE_URL + '/api/purchase/confirm',
      method: 'POST',
      data: data,
      header: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + token },
      success: (res) => {
        if (res.data && res.data.code === 200) {
          resolve(res.data)
        } else {
          reject(res.data || { code: -1, message: '确认支付失败' })
        }
      },
      fail: (err) => reject(err)
    })
  })
}

export function getRenewalInfo() {
  return new Promise((resolve, reject) => {
    const token = uni.getStorageSync('token')
    uni.request({
      url: config.API_BASE_URL + '/api/purchase/renewal-info',
      method: 'POST',
      data: {},
      header: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + token },
      success: (res) => {
        if (res.data && res.data.code === 200) {
          resolve(res.data)
        } else {
          reject(res.data || { code: -1, message: '获取续费信息失败' })
        }
      },
      fail: (err) => reject(err)
    })
  })
}

// 健康启航计划：获取虚拟支付参数（下单后调用）
export function getPurchasePayParams(orderNo) {
  return new Promise((resolve, reject) => {
    const token = uni.getStorageSync('token')
    uni.request({
      url: config.API_BASE_URL + '/api/purchase/pay-params',
      method: 'POST',
      data: { orderNo: orderNo },
      header: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + token },
      success: (res) => {
        if (res.data && res.data.code === 200) {
          resolve(res.data)
        } else {
          reject(res.data || { code: -1, message: '获取支付参数失败' })
        }
      },
      fail: (err) => reject(err)
    })
  })
}

export function getChallengeProgress(memberId) {
  return request('/api/purchase/challenge/progress', 'POST', { memberId: memberId })
}

// ── 管家自助选择 ──
export function getAvailableButlers() {
  return request('/api/butler/available-list', 'POST', {})
}
export function getMyButler() {
  return request('/api/butler/my-butler', 'POST', {})
}
export function selectButler(butlerUserId) {
  return request('/api/butler/select', 'POST', { butlerUserId })
}

// ── 用户画像 ──
export function getPortrait(params = {}) {
  return request('/api/user/portrait/get', 'POST', params)
}
export function editPortrait(data) {
  return request('/api/user/portrait/edit', 'POST', data)
}
export function generatePortrait(params = {}) {
  return request('/api/user/portrait/generate', 'POST', params)
}
export function regeneratePortrait(params = {}) {
  return request('/api/user/portrait/regenerate', 'POST', params)
}

export const shopDiscountCalculate = (params) => {
  return request('/api/shop/discount/calculate', 'POST', params || {})
}

// ── 首页快捷方式 ──
export const getAppLibrary = () => request('/api/home/app-library', 'POST', {})
export const saveShortcutConfig = (items) => request('/api/home/shortcut/save', 'POST', { items })
export const reportAppEnter = (appKey) => request('/api/home/app/enter', 'POST', { appKey })
export const resetShortcutConfig = () => request('/api/home/shortcut/reset', 'POST', {})
export function getOrchestrationFlowList(params = {}) {
  return request('/api/orchestration/flow/list', 'POST', params)
}
export function getOrchestrationFlowDetail(flowId) {
  return request('/api/orchestration/flow/detail', 'POST', { flowId })
}
export function saveOrchestrationFlow(data) {
  return request('/api/orchestration/flow/save', 'POST', data)
}
export function publishOrchestrationFlow(flowId) {
  return request('/api/orchestration/flow/publish', 'POST', { flowId })
}
export function archiveOrchestrationFlow(flowId) {
  return request('/api/orchestration/flow/archive', 'POST', { flowId })
}
export function deleteOrchestrationFlow(flowId) {
  return request('/api/orchestration/flow/delete', 'POST', { flowId })
}
export function startOrchestrationExecution(data) {
  return request('/api/orchestration/execution/start', 'POST', data)
}
export function getOrchestrationExecutionDetail(executionId) {
  return request('/api/orchestration/execution/detail', 'POST', { executionId })
}
export function terminateOrchestrationExecution(data) {
  return request('/api/orchestration/execution/terminate', 'POST', data)
}
export function getNodeTemplateList(params = {}) {
  return request('/api/admin/task-templates', 'POST', params)
}

export const getHomeBanners = () => request('/api/home-banner/list', 'POST', {})