/**
 * @Description: Mock 数据生成工具 - 用于测试分页加载功能
 * @Date: 2026-02-08
 * @update 2026-02-27: 添加文章模块 Mock 数据支持
 *
 * 支持的 API Mock:
 * - weekHotAPI: 周热门资料（已废弃，使用 articleWeekHotAPI）
 * - fileListAPI: 资料列表（已废弃，使用 articleListAPI）
 * - listAPI: 产品列表
 * - searchAPI: 搜索(产品+资料)
 * - myListAPI: 消息列表
 * - favoriteListAPI: 收藏列表（已废弃，使用 articleFavoriteAPI）
 * - feedbackListAPI: 意见反馈列表
 * - planListAPI: 计划书列表
 * - articleListAPI: 文章列表（新增）
 * - articleWeekHotAPI: 热门文章（新增）
 * - articleDetailAPI: 文章详情（新增）
 * - articleFavoriteAPI: 文章收藏列表（新增）
 */

// ============================================================================
// 工具函数
// ============================================================================

/**
 * 生成随机文件大小
 * @returns {string} 文件大小(如 "2.5MB")
 */
function generateRandomSize() {
  const sizeInMB = (Math.random() * 10 + 0.5).toFixed(1)
  return `${sizeInMB}MB`
}

/**
 * 生成随机学习人数
 * @returns {number} 学习人数(100-5000之间)
 */
function generateRandomReadCount() {
  return Math.floor(Math.random() * 4900) + 100
}

/**
 * 生成随机学习百分比
 * @returns {number} 学习百分比(0-100之间)
 */
function generateRandomReadPercent() {
  return Math.floor(Math.random() * 100)
}

/**
 * 生成随机收藏状态
 * @returns {string} '1' 或 '0'
 */
function generateRandomFavorite() {
  return Math.random() > 0.7 ? '1' : '0'
}

/**
 * 模拟网络延迟
 * @param {number} min 最小延迟(ms)
 * @param {number} max 最大延迟(ms)
 * @returns {Promise}
 */
function mockDelay(min = 100, max = 300) {
  const delay = Math.random() * (max - min) + min
  return new Promise(resolve => setTimeout(resolve, delay))
}

// ============================================================================
// 真实的测试文件地址（可预览）
// ============================================================================

/**
 * 真实的可预览测试文件地址
 *
 * 来源说明：
 * - 项目 CDN: cdn.ipadbiz.cn（项目自有 CDN，最稳定）
 * - calibre-ebook.com: Calibre 官方测试文件
 * - filesamples.com: 文件格式测试样本
 * - Microsoft: 官方示例文件
 */
const TEST_FILES = {
  // PDF 文档（优先使用项目 CDN）
  pdf: [
    'https://cdn.ipadbiz.cn/manulife/document/test.pdf',  // 项目 CDN（最可靠）
    'https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf',
    'https://www.africau.edu/images/default/sample.pdf'
  ],

  // Word 文档 (docx)
  docx: [
    'https://calibre-ebook.com/downloads/demos/demo.docx'
  ],

  // Excel 表格 (xlsx)
  xlsx: [
    'https://filesamples.com/samples/document/xlsx/sample1.xlsx',  // filesamples 更稳定
    'https://go.microsoft.com/fwlink/?LinkID=512104&clcid=0x0409'
  ],

  // PPT 演示文稿 (ppt/pptx)
  pptx: [
    'https://www.africau.edu/images/default/sample.pptx',
    'https://filesamples.com/samples/document/ppt/sample1.ppt'
  ],

  // 图片
  jpg: [
    'https://picsum.photos/seed/test1/800/600.jpg',
    'https://picsum.photos/seed/test2/800/600.jpg',
    'https://picsum.photos/seed/test3/800/600.jpg'
  ],

  // PNG 图片
  png: [
    'https://picsum.photos/seed/test4/800/600.png',
    'https://picsum.photos/seed/test5/800/600.png'
  ],

  // 文本文件（使用 GitHub raw）
  txt: [
    'https://raw.githubusercontent.com/torvalds/linux/master/README',
    'https://raw.githubusercontent.com/github/gitignore/main/README'
  ]
}

/**
 * 根据文件类型获取测试文件地址
 * @param {string} extension - 文件扩展名
 * @param {number} seed - 随机种子
 * @returns {string} 测试文件地址
 */
function getTestFileUrl(extension, seed = 0) {
  const files = TEST_FILES[extension] || TEST_FILES.pdf
  const index = seed % files.length
  return files[index]
}

// ============================================================================
// 1. 周热门资料 Mock (weekHotAPI)
// ============================================================================

const WEEK_HOT_MATERIALS = [
  '财富管理基础知识指南',
  '保险产品销售技巧',
  '客户关系管理实战',
  '家庭资产配置方案',
  '税务筹划实用手册',
  '退休规划完整教程',
  '投资组合管理策略',
  '风险控制与合规要求',
  '高净值客户开发指南',
  '理财产品营销话术',
  '基金定投实战技巧',
  '保单整理服务流程',
  '传承规划案例分析',
  '健康险产品对比分析',
  '年金保险销售指南',
  '重疾险核保知识',
  '教育金规划方案',
  '房贷规划实务操作',
  '家族信托业务介绍',
  '私募股权投资指南'
]

const FILE_TYPES = [
  { extension: 'pdf', name: 'PDF文档' },
  { extension: 'doc', name: 'Word文档' },
  { extension: 'docx', name: 'Word文档' },
  { extension: 'xls', name: 'Excel表格' },
  { extension: 'xlsx', name: 'Excel表格' },
  { extension: 'ppt', name: 'PPT演示文稿' },
  { extension: 'pptx', name: 'PPT演示文稿' },
  { extension: 'txt', name: '文本文件' },
  { extension: 'jpg', name: '图片' },
  { extension: 'png', name: '图片' }
]

/**
 * 生成周热门资料数据
 */
function generateWeekHotItem(id) {
  const fileType = FILE_TYPES[Math.floor(Math.random() * FILE_TYPES.length)]
  const materialName = WEEK_HOT_MATERIALS[Math.floor(Math.random() * WEEK_HOT_MATERIALS.length)]

  // 获取真实的测试文件地址
  const testFileUrl = getTestFileUrl(fileType.extension, id)

  return {
    meta_id: id,
    name: `${materialName} ${fileType.name.toUpperCase()}`,
    src: `https://picsum.photos/seed/material-${id}-${fileType.extension}/100/100`,
    size: generateRandomSize(),
    read_people_count: generateRandomReadCount(),
    read_people_percent: generateRandomReadPercent(),
    is_favorite: generateRandomFavorite(),
    extension: fileType.extension,
    downloadUrl: testFileUrl  // 使用真实的测试文件地址
  }
}

/**
 * Mock: weekHotAPI
 */
export async function mockWeekHotAPI(params) {
  await mockDelay()

  const { page = 0, limit = 20 } = params
  const totalPages = 5

  if (page >= totalPages) {
    return { code: 1, msg: 'success', data: { list: [] } }
  }

  const list = []
  const startIndex = page * limit

  for (let i = 0; i < limit; i++) {
    list.push(generateWeekHotItem(startIndex + i + 1))
  }

  console.log(`[Mock] weekHotAPI - 第${page}页,共${list.length}条`)

  return { code: 1, msg: 'success', data: { list } }
}

// ============================================================================
// 2. 资料列表 Mock (fileListAPI)
// ============================================================================

const MATERIAL_NAMES = [
  '2024年保险行业发展趋势报告',
  '高净值客户开发实战手册',
  '家庭保障需求分析模板',
  '养老规划产品对比表',
  '教育金储备方案',
  '重疾险条款解读',
  '百万医疗险销售指南',
  '年金险产品培训资料',
  '终身寿险销售技巧',
  '车险理赔流程说明',
  '企业财产险基础知识',
  '责任险产品介绍',
  '意外险保障方案',
  '健康险核保手册',
  '投保实务操作指南',
  '客户异议处理话术',
  '保单托管服务流程',
  '理赔案例分析',
  '保险法律法规汇编',
  '行业合规要求解读'
]

/**
 * 生成资料列表项
 */
function generateMaterialItem(id) {
  const fileType = FILE_TYPES[Math.floor(Math.random() * FILE_TYPES.length)]
  const materialName = MATERIAL_NAMES[Math.floor(Math.random() * MATERIAL_NAMES.length)]

  // 获取真实的测试文件地址
  const testFileUrl = getTestFileUrl(fileType.extension, id)

  return {
    id: id,
    meta_id: id,
    name: materialName,
    title: materialName,
    fileName: `${materialName}.${fileType.extension}`,
    desc: '这是一份详细的培训资料，包含丰富的案例和实战技巧...',
    size: generateRandomSize(),
    extension: fileType.extension,
    collected: generateRandomFavorite() === '1',
    src: `https://picsum.photos/seed/file-${id}-${fileType.extension}/100/100`,
    downloadUrl: testFileUrl,  // 使用真实的测试文件地址
    post_date: new Date().toISOString(),
    value: testFileUrl  // 使用真实的测试文件地址
  }
}

/**
 * Mock: fileListAPI
 */
export async function mockFileListAPI(params) {
  await mockDelay()

  const { page = 0, limit = 20, cid, keyword, child_id } = params
  const totalPages = 8

  if (page >= totalPages) {
    return { code: 1, msg: 'success', data: { list: [], total: totalPages * limit } }
  }

  const list = []
  const startIndex = page * limit

  for (let i = 0; i < limit; i++) {
    const item = generateMaterialItem(startIndex + i + 1)

    // 如果有关键词搜索，过滤数据
    if (keyword && !item.name.includes(keyword)) {
      continue
    }

    list.push(item)
  }

  console.log(`[Mock] fileListAPI - 第${page}页,共${list.length}条`)

  return {
    code: 1,
    msg: 'success',
    data: {
      list,
      total: totalPages * limit,
      max_level: 2,
      cate: {
        id: parseInt(cid) || 1,
        category_name: '培训资料',
        category_parent: 0,
        category_description: null
      }
    }
  }
}

// ============================================================================
// 3. 产品列表 Mock (listAPI)
// ============================================================================

const PRODUCT_NAMES = [
  '百万年金保险计划',
  '终身寿险至尊版',
  '重疾险保障计划',
  '百万医疗险',
  '意外伤害保险',
  '教育金保险计划',
  '养老理财保险',
  '高端医疗险',
  '定期寿险',
  '终身寿险',
  '企业年金保险',
  '团体意外险',
  '家庭财产保险',
  '责任保险系列',
  '旅游保险',
  '留学保险',
  '健康保险计划',
  '车辆保险',
  '财产一切险',
  '工程保险'
]

const PRODUCT_TAGS = [
  { id: 1, name: '热销', bg_color: '#FEE2E2', text_color: '#DC2626' },
  { id: 2, name: '新品', bg_color: '#DBEAFE', text_color: '#2563EB' },
  { id: 3, name: '推荐', bg_color: '#D1FAE5', text_color: '#059669' },
  { id: 4, name: '限时', bg_color: '#FEF3C7', text_color: '#D97706' }
]

const PRODUCT_CATEGORIES = [
  { id: 1, name: '人寿保险' },
  { id: 2, name: '健康保险' },
  { id: 3, name: '意外保险' },
  { id: 4, name: '财产保险' }
]

/**
 * 生成产品列表项
 */
/**
 * 生成产品列表项（符合真实 API 结构）
 *
 * @param {number} id - 产品 ID
 * @param {string} formSn - 表单标识（可选）
 * @returns {Object} 产品对象
 */
function generateProductItem(id, formSn) {
  const productName = PRODUCT_NAMES[Math.floor(Math.random() * PRODUCT_NAMES.length)]
  const recommend = Math.random() > 0.7 ? 'hot' : ''

  // 随机选择1-2个标签
  const tags = []
  const tagCount = Math.floor(Math.random() * 2) + 1
  const availableTags = [...PRODUCT_TAGS].sort(() => Math.random() - 0.5)

  for (let i = 0; i < tagCount; i++) {
    tags.push(availableTags[i])
  }

  // 随机选择分类
  const categoryId = Math.floor(Math.random() * 4) + 1
  const category = PRODUCT_CATEGORIES.find(c => parseInt(c.id) === categoryId)

  return {
    id: id,
    product_name: productName,
    cover_image: `https://picsum.photos/seed/product-${id}/400/300`,
    recommend: recommend,
    form_sn: formSn || `product-template-${categoryId}`, // 关键：对应模板的 form_sn
    created_time: new Date().toISOString(),
    categories: [category], // ✅ 真实 API 结构：categories 是数组
    tags: tags
  }
}

/**
 * Mock: listAPI (产品列表)
 */
export async function mockProductListAPI(params) {
  await mockDelay()

  const { page = 0, limit = 10, cid, keyword } = params
  const totalPages = 10

  if (page >= totalPages) {
    return { code: 1, msg: 'success', data: { list: [], categories: [], total: 0 } }
  }

  const list = []
  const startIndex = page * limit

  // 🔧 测试商品：第一页前两位固定为测试产品
  if (page === 0) {
    const testCategory = PRODUCT_CATEGORIES.find(c => parseInt(c.id) === 1)

    // 测试商品1: 储蓄产品
    const testProduct1 = {
      id: 'savings-2-148b3acd',
      product_name: '测试计划书-智享未来2（form_sn:savings-2-148b3acd）',
      cover_image: 'https://picsum.photos/seed/savings-2-148b3acd/400/300',
      recommend: 'hot',
      form_sn: 'savings-2-148b3acd', // ✅ 关键字段：对应真实 API 的 form_sn
      created_time: new Date().toISOString(),
      categories: [testCategory], // ✅ 符合真实 API 结构：categories 是数组
      tags: [{ id: '1', name: '热销', bg_color: '#FEE2E2', text_color: '#DC2626' }],
      // 测试标识（不影响业务逻辑）
      _test: true,
      _test_note: 'form_sn:savings-2-148b3acd'
    }

    // 测试商品2: 人寿保险产品
    const testProduct2 = {
      id: 'life-insurance-3-d8fde07d',
      product_name: '测试计划书-人生无忧3（form_sn:life-insurance-3-d8fde07d）',
      cover_image: 'https://picsum.photos/seed/life-insurance-3-d8fde07d/400/300',
      recommend: 'hot',
      form_sn: 'life-insurance-3-d8fde07d', // ✅ 关键字段：对应真实 API 的 form_sn
      created_time: new Date().toISOString(),
      categories: [testCategory], // ✅ 符合真实 API 结构：categories 是数组
      tags: [{ id: '1', name: '热销', bg_color: '#FEE2E2', text_color: '#DC2626' }],
      // 测试标识（不影响业务逻辑）
      _test: true,
      _test_note: 'form_sn:life-insurance-3-d8fde07d'
    }

    // 检查分类和关键词过滤，依次添加测试商品
    const testProducts = [testProduct1, testProduct2]

    testProducts.forEach((testProduct, index) => {
      let shouldInclude = true
      if (cid && !testProduct.categories.some(c => parseInt(c.id) === parseInt(cid))) {
        shouldInclude = false
      }
      if (keyword && !testProduct.product_name.includes(keyword)) {
        shouldInclude = false
      }

      if (shouldInclude) {
        list.push(testProduct)
        console.log(`[Mock] listAPI - 测试商品${index + 1}已置顶: form_sn=${testProduct.form_sn}`)
      }
    })
  }

  for (let i = 0; i < limit; i++) {
    const item = generateProductItem(startIndex + i + 1)

    // 如果有分类过滤
    if (cid && item.category_id !== parseInt(cid)) {
      continue
    }

    // 如果有关键词搜索
    if (keyword && !item.product_name.includes(keyword)) {
      continue
    }

    list.push(item)
  }

  console.log(`[Mock] listAPI - 第${page}页,共${list.length}条`)

  return {
    code: 1,
    msg: 'success',
    data: {
      list,
      categories: PRODUCT_CATEGORIES,
      total: totalPages * limit
    }
  }
}

// ============================================================================
// 4. 搜索 Mock (searchAPI)
// ============================================================================

/**
 * Mock: searchAPI (支持产品和资料搜索)
 */
export async function mockSearchAPI(params) {
  await mockDelay()

  const { page = 0, limit = 20, keyword, type } = params

  if (!keyword) {
    // 🔧 优化：如果没有关键词，返回更多推荐数据用于测试
    // 生成20个产品和20个文章作为默认搜索结果
    const defaultProducts = []
    const defaultArticles = []

    for (let i = 0; i < 20; i++) {
      const productItem = generateProductItem(i + 1)
      defaultProducts.push({
        ...productItem,
        id: i + 1,
        cover_image: productItem.cover_image
      })

      const articleItem = generateArticleItem(i + 1)
      defaultArticles.push(articleItem)
    }

    console.log(`[Mock] searchAPI - 无关键词，返回默认数据:产品${defaultProducts.length}条,文章${defaultArticles.length}条`)
    return {
      code: 1,
      msg: 'success',
      data: {
        products: { list: defaultProducts, total: defaultProducts.length * 5 },
        article: { list: defaultArticles, total: defaultArticles.length * 5 }
      }
    }
  }

  const totalPages = 5

  if (page >= totalPages) {
    return {
      code: 1,
      msg: 'success',
      data: {
        products: { list: [], total: 0 },
        article: { list: [], total: 0 }
      }
    }
  }

  const products = []
  const articles = []
  const startIndex = page * limit

  // 🔧 优化：每次循环都生成数据和尝试匹配，增加命中率
  for (let i = 0; i < limit / 2; i++) {
    // 产品
    const productItem = generateProductItem(startIndex + i + 1)
    const productName = productItem.product_name.toLowerCase()
    const searchKeyword = keyword.toLowerCase()

    // 🔧 优化：更宽松的搜索条件
    // 1. 完全匹配
    // 2. 拆分关键词，包含任意一个字符即可
    // 3. 关键词长度 >= 2 时，只要产品名称包含任意连续2个字符
    const keywords = searchKeyword.split('').filter(k => k.trim())
    const hasAnyChar = keywords.length > 0 && keywords.some(k => productName.includes(k))
    const hasBigram = searchKeyword.length >= 2 && keywords.slice(0, -1).some((k, idx) => productName.includes(k + keywords[idx + 1]))

    if (productName.includes(searchKeyword) || hasAnyChar || hasBigram) {
      products.push({
        ...productItem,
        id: startIndex + i + 1,
        cover_image: productItem.cover_image
      })
    }

    // 文章
    const articleItem = generateArticleItem(startIndex + i + 100)
    const articleTitle = articleItem.post_title.toLowerCase()

    const hasAnyCharArticle = keywords.length > 0 && keywords.some(k => articleTitle.includes(k))
    const hasBigramArticle = searchKeyword.length >= 2 && keywords.slice(0, -1).some((k, idx) => articleTitle.includes(k + keywords[idx + 1]))

    if (articleTitle.includes(searchKeyword) || hasAnyCharArticle || hasBigramArticle) {
      articles.push(articleItem)
    }
  }

  // 🔧 优化：如果没有匹配到任何数据，返回一些推荐数据
  if (products.length === 0 && articles.length === 0) {
    console.log(`[Mock] searchAPI - 无匹配结果，返回推荐数据`)
    // 生成 5 个推荐产品
    for (let i = 0; i < 5; i++) {
      const productItem = generateProductItem(startIndex + i + 1)
      products.push({
        ...productItem,
        id: startIndex + i + 1,
        cover_image: productItem.cover_image
      })

      const articleItem = generateArticleItem(startIndex + i + 100)
      articles.push(articleItem)
    }
  }

  console.log(`[Mock] searchAPI - 第${page}页,关键词"${keyword}",产品${products.length}条,文章${articles.length}条`)

  return {
    code: 1,
    msg: 'success',
    data: {
      products: { list: products, total: products.length * totalPages },
      article: { list: articles, total: articles.length * totalPages }
    }
  }
}

// ============================================================================
// 5. 消息列表 Mock (myListAPI)
// ============================================================================

const MESSAGE_TITLES = [
  '关于2024年新产品上线通知',
  '系统升级维护公告',
  '您的保单已生效提醒',
  '理赔进度更新通知',
  '续费提醒',
  '活动邀请：财富管理讲座',
  '客户服务满意度调查',
  '最新培训资料已上线',
  '合规要求更新通知',
  '节日问候与祝福',
  '产品停售通知',
  '核保政策调整',
  '理赔流程优化说明',
  '客户权益保障计划',
  '数字化服务升级公告'
]

/**
 * 生成消息列表项
 *
 * @description 按 API 规范生成消息 Mock 数据
 * @param {number} id - 消息 ID
 * @returns {Object} 消息对象
 */
function generateMessageItem(id) {
  const title = MESSAGE_TITLES[Math.floor(Math.random() * MESSAGE_TITLES.length)]
  const now = new Date()
  const createDate = new Date(now.getTime() - Math.random() * 30 * 24 * 60 * 60 * 1000)
  const isUnread = Math.random() > 0.5

  return {
    id: id,
    title: title,  // API 返回的标题字段
    note: `这是一条关于"${title}"的通知。\n点击查看详情了解更多信息。`,  // 消息内容（note 字段）
    created_time: formatDate(createDate),  // 发消息时间
    status: isUnread ? 'send' : 'read',  // send=已发送未读取，read=已读取
    pk_id: Math.floor(Math.random() * 10000)  // 计划书订单 ID（可选）
  }
}

/**
 * 格式化日期
 */
function formatDate(date) {
  const year = date.getFullYear()
  const month = String(date.getMonth() + 1).padStart(2, '0')
  const day = String(date.getDate()).padStart(2, '0')
  return `${year}-${month}-${day}`
}

/**
 * Mock: myListAPI (消息列表)
 *
 * @description 第1页（page=0）前面会插入三条测试消息用于测试计划书查看功能
 */
export async function mockMessageListAPI(params) {
  await mockDelay()

  const { page = 0, limit = 10 } = params  // 前端传的是从0开始的页码
  const totalPages = 8

  if (page >= totalPages) {
    return { code: 1, msg: 'success', data: { list: [] } }
  }

  const list = []

  // 第1页（page=0）：在前面插入三条测试消息（用于测试计划书查看）
  if (page === 0) {
    list.push(
      {
        id: '1001',
        title: '【测试】已生成计划书（单文件）',
        note: '测试场景：状态为"已生成"，只有一个计划书文件，可直接查看。',
        created_time: '2026-02-13',
        status: 'send'
      },
      {
        id: '1002',
        title: '【测试】已生成计划书（多文件）',
        note: '测试场景：状态为"已生成"，有3个计划书文件，点击后会显示选择弹框。',
        created_time: '2026-02-13',
        status: 'send'
      },
      {
        id: '1003',
        title: '【测试】已查看计划书',
        note: '测试场景：状态为"已查看"，查看后不会再次标记。',
        created_time: '2026-02-13',
        status: 'read'
      }
    )
  }

  const startIndex = page * limit
  const remainingCount = limit - list.length

  for (let i = 0; i < remainingCount; i++) {
    list.push(generateMessageItem(startIndex + i + 1))
  }

  console.log(`[Mock] myListAPI - 第${page}页,共${list.length}条`)

  return {
    code: 1,
    msg: 'success',
    data: { list }
  }
}

/**
 * Mock: detailAPI (消息详情)
 *
 * @description 根据 ID 返回消息详情，包含完整的 proposal 数据
 * @param {Object} params 请求参数
 * @param {string|number} params.i 消息ID
 * @returns {Promise} 详情数据
 *
 * @description 测试数据说明：
 * - id='1001': 已生成 + 单文件
 * - id='1002': 已生成 + 多文件 (3个文件)
 * - id='1003': 已查看 + 单文件
 * - 其他ID: 待处理状态 + 2个文件
 */
export async function mockDetailAPI(params) {
  await mockDelay()

  const { i: id } = params

  if (!id) {
    return { code: 0, msg: '消息ID不能为空', data: null }
  }

  // 生成基础消息数据
  const messageItem = generateMessageItem(id)

  // 根据消息 ID 返回不同状态的计划书数据（用于测试）
  let proposal = null

  if (id === '1001') {
    // 场景1: 已生成 + 单文件
    proposal = {
      id: 1001,
      customer_name: '张三',
      product_name: '年金险产品A',
      categories: [{ id: '1', name: '基本信息' }],
      created_time: messageItem.created_time,
      order_status: '7',  // 已生成
      proposal_files: [
        {
          id: 1,
          file_name: '计划书.pdf',
          file_url: TEST_FILES.pdf[0] // 使用真实的 PDF 测试文件
        }
      ]
    }
  } else if (id === '1002') {
    // 场景2: 已生成 + 多文件 (3个文件)
    proposal = {
      id: 1002,
      customer_name: '李四',
      product_name: '终身寿险产品B',
      categories: [
        { id: '1', name: '基本信息' },
        { id: '2', name: '保障内容' },
        { id: '3', name: '缴费方式' }
      ],
      created_time: messageItem.created_time,
      order_status: '7',  // 已生成
      proposal_files: [
        {
          id: 1,
          file_name: '计划书完整版.pdf',
          file_url: TEST_FILES.pdf[0]
        },
        {
          id: 2,
          file_name: '产品条款说明书.pdf',
          file_url: TEST_FILES.pdf[0]
        },
        {
          id: 3,
          file_name: '费率表.pdf',
          file_url: TEST_FILES.pdf[0]
        }
      ]
    }
  } else if (id === '1003') {
    // 场景3: 已查看 + 单文件
    proposal = {
      id: 1003,
      customer_name: '王五',
      product_name: '重疾险产品C',
      categories: [{ id: '1', name: '基本信息' }],
      created_time: messageItem.created_time,
      order_status: '9',  // 已查看
      proposal_files: [
        {
          id: 1,
          file_name: '计划书.pdf',
          file_url: TEST_FILES.pdf[0]
        }
      ]
    }
  } else {
    // 默认: 待处理状态 + 2个文件（无法查看）
    proposal = {
      id: id,
      customer_name: '测试用户',
      product_name: '测试产品',
      categories: [{ id: '1', name: '基本信息' }],
      created_time: messageItem.created_time,
      order_status: '3',  // 待处理
      proposal_files: [
        {
          id: 1,
          file_name: '计划书文件.pdf',
          file_url: TEST_FILES.pdf[0]
        },
        {
          id: 2,
          file_name: '产品说明.pdf',
          file_url: TEST_FILES.pdf[0]
        }
      ]
    }
  }

  console.log(`[Mock] detailAPI - 消息ID: ${id}, 计划书状态: ${proposal.order_status}`)

  return {
    code: 1,
    msg: 'success',
    data: {
      ...messageItem,
      proposal
    }
  }
}

// ============================================================================
// 6. 收藏列表 Mock (favoriteListAPI)
// ============================================================================

const FAVORITE_MATERIALS = [
  '财富管理基础知识指南',
  '保险产品销售技巧',
  '客户关系管理实战',
  '家庭资产配置方案',
  '税务筹划实用手册',
  '退休规划完整教程',
  '投资组合管理策略',
  '风险控制与合规要求',
  '高净值客户开发指南',
  '理财产品营销话术',
  '基金定投实战技巧',
  '保单整理服务流程',
  '传承规划案例分析',
  '健康险产品对比分析',
  '年金保险销售指南',
  '重疾险核保知识',
  '教育金规划方案',
  '房贷规划实务操作',
  '家族信托业务介绍',
  '私募股权投资指南'
]

/**
 * 生成收藏列表项
 */
function generateFavoriteItem(id) {
  const fileType = FILE_TYPES[Math.floor(Math.random() * FILE_TYPES.length)]
  const materialName = FAVORITE_MATERIALS[Math.floor(Math.random() * FAVORITE_MATERIALS.length)]
  const now = new Date()
  const createDate = new Date(now.getTime() - Math.random() * 90 * 24 * 60 * 60 * 1000)

  // 获取真实的测试文件地址
  const testFileUrl = getTestFileUrl(fileType.extension, id)

  return {
    meta_id: id,
    name: `${materialName}.${fileType.extension}`,
    size: generateRandomSize(),
    src: `https://picsum.photos/seed/favorite-${id}-${fileType.extension}/100/100`,
    downloadUrl: testFileUrl,  // 添加下载地址
    extension: fileType.extension,  // 添加文件扩展名
    created_time: formatDate(createDate)
  }
}

/**
 * Mock: favoriteListAPI (收藏列表)
 */
export async function mockFavoriteListAPI(params) {
  await mockDelay()

  const { page = 0, limit = 20 } = params
  const totalPages = 3

  if (page >= totalPages) {
    return { code: 1, msg: 'success', data: { list: [] } }
  }

  const list = []
  const startIndex = page * limit

  for (let i = 0; i < limit; i++) {
    list.push(generateFavoriteItem(startIndex + i + 1))
  }

  console.log(`[Mock] favoriteListAPI - 第${page}页,共${list.length}条`)

  return {
    code: 1,
    msg: 'success',
    data: { list }
  }
}

// ============================================================================
// 7. 意见反馈列表 Mock (feedbackListAPI)
// ============================================================================

const FEEDBACK_CATEGORIES = ['1', '3', '7'] // 1=功能建议, 3=问题反馈, 7=其他问题
const FEEDBACK_NOTES = [
  '希望能够增加资料下载功能',
  '产品详情页加载速度较慢',
  '收藏功能使用不便，建议优化',
  '搜索结果不够准确',
  '希望能够添加学习进度跟踪',
  '界面颜色有点太深了',
  '建议添加夜间模式',
  '资料分类不够清晰',
  '希望能够离线查看资料',
  '登录后总是会重新要求登录',
  '视频播放有时会卡顿',
  '希望能够支持分享到朋友圈',
  '字体大小无法调整',
  '建议增加资料收藏夹分类',
  '消息通知太频繁了',
  '希望能够批量管理收藏',
  '产品对比功能不够直观',
  '建议添加更多实用工具',
  '客服回复速度有待提升'
]

const FEEDBACK_REPLIES = [
  '感谢您的宝贵建议，我们会尽快优化！',
  '您反馈的问题我们已经记录，技术团队正在处理中。',
  '好的，我们会考虑您的建议。',
  '非常感谢您的反馈，这对我们改进产品很有帮助。',
  '您提到的问题我们已经收到，会在下个版本中优化。',
  '感谢您的支持，我们会继续改进产品体验。'
]

/**
 * 生成反馈列表项
 */
function generateFeedbackItem(id) {
  const category = FEEDBACK_CATEGORIES[Math.floor(Math.random() * FEEDBACK_CATEGORIES.length)]
  const note = FEEDBACK_NOTES[Math.floor(Math.random() * FEEDBACK_NOTES.length)]
  const status = Math.random() > 0.6 ? 5 : 1 // 60%概率已处理
  const hasReply = status === 5 && Math.random() > 0.3 // 已处理的有70%概率有回复
  const hasImages = Math.random() > 0.7 // 30%概率有图片

  const now = new Date()
  const createDate = new Date(now.getTime() - Math.random() * 60 * 24 * 60 * 60 * 1000)
  const replyDate = new Date(createDate.getTime() + Math.random() * 7 * 24 * 60 * 60 * 1000)

  // 生成随机图片
  const images = []
  if (hasImages) {
    const imageCount = Math.floor(Math.random() * 3) + 1
    for (let i = 0; i < imageCount; i++) {
      images.push(`https://picsum.photos/seed/feedback-${id}-${i}/200/200`)
    }
  }

  return {
    id: id,
    category: category,
    status: status,
    note: note,
    images: images,
    contact: Math.random() > 0.5 ? '138****8888' : '',
    reply: hasReply ? FEEDBACK_REPLIES[Math.floor(Math.random() * FEEDBACK_REPLIES.length)] : '',
    reply_time: hasReply ? formatDate(replyDate) : ''
  }
}

/**
 * Mock: feedbackListAPI (意见反馈列表)
 */
export async function mockFeedbackListAPI(params) {
  await mockDelay()

  const { page = 0, limit = 10 } = params
  const totalPages = 5

  if (page >= totalPages) {
    return { code: 1, msg: 'success', data: { list: [] } }
  }

  const list = []
  const startIndex = page * limit

  for (let i = 0; i < limit; i++) {
    list.push(generateFeedbackItem(startIndex + i + 1))
  }

  console.log(`[Mock] feedbackListAPI - 第${page}页,共${list.length}条`)

  return {
    code: 1,
    msg: 'success',
    data: { list }
  }
}

// ============================================================================
// 8. 计划书列表 Mock (planListAPI)
// ============================================================================

const PLAN_PRODUCT_NAMES = [
  '终身寿险至尊版',
  '重疾险保障计划',
  '百万年金保险计划',
  '高端医疗险',
  '养老理财保险',
  '教育金保险计划',
  '意外伤害保险',
  '定期寿险',
  '终身寿险',
  '企业年金保险',
  '团体意外险',
  '健康保险计划'
]

const PLAN_STATUS = ['3', '5', '7', '9'] // 3=待处理, 5=处理中, 7=已生成, 9=已查看

const PLAN_CATEGORIES = [
  { id: '1', name: '人寿保险' },
  { id: '2', name: '重疾险' },
  { id: '3', name: '医疗险' },
  { id: '4', name: '年金险' },
  { id: '5', name: '意外险' }
]

const CUSTOMER_NAMES = [
  '张三', '李四', '王五', '赵六', '钱七',
  '孙八', '周九', '吴十', '郑十一', '陈十二',
  '刘十三', '黄十四', '杨十五', '朱十六', '胡十七'
]

/**
 * 生成计划书列表项
 * @param {number} id - 计划书ID
 * @returns {Object} 计划书对象
 */
function generatePlanItem(id) {
  const productName = PLAN_PRODUCT_NAMES[Math.floor(Math.random() * PLAN_PRODUCT_NAMES.length)]
  const customerName = CUSTOMER_NAMES[Math.floor(Math.random() * CUSTOMER_NAMES.length)]
  const orderStatus = PLAN_STATUS[Math.floor(Math.random() * PLAN_STATUS.length)]
  const category = PLAN_CATEGORIES[Math.floor(Math.random() * PLAN_CATEGORIES.length)]

  // 生成创建时间（最近30天内）
  const now = new Date()
  const createTime = new Date(now.getTime() - Math.random() * 30 * 24 * 60 * 60 * 1000)

  // 根据状态决定是否有计划书文件
  // 处理中场景也需要覆盖“文件已可查看但状态尚未流转”的联调需求
  const hasFiles = orderStatus === '7' || orderStatus === '9' || (orderStatus === '5' && Math.random() < 0.5)
  const proposalFiles = []

  if (hasFiles) {
    // 生成1-3个计划书文件
    const fileCount = Math.floor(Math.random() * 3) + 1
    for (let i = 0; i < fileCount; i++) {
      proposalFiles.push({
        id: id * 10 + i,
        file_name: `${customerName}-${productName}-计划书.pdf`,
        file_url: `https://picsum.photos/seed/plan-${id}-${i}/400/300`
      })
    }
  }

  return {
    id: id,
    customer_name: customerName,
    product_name: productName,
    categories: [category],
    created_time: formatDate(createTime),
    order_status: orderStatus,
    proposal_files: proposalFiles
  }
}

/**
 * Mock: planListAPI (计划书列表)
 * @description 支持分页、状态筛选、关键词搜索
 * @param {Object} params - 请求参数
 * @param {number} params.page - 页码（从0开始）
 * @param {number} params.limit - 每页数量（默认20）
 * @param {string} [params.status] - 状态筛选（3=待处理, 5=处理中, 7=已生成, 9=已查看）
 * @param {string} [params.keyword] - 搜索关键字
 * @returns {Promise<Object>} Mock 响应
 */
export async function mockPlanListAPI(params) {
  await mockDelay()

  const { page = 0, limit = 20, status, keyword } = params
  const totalPages = 10

  // 如果超过总页数，返回空列表
  if (page >= totalPages) {
    console.log(`[Mock] planListAPI - 第${page}页,共0条（已到最后一页）`)
    return {
      code: 1,
      msg: 'success',
      data: {
        list: [],
        total: totalPages * limit
      }
    }
  }

  const list = []
  const startIndex = page * limit

  // 生成数据并过滤
  for (let i = 0; i < limit; i++) {
    const item = generatePlanItem(startIndex + i + 1)

    // 状态筛选
    if (status && item.order_status !== status) {
      continue
    }

    // 关键词搜索（搜索产品名或客户名）
    if (keyword) {
      const searchKeyword = keyword.toLowerCase()
      const productName = item.product_name.toLowerCase()
      const customerName = item.customer_name.toLowerCase()

      if (!productName.includes(searchKeyword) && !customerName.includes(searchKeyword)) {
        continue
      }
    }

    list.push(item)
  }

  console.log(`[Mock] planListAPI - 第${page}页,共${list.length}条,状态筛选:${status || '无'},关键词:"${keyword || '无'}"`)

  return {
    code: 1,
    msg: 'success',
    data: {
      list,
      total: totalPages * limit
    }
  }
}

// ============================================================================
// 9. 文章模块 Mock
// ============================================================================

const ARTICLE_TITLES = [
  '财富管理基础知识指南',
  '保险产品销售技巧',
  '客户关系管理实战',
  '家庭资产配置方案',
  '税务筹划实用手册',
  '退休规划完整教程',
  '投资组合管理策略',
  '风险控制与合规要求',
  '高净值客户开发指南',
  '理财产品营销话术',
  '基金定投实战技巧',
  '保单整理服务流程',
  '传承规划案例分析',
  '健康险产品对比分析',
  '年金保险销售指南',
  '重疾险核保知识',
  '教育金规划方案',
  '房贷规划实务操作',
  '家族信托业务介绍',
  '私募股权投资指南',
  '终身寿险销售技巧',
  '车险理赔流程说明',
  '企业财产险基础知识',
  '责任险产品介绍',
  '意外险保障方案',
  '健康险核保手册',
  '投保实务操作指南',
  '客户异议处理话术',
  '理赔案例分析',
  '保险法律法规汇编'
]

const ARTICLE_EXCERPTS = [
  '这是一篇关于财富管理的基础知识文章，帮助您了解投资理财的基本概念和方法。',
  '保险产品销售技巧分享，从客户需求分析到产品推荐的完整流程。',
  '高净值客户开发与维护实战指南，分享成功的客户管理经验。',
  '家庭资产配置方案设计，综合考虑风险、收益和流动性需求。',
  '税务筹划实用手册，合法合规地降低税负，提高财务效率。',
  '退休规划完整教程，为您打造安心舒适的退休生活。',
  '投资组合管理策略，分散风险，实现稳健收益。',
  '风险控制与合规要求解读，确保业务健康发展。',
  '高净值客户开发指南，提升客户开发成功率。',
  '理财产品营销话术，让客户更容易接受产品推荐。'
]

const ARTICLE_AUTHORS = [
  '财富管理专家',
  '保险规划师',
  '投资顾问',
  '税务筹划师',
  '法律顾问',
  '风险管理师'
]

const ARTICLE_COVER_IMAGES = [
  'https://picsum.photos/seed/article1/800/450',
  'https://picsum.photos/seed/article2/800/450',
  'https://picsum.photos/seed/article3/800/450',
  'https://picsum.photos/seed/article4/800/450',
  'https://picsum.photos/seed/article5/800/450'
]

/**
 * 生成文章列表项
 */
function generateArticleItem(id) {
  const title = ARTICLE_TITLES[Math.floor(Math.random() * ARTICLE_TITLES.length)]
  const excerpt = ARTICLE_EXCERPTS[Math.floor(Math.random() * ARTICLE_EXCERPTS.length)]
  const author = ARTICLE_AUTHORS[Math.floor(Math.random() * ARTICLE_AUTHORS.length)]
  const coverUrl = ARTICLE_COVER_IMAGES[Math.floor(Math.random() * ARTICLE_COVER_IMAGES.length)]

  // 生成随机日期（最近30天内）
  const now = new Date()
  const postDate = new Date(now.getTime() - Math.random() * 30 * 24 * 60 * 60 * 1000)

  return {
    id: id,
    post_title: title,
    post_excerpt: excerpt,
    post_link: '',
    post_date: formatDate(postDate),
    is_favorite: generateRandomFavorite(),
    read_people_count: generateRandomReadCount(),
    read_people_percent: generateRandomReadPercent(),
    author_name: author
  }
}

/**
 * Mock: 文章列表 API (listAPI - article)
 * @param {Object} params - 请求参数
 */
export async function mockArticleListAPI(params) {
  await mockDelay()

  const { page = 0, limit = 20, cid, child_id, keyword } = params
  const totalPages = 10

  if (page >= totalPages) {
    return { code: 1, msg: 'success', data: { list: [], total: totalPages * limit } }
  }

  // 文章分类数据（模拟分类结构）
  const ARTICLE_CATEGORIES = {
    1: { // 第一层：入职前
      id: 1,
      category_name: '入职前',
      level: 1,
      children: [
        { id: 11, category_name: '公司介绍', level: 2, icon: '', max_depth: 2, list: [] },
        { id: 12, category_name: '企业文化', level: 2, icon: '', max_depth: 2, list: [] },
        { id: 13, category_name: '产品知识', level: 2, icon: '', max_depth: 2, list: [] }
      ]
    },
    2: { // 第一层：入职中
      id: 2,
      category_name: '入职中',
      level: 1,
      children: [
        { id: 21, category_name: '销售技巧', level: 2, icon: '', max_depth: 2, list: [] },
        { id: 22, category_name: '客户服务', level: 2, icon: '', max_depth: 2, list: [] },
        { id: 23, category_name: '合规要求', level: 2, icon: '', max_depth: 2, list: [] }
      ]
    },
    3: { // 第一层：入职后
      id: 3,
      category_name: '入职后',
      level: 1,
      children: [
        { id: 31, category_name: '进阶培训', level: 2, icon: '', max_depth: 2, list: [] },
        { id: 32, category_name: '管理技能', level: 2, icon: '', max_depth: 2, list: [] }
      ]
    },
    // 兼容后端返回的分类 ID
    3129684: {
      id: 3129684,
      category_name: '培训资料',
      level: 1,
      children: [
        { id: 3129685, category_name: '销售培训', level: 2, icon: '', max_depth: 2, list: [] },
        { id: 3129686, category_name: '产品培训', level: 2, icon: '', max_depth: 2, list: [] },
        { id: 3129687, category_name: '服务培训', level: 2, icon: '', max_depth: 2, list: [] },
        { id: 3129688, category_name: '合规培训', level: 2, icon: '', max_depth: 2, list: [] }
      ]
    }
  }

  // 如果有分类 ID，生成该分类的子分类数据
  let selectedCategory = null
  let children = []
  let cate = null

  if (cid) {
    const categoryId = parseInt(cid)
    // 查找对应的分类
    for (const key in ARTICLE_CATEGORIES) {
      if (parseInt(key) === categoryId) {
        selectedCategory = ARTICLE_CATEGORIES[key]
        break
      }
    }

    // 如果找不到精确匹配，生成默认分类结构（兼容任何分类 ID）
    if (!selectedCategory) {
      console.log(`[Mock] 未找到分类 ${cid}，生成默认分类结构`)
      selectedCategory = {
        id: categoryId,
        category_name: `分类${categoryId}`,
        level: 1,
        children: [
          { id: categoryId * 10 + 1, category_name: '子分类1', level: 2, icon: '', max_depth: 2, list: [] },
          { id: categoryId * 10 + 2, category_name: '子分类2', level: 2, icon: '', max_depth: 2, list: [] },
          { id: categoryId * 10 + 3, category_name: '子分类3', level: 2, icon: '', max_depth: 2, list: [] }
        ]
      }
    }

    // 如果找到了，返回其子分类
    if (selectedCategory) {
      cate = {
        id: selectedCategory.id,
        category_name: selectedCategory.category_name,
        category_parent: 0,
        category_description: null
      }
      // 为每个子分类生成 5-15 篇文章的占位数据
      children = selectedCategory.children.map(child => ({
        ...child,
        list: Array.from({ length: Math.floor(Math.random() * 10) + 5 }, (_, i) => ({
          name: `${child.category_name}文章${i + 1}`,
          value: `https://example.com/article-${child.id}-${i + 1}`,
          extension: 'pdf',
          post_date: formatDate(new Date()),
          is_favorite: generateRandomFavorite(),
          id: child.id * 100 + i + 1
        }))
      }))
    }
  }

  // 如果有分类 ID，返回分类结构；否则返回文章列表
  if (cid) {
    console.log(`[Mock] mockArticleListAPI - 分类 ${cid},子分类 ${children.length} 个`)

    return {
      code: 1,
      msg: 'success',
      data: {
        cate: cate || { id: cid || 1, category_name: '文章分类', category_parent: 0, category_description: null },
        children: children,
        list: [], // 分类模式下，列表为空
        total: 0,
        max_level: 2
      }
    }
  }

  // 无分类 ID 时，返回文章列表
  let list = []
  const startIndex = page * limit

  // 生成基础数据
  for (let i = 0; i < limit; i++) {
    list.push(generateArticleItem(startIndex + i + 1))
  }

  // 关键词搜索过滤
  if (keyword) {
    const searchKeyword = keyword.toLowerCase()
    list = list.filter(article =>
      article.post_title.toLowerCase().includes(searchKeyword)
    )
  }

  console.log(`[Mock] mockArticleListAPI - 第${page}页,共${list.length}条,关键词:"${keyword || '无'}"`)

  return {
    code: 1,
    msg: 'success',
    data: {
      cate: { id: 1, category_name: '全部文章', category_parent: 0, category_description: null },
      children: [],
      list: list,
      total: list.length >= limit ? totalPages * limit : list.length,
      max_level: 2
    }
  }
}

/**
 * Mock: 热门文章 API (weekHotAPI - article)
 * @param {Object} params - 请求参数
 */
export async function mockArticleWeekHotAPI(params) {
  await mockDelay()

  const { page = 0, limit = 20 } = params
  const totalPages = 5

  if (page >= totalPages) {
    return { code: 1, msg: 'success', data: { list: [] } }
  }

  const list = []
  const startIndex = page * limit

  for (let i = 0; i < limit; i++) {
    list.push(generateArticleItem(startIndex + i + 1))
  }

  console.log(`[Mock] mockArticleWeekHotAPI - 第${page}页,共${list.length}条`)

  return { code: 1, msg: 'success', data: { list } }
}

/**
 * Mock: 文章详情 API (articleDetailAPI)
 * @param {Object} params - 请求参数
 * @param {string} params.i - 文章ID
 */
export async function mockArticleDetailAPI(params) {
  await mockDelay(300, 500) // 详情页延迟稍长，模拟真实加载

  const { i } = params
  const id = parseInt(i) || 1

  const article = generateArticleItem(id)

  // 模拟文章内容（HTML格式）
  const content = `
    <div style="font-size: 16px; line-height: 1.8; color: #333;">
      <h2 style="font-size: 20px; font-weight: bold; margin-bottom: 16px;">${article.post_title}</h2>

      <p style="margin-bottom: 16px;">${article.post_excerpt}</p>

      <h3 style="font-size: 18px; font-weight: bold; margin: 24px 0 12px;">一、背景介绍</h3>
      <p style="margin-bottom: 16px;">随着财富管理行业的快速发展，专业知识和技能的重要性日益凸显。本文将为您详细介绍相关的核心概念和实践方法。</p>

      <h3 style="font-size: 18px; font-weight: bold; margin: 24px 0 12px;">二、核心要点</h3>
      <ul style="margin-bottom: 16px; padding-left: 20px;">
        <li>深入理解客户需求，提供个性化解决方案</li>
        <li>持续学习行业知识，提升专业能力</li>
        <li>建立长期客户关系，增强客户黏性</li>
        <li>注重风险控制，保障客户资产安全</li>
      </ul>

      <h3 style="font-size: 18px; font-weight: bold; margin: 24px 0 12px;">三、实践建议</h3>
      <p style="margin-bottom: 16px;">在日常工作中，建议您：</p>
      <ol style="margin-bottom: 16px; padding-left: 20px;">
        <li>定期参加行业培训和研讨会</li>
        <li>建立完善的客户档案系统</li>
        <li>与团队成员保持良好沟通</li>
        <li>关注市场动态，及时调整策略</li>
      </ol>

      <h3 style="font-size: 18px; font-weight: bold; margin: 24px 0 12px;">四、总结</h3>
      <p style="margin-bottom: 16px;">通过系统的学习和实践，您将能够更好地为客户服务，实现个人和团队的共同成长。</p>

      <p style="color: #666; font-size: 14px; margin-top: 24px;">作者：${article.author_name}</p>
      <p style="color: #666; font-size: 14px;">发布日期：${article.post_date}</p>
    </div>
  `

  console.log(`[Mock] mockArticleDetailAPI - 文章ID: ${id}`)

  return {
    code: 1,
    msg: 'success',
    data: {
      ...article,
      post_content: content
    }
  }
}

/**
 * Mock: 文章收藏列表 API (favoriteAPI - article)
 * @param {Object} params - 请求参数
 */
export async function mockArticleFavoriteAPI(params) {
  await mockDelay()

  const { page = 0, limit = 20, keyword } = params
  const totalPages = 3

  if (page >= totalPages) {
    return { code: 1, msg: 'success', data: { list: [], total: 0 } }
  }

  let list = []
  const startIndex = page * limit

  // 生成收藏列表（只返回已收藏的）
  for (let i = 0; i < Math.min(limit, 10); i++) {
    const article = generateArticleItem(startIndex + i + 1)

    // 标记为已收藏，并添加收藏时间
    const now = new Date()
    const favoriteTime = new Date(now.getTime() - Math.random() * 60 * 24 * 60 * 60 * 1000)

    list.push({
      id: article.id,
      post_title: article.post_title,
      post_excerpt: article.post_excerpt,
      post_link: article.post_link,
      post_date: article.post_date,
      favorite_time: formatDate(favoriteTime)
    })
  }

  // 关键词搜索过滤
  if (keyword) {
    const searchKeyword = keyword.toLowerCase()
    list = list.filter(article =>
      article.post_title.toLowerCase().includes(searchKeyword)
    )
  }

  console.log(`[Mock] mockArticleFavoriteAPI - 第${page}页,共${list.length}条`)

  return {
    code: 1,
    msg: 'success',
    data: {
      list: list,
      total: list.length >= limit ? totalPages * limit : list.length
    }
  }
}

// ============================================================================
// 导出统一 Mock API 调用器
// ============================================================================

/**
 * Mock API 调用器
 * @param {string} apiName - API 名称
 * @param {Object} params - 请求参数
 * @returns {Promise}
 */
export async function mockAPI(apiName, params) {
  switch (apiName) {
    case 'weekHotAPI':
      return await mockWeekHotAPI(params)
    case 'fileListAPI':
      return await mockFileListAPI(params)
    case 'listAPI':
      return await mockProductListAPI(params)
    case 'searchAPI':
      return await mockSearchAPI(params)
    case 'myListAPI':
      return await mockMessageListAPI(params)
    case 'detailAPI':
      return await mockDetailAPI(params)
    case 'favoriteListAPI':
      return await mockFavoriteListAPI(params)
    case 'feedbackListAPI':
      return await mockFeedbackListAPI(params)
    case 'planListAPI':
      return await mockPlanListAPI(params)
    // 文章模块 Mock（直接调用独立函数，这里仅为兼容性保留）
    case 'articleListAPI':
      return await mockArticleListAPI(params)
    case 'articleWeekHotAPI':
      return await mockArticleWeekHotAPI(params)
    case 'articleDetailAPI':
      return await mockArticleDetailAPI(params)
    case 'articleFavoriteAPI':
      return await mockArticleFavoriteAPI(params)
    default:
      console.warn(`[Mock] 未知的 API: ${apiName}`)
      return { code: 0, msg: 'Unknown API', data: null }
  }
}

// ============================================================================
// POST 请求 Mock API（AI 测试专用）
// ============================================================================

/**
 * 解析 URL 参数
 * @param {string} url - 完整 URL
 * @param {string} key - 参数名
 * @returns {string|null} 参数值
 */
function getUrlParam(url, key) {
  const regex = new RegExp(`[?&]${key}=([^&#]*)`)
  const match = url.match(regex)
  return match ? decodeURIComponent(match[1]) : null
}

/**
 * POST Mock 路由器
 * @description 根据 URL 中的 a 和 t 参数路由到对应的 Mock 函数
 * @param {string} url - 请求 URL
 * @param {any} data - 请求体
 * @returns {Promise<{code:number, msg:string, data:any}>} Mock 响应
 */
export async function mockPostAPI(url, data) {
  await mockDelay(100, 300)

  // 解析 action 和 type 参数
  const action = getUrlParam(url, 'a')
  const type = getUrlParam(url, 't')

  console.log(`[Mock] POST 请求 - a=${action}, t=${type}`)

  // 路由到具体 Mock 函数
  switch (action) {
    // 收藏模块
    case 'favorite':
      if (type === 'add') return mockFavoriteAddAPI(data)
      if (type === 'del') return mockFavoriteDelAPI(data)
      break

    // 埋点模块
    case 'event':
      if (type === 'add') return mockEventAddAPI(data)
      break

    // 验证码
    case 'sms':
      return mockSmsAPI(data)

    // 文件上传
    case 'upload':
      if (type === 'save_file') return mockSaveFileAPI(data)
      return mockQiniuTokenAPI(data)

    // 小程序授权
    case 'openid':
      return mockMiniProgramAuthAPI(data)

    // 计划书模块
    case 'proposal':
      if (type === 'add') return mockProposalAddAPI(data)
      if (type === 'del') return mockProposalDeleteAPI(data)
      if (type === 'view') return mockProposalViewAPI(data)
      break

    // 用户模块
    case 'user':
      if (type === 'login') return mockLoginAPI(data)
      if (type === 'logout') return mockLogoutAPI(data)
      if (type === 'update_profile') return mockUpdateProfileAPI(data)
      break

    // 反馈模块
    case 'feedback':
      if (type === 'add') return mockFeedbackAddAPI(data)
      break

    // 微信支付
    case 'icbc_pay_wxamp':
      return mockWxPayAPI(data)

    default:
      console.warn(`[Mock] 未定义的 POST API: a=${action}, t=${type}`)
  }

  // 默认响应
  return { code: 1, msg: 'success (mock)', data: null }
}

// ============================================================================
// 具体实现
// ============================================================================

/**
 * Mock: 添加收藏
 */
async function mockFavoriteAddAPI(data) {
  console.log('[Mock] favorite/add - data:', data)
  return { code: 1, msg: '收藏成功', data: null }
}

/**
 * Mock: 取消收藏
 */
async function mockFavoriteDelAPI(data) {
  console.log('[Mock] favorite/del - data:', data)
  return { code: 1, msg: '取消成功', data: null }
}

/**
 * Mock: 埋点
 */
async function mockEventAddAPI(data) {
  console.log('[Mock] event/add - data:', data)
  return { code: 1, msg: 'success', data: null }
}

/**
 * Mock: 发送验证码
 */
async function mockSmsAPI(data) {
  console.log('[Mock] sms - data:', data)
  return { code: 1, msg: '发送成功', data: null }
}

/**
 * Mock: 七牛 Token
 */
async function mockQiniuTokenAPI(data) {
  console.log('[Mock] upload (qiniu token) - data:', data)
  return {
    code: 1,
    msg: 'success',
    data: {
      token: 'mock_qiniu_token_' + Date.now(),
      upload_url: 'https://mock.qiniu.com/putb64/-1'
    }
  }
}

/**
 * Mock: 保存文件
 */
async function mockSaveFileAPI(data) {
  console.log('[Mock] upload/save_file - data:', data)
  return {
    code: 1,
    msg: '保存成功',
    data: {
      src: 'https://cdn.ipadbiz.cn/manulife/mock/' + Date.now() + '.jpg'
    }
  }
}

/**
 * Mock: 小程序授权
 */
async function mockMiniProgramAuthAPI(data) {
  await mockDelay(500, 800) // 授权延迟稍长
  console.log('[Mock] openid (授权) - data:', data)
  return {
    code: 1,
    msg: '授权成功',
    data: {
      user: {
        id: 1,
        avatar_url: 'https://cdn.ipadbiz.cn/manulife/avatar/default.png',
        name: 'AI测试用户'
      }
    }
  }
}

/**
 * Mock: 新增计划书
 */
async function mockProposalAddAPI(data) {
  await mockDelay(300, 500)
  console.log('[Mock] proposal/add - data:', data)
  return {
    code: 1,
    msg: '创建成功',
    data: {
      order_id: 'mock_order_' + Date.now()
    }
  }
}

/**
 * Mock: 删除计划书
 */
async function mockProposalDeleteAPI(data) {
  console.log('[Mock] proposal/del - data:', data)
  return { code: 1, msg: '删除成功', data: null }
}

/**
 * Mock: 查看计划书
 */
async function mockProposalViewAPI(data) {
  await mockDelay(500, 800)
  console.log('[Mock] proposal/view - data:', data)
  return {
    code: 1,
    msg: 'success',
    data: {
      status: 7, // 已生成
      pdf_url: 'https://cdn.ipadbiz.cn/manulife/mock/proposal.pdf'
    }
  }
}

/**
 * Mock: 登录
 */
async function mockLoginAPI(data) {
  await mockDelay(500, 800)
  console.log('[Mock] user/login - data:', data)
  return {
    code: 1,
    msg: '登录成功',
    data: {
      userid: 'mock_test_user',
      username: 'AI测试用户',
      avatar: 'https://cdn.ipadbiz.cn/manulife/avatar/default.png'
    }
  }
}

/**
 * Mock: 登出
 */
async function mockLogoutAPI(data) {
  console.log('[Mock] user/logout - data:', data)
  return { code: 1, msg: '退出成功', data: null }
}

/**
 * Mock: 更新个人资料
 */
async function mockUpdateProfileAPI(data) {
  console.log('[Mock] user/update_profile - data:', data)
  return { code: 1, msg: '更新成功', data: { ...data } }
}

/**
 * Mock: 提交反馈
 */
async function mockFeedbackAddAPI(data) {
  console.log('[Mock] feedback/add - data:', data)
  return {
    code: 1,
    msg: '提交成功',
    data: { id: Date.now() }
  }
}

/**
 * Mock: 微信支付
 */
async function mockWxPayAPI(data) {
  await mockDelay(500, 1000) // 支付延迟较长
  console.log('[Mock] icbc_pay_wxamp - data:', data)
  return {
    code: 1,
    msg: 'success',
    data: {
      timeStamp: String(Date.now()),
      nonceStr: 'mock_nonce_' + Date.now(),
      package: 'prepay_id=mock_prepay_id',
      signType: 'RSA',
      paySign: 'mock_sign_' + Date.now()
    }
  }
}