buddhism/utils/activity-data-formatter.js

import { ACTIVITY_STATUS, ACTIVITY_TYPE } from '../enum/activity'

/**
 * 活动数据格式化工具
 */
export default {
  /**
   * 格式化活动列表数据
   * @param {Array} apiData - API返回的活动数据
   * @returns {Array} 格式化后的活动数据
   */
  formatActivityList(apiData) {
    if (!Array.isArray(apiData)) {
      return []
    }

    return apiData.map(item => this.formatActivityItem(item))
  },

  /**
   * 格式化单个活动数据
   * @param {Object} item - API返回的单个活动数据
   * @returns {Object} 格式化后的活动数据
   */
  formatActivityItem(item) {
    if (!item) return null

    return {
      id: item.id || '',
      name: item.title || '未命名活动',
      theme: item.content ? `活动主题: ${item.content}` : '',
      type: this.getActivityType(item.type),
      status: this.getActivityStatus(item.status, item.actStartTime, item.actEndTime),
      time: this.formatActivityTime(item.actStartTime, item.actEndTime),
      location: item.address || '',
      backgroundImage: item.imgUrl || this.getDefaultImageByType(item.type),
      // 额外信息
      templeId: item.templeId,
      currentBooking: item.currentBooking || 0,
      attendance: item.attendance || 0,
      readNum: item.readNum || 0,
      phone: item.phone,
      lon: item.lon,
      lat: item.lat
    }
  },

  /**
   * 格式化活动详情数据
   * @param {Object} apiData - API返回的活动详情数据
   * @returns {Object} 格式化后的活动详情数据
   */
  formatActivityDetail(apiData) {
    if (!apiData) return null

    return {
      id: apiData.id || '',
      name: apiData.title || '未命名活动',

      type: this.getActivityType(apiData.type),
      status: this.getActivityStatus(apiData.status, apiData.actStartTime, apiData.actEndTime),
      time: this.formatActivityTime(apiData.actStartTime, apiData.actEndTime),
      location: apiData.address || '',
      backgroundImage: apiData.imgUrl || this.getDefaultImageByType(apiData.type),
      // 详情页额外信息
      templeId: apiData.templeId,
      currentBooking: apiData.currentBooking || 0,
      attendance: apiData.attendance || 0,
      readNum: apiData.readNum || 0,
      phone: apiData.phone,
      lon: apiData.lon,
      lat: apiData.lat,
      content: apiData.content,
      createTime: apiData.createTime,
      updateTime: apiData.updateTime
    }
  },

  /**
   * 从HTML内容中提取纯文本
   * @param {string} htmlContent - HTML内容
   * @returns {string} 纯文本内容
   */
  extractTextFromHtml(htmlContent) {
    if (!htmlContent) return ''
    
    try {
      // 简单的HTML标签移除
      return htmlContent
        .replace(/<[^>]*>/g, '') // 移除HTML标签
        .replace(/&nbsp;/g, ' ') // 替换空格实体
        .replace(/&amp;/g, '&') // 替换&实体
        .replace(/&lt;/g, '<') // 替换<实体
        .replace(/&gt;/g, '>') // 替换>实体
        .replace(/&quot;/g, '"') // 替换"实体
        .trim()
    } catch (error) {
      console.error('提取HTML文本失败:', error)
      return htmlContent
    }
  },

  /**
   * 获取活动类型
   * @param {string} type - API返回的类型
   * @returns {string} 标准化的活动类型
   */
  getActivityType(type) {
    if (!type) return ACTIVITY_TYPE.PRAYER

    const typeMap = {
      '1': ACTIVITY_TYPE.PRAYER,    // 祈福活动
      '2': ACTIVITY_TYPE.CEREMONY,  // 法会活动
      '3': ACTIVITY_TYPE.MEDITATION, // 禅修活动
      '4': ACTIVITY_TYPE.DONATION,  // 捐赠活动
      '5': ACTIVITY_TYPE.VOLUNTEER  // 义工活动
    }

    return typeMap[type] || ACTIVITY_TYPE.PRAYER
  },

  /**
   * 获取活动状态
   * @param {string} status - API返回的状态
   * @param {string} startTime - 开始时间
   * @param {string} endTime - 结束时间
   * @returns {string} 标准化的活动状态
   */
  getActivityStatus(status, startTime, endTime) {
    if (!status || status === '0') {
      return ACTIVITY_STATUS.FINISHED
    }

    // 如果有时间信息，根据时间判断状态
    if (startTime && endTime) {
      const now = new Date()
      const start = this.parseDateForIOS(startTime)
      const end = this.parseDateForIOS(endTime)

      if (now < start) {
        return ACTIVITY_STATUS.REGISTERING
      } else if (now >= start && now <= end) {
        return ACTIVITY_STATUS.ONGOING
      } else {
        return ACTIVITY_STATUS.FINISHED
      }
    }

    // 默认根据status判断
    const statusMap = {
      '1': ACTIVITY_STATUS.REGISTERING,
      '2': ACTIVITY_STATUS.ONGOING,
      '3': ACTIVITY_STATUS.FINISHED
    }

    return statusMap[status] || ACTIVITY_STATUS.REGISTERING
  },

  /**
   * 兼容iOS的日期解析函数
   * @param {string} dateString - 日期字符串
   * @returns {Date} 解析后的日期对象
   */
  parseDateForIOS(dateString) {
    if (!dateString) return new Date()
    
    try {
      // 将 "yyyy-MM-dd HH:mm:ss" 格式转换为 "yyyy-MM-ddTHH:mm:ss" 格式以兼容iOS
      const iosCompatibleDate = dateString.replace(' ', 'T')
      return new Date(iosCompatibleDate)
    } catch (error) {
      console.error('解析日期失败:', error)
      return new Date()
    }
  },

  /**
   * 格式化活动时间
   * @param {string} startTime - 开始时间
   * @param {string} endTime - 结束时间
   * @returns {string} 格式化后的时间字符串
   */
  formatActivityTime(startTime, endTime) {
    if (!startTime) return ''

    try {
      const start = this.parseDateForIOS(startTime)
      const end = endTime ? this.parseDateForIOS(endTime) : null

      // 格式化日期
      const formatDate = (date) => {
        const year = date.getFullYear()
        const month = String(date.getMonth() + 1).padStart(2, '0')
        const day = String(date.getDate()).padStart(2, '0')
        const weekdays = ['周日', '周一', '周二', '周三', '周四', '周五', '周六']
        const weekday = weekdays[date.getDay()]
        const hours = String(date.getHours()).padStart(2, '0')
        const minutes = String(date.getMinutes()).padStart(2, '0')

        return `${year}年${month}月${day}日 ${weekday} ${hours}:${minutes}`
      }

      let timeStr = formatDate(start)

      // 如果有结束时间，添加结束时间
      if (end && end.getTime() !== start.getTime()) {
        const endHours = String(end.getHours()).padStart(2, '0')
        const endMinutes = String(end.getMinutes()).padStart(2, '0')
        timeStr += `~${endHours}:${endMinutes}`
      }

      return timeStr
    } catch (error) {
      console.error('格式化时间失败:', error)
      return startTime
    }
  },

  /**
   * 根据类型获取默认图片
   * @param {string} type - 活动类型
   * @returns {string} 默认图片路径
   */
  getDefaultImageByType(type) {
    const typeMap = {
      '1': '/static/image/a1.png', // 祈福活动
      '2': '/static/image/a2.png', // 法会活动
      '3': '/static/image/a3.png', // 禅修活动
      '4': '/static/image/a4.png', // 捐赠活动
      '5': '/static/image/a5.png'  // 义工活动
    }

    return typeMap[type] || '/static/image/a1.png'
  },

  /**
   * 验证活动数据是否有效
   * @param {Object} activity - 活动数据
   * @returns {boolean} 是否有效
   */
  isValidActivity(activity) {
    return activity && 
           activity.id && 
           activity.title && 
           activity.status !== '0'
  }
}