/**
 * 任务调度器
 * 支持间隔定时和每日多次定时
 */

class TaskScheduler {
  constructor() {
    this.timers = new Map() // 存储定时器
    this.callbacks = new Map() // 存储回调函数
    this.isRunning = false
  }

  /**
   * 启动调度器
   * @param {Object} config - 调度配置
   * @param {Function} callback - 执行回调
   */
  start(config, callback) {
    if (this.isRunning) {
      console.warn('⚠️ 调度器已在运行中')
      return
    }

    console.log('🕐 启动任务调度器', config)
    this.isRunning = true

    if (config.type === 'interval') {
      this.startIntervalSchedule(config, callback)
    } else if (config.type === 'daily') {
      this.startDailySchedule(config, callback)
    }
  }

  /**
   * 启动间隔调度（每N分钟执行一次）
   */
  startIntervalSchedule(config, callback) {
    const intervalMs = config.interval * 60 * 1000 // 分钟转换为毫秒
    
    console.log(`⏰ 间隔调度启动: 每${config.interval}分钟执行一次`)
    
    // 检查是否应该立即执行
    if (config.lastExecutionTime) {
      const timeSinceLastExecution = Date.now() - config.lastExecutionTime
      if (timeSinceLastExecution >= intervalMs) {
        // 立即执行一次
        console.log('🚀 立即执行任务（超过间隔时间）')
        this.executeTask(callback, config)
      } else {
        // 计算下次执行时间
        const nextExecutionDelay = intervalMs - timeSinceLastExecution
        console.log(`⏳ 下次执行时间: ${Math.round(nextExecutionDelay / 1000 / 60)}分钟后`)
        
        // 设置首次延迟执行
        const firstTimer = setTimeout(() => {
          this.executeTask(callback, config)
          
          // 然后开始周期性执行
          const intervalTimer = setInterval(() => {
            this.executeTask(callback, config)
          }, intervalMs)
          
          this.timers.set('interval', intervalTimer)
        }, nextExecutionDelay)
        
        this.timers.set('first', firstTimer)
      }
    } else {
      // 首次启动，立即执行
      console.log('🚀 首次启动，立即执行任务')
      this.executeTask(callback, config)
    }
    
    // 如果没有设置first定时器，直接设置周期性定时器
    if (!this.timers.has('first')) {
      const intervalTimer = setInterval(() => {
        this.executeTask(callback, config)
      }, intervalMs)
      
      this.timers.set('interval', intervalTimer)
    }
    
    this.callbacks.set('interval', callback)
  }

  /**
   * 启动每日定时调度（每天特定时间执行）
   */
  startDailySchedule(config, callback) {
    // 优先使用新格式dailySchedules，兼容旧格式dailyTimes
    const schedules = config.dailySchedules || config.dailyTimes.map(time => ({ time, tasks: null }))
    
    console.log(`⏰ 每日调度启动: ${schedules.map(s => s.time).join(', ')}`)
    
    // 为每个时间点创建定时器
    schedules.forEach((schedule, index) => {
      this.scheduleDailyTime(schedule, callback, config, index)
    })
    
    this.callbacks.set('daily', callback)
  }

  /**
   * 调度单个每日时间点
   */
  scheduleDailyTime(schedule, callback, config, index) {
    // schedule可能是字符串（旧格式兼容）或对象（新格式）
    const timeStr = typeof schedule === 'string' ? schedule : schedule.time
    const tasks = typeof schedule === 'object' ? schedule.tasks : null
    
    const [hour, minute] = timeStr.split(':').map(Number)
    
    const scheduleNext = () => {
      const now = new Date()
      const scheduledTime = new Date()
      scheduledTime.setHours(hour, minute, 0, 0)
      
      // 如果今天的时间已过，调度到明天
      if (scheduledTime <= now) {
        scheduledTime.setDate(scheduledTime.getDate() + 1)
      }
      
      const delay = scheduledTime - now
      const delayMinutes = Math.round(delay / 1000 / 60)
      
      const tasksInfo = tasks ? ` [${tasks.length}个任务]` : ''
      console.log(`  📅 ${timeStr}${tasksInfo} - 下次执行: ${delayMinutes}分钟后`)
      
      const timer = setTimeout(() => {
        console.log(`⏰ 定时任务触发: ${timeStr}${tasksInfo}`)
        // 传递任务列表给回调函数
        this.executeTask(callback, config, tasks)
        
        // 执行完后调度下一次（明天同一时间）
        scheduleNext()
      }, delay)
      
      this.timers.set(`daily_${index}`, timer)
    }
    
    scheduleNext()
  }

  /**
   * 执行任务
   */
  async executeTask(callback, config, tasks = null) {
    try {
      const tasksInfo = tasks ? ` [${tasks.length}个任务]` : ''
      console.log(`🚀 执行定时任务${tasksInfo}`)
      
      // 更新最后执行时间
      config.lastExecutionTime = Date.now()
      
      // 执行回调，传递任务列表参数
      await callback(tasks)
      
      console.log('✅ 定时任务执行完成')
    } catch (error) {
      console.error('❌ 定时任务执行失败:', error)
    }
  }

  /**
   * 停止调度器
   */
  stop() {
    if (!this.isRunning) {
      return
    }

    console.log('⏹️ 停止任务调度器')
    
    // 清除所有定时器
    this.timers.forEach((timer, key) => {
      clearTimeout(timer)
      clearInterval(timer)
    })
    
    this.timers.clear()
    this.callbacks.clear()
    this.isRunning = false
  }

  /**
   * 获取调度器状态
   */
  getStatus() {
    return {
      isRunning: this.isRunning,
      timersCount: this.timers.size
    }
  }

  /**
   * 手动触发执行
   */
  async triggerManually(callback, config) {
    console.log('👆 手动触发任务执行')
    await this.executeTask(callback, config)
  }
}

// 导出单例
export const taskScheduler = new TaskScheduler()
export default TaskScheduler

