module.exports = {
  // 数据库健康检查：每5分钟执行一次
  databaseHealthCheck: {
    cron: "*/5 * * * *", // Cron 表达式
    description: "数据库连接健康检查",
  },

  // Redis健康检查：每5分钟执行一次
  redisHealthCheck: {
    cron: "*/5 * * * *",
    description: "检查Redis连接状态",
  },

  // SSE心跳检查：每60秒执行一次
  sseHeartbeat: {
    cron: 60000, // 毫秒数（间隔任务）
    description: "SSE连接心跳检查和清理",
  },

  // Token清理：通过环境变量配置
  tokenCleanup: {
    // cron: '',  // 通过env配置
    description: "过期Token清理",
  },

  // 验证码清理：每60秒执行一次
  captchaCleanup: {
    cron: 60000,
    description: "过期验证码清理",
  },
};

"*/5 * * * *"; // 每5分钟执行一次
"0 */1 * * *"; // 每小时执行一次
"0 0 * * *"; // 每天0点执行
"0 0 0 * * 0"; // 每周日0点执行
"0 0 0 1 * *"; // 每月1号0点执行
"0 0 2 * * *"; // 每天凌晨2点执行

schedules: {
    tokenCleanup: {
        cron: "*/5 * * * *", // 开发环境：每5分钟清理一次
    },
},

schedules: {
    tokenCleanup: {
        cron: "0 * * * *", // 生产环境：每小时清理一次
    },
},

const scheduler = require("./src/infra/scheduler");

// 从配置中添加任务
scheduler.addFromConfig("databaseHealthCheck", async () => {
  try {
    const ok = await checkDatabaseConnection();
    if (!ok) {
      logger.warn("⚠️ 数据库健康检查失败");
    }
  } catch (error) {
    logger.error("数据库健康检查出错:", { error });
  }
});

const scheduler = require("./src/infra/scheduler");

// 方式1：使用 Cron 表达式
scheduler.addTask(
  "myTask",
  "*/10 * * * *", // 每10分钟执行一次
  async () => {
    console.log("执行任务");
  },
  {
    description: "我的定时任务",
  }
);

// 方式2：使用间隔时间（毫秒）
scheduler.addTask(
  "myIntervalTask",
  60000, // 每60秒执行一次
  async () => {
    console.log("执行间隔任务");
  }
);

// 移除单个任务
scheduler.removeTask("myTask");

// 移除所有任务
scheduler.removeAllTasks();

// 获取所有任务状态
const tasks = scheduler.getAllTasks();
console.log(tasks);
// 输出示例：
// [
//   {
//     taskId: "databaseHealthCheck",
//     status: { failed: false }
//   },
//   {
//     taskId: "myTask",
//     status: {
//       failed: true,
//       failureCount: 3,
//       lastError: "Connection timeout",
//       nextAttempt: "2024-12-19T10:30:00.000Z"
//     }
//   }
// ]

任务执行
  ↓
执行失败
  ↓
记录失败次数 +1
  ↓
失败次数 < 3？
  ├─ 是 → 记录错误日志，下次继续执行
  └─ 否 → 计算冷却时间，暂停任务
           ↓
      冷却时间结束
           ↓
      自动恢复执行

// 任务执行成功
await taskFunction();
this.resetTaskFailureCount(taskId); // 自动重置失败计数

scheduler.addFromConfig("databaseHealthCheck", async () => {
  try {
    const ok = await checkDatabaseConnection();
    if (!ok) {
      logger.warn("⚠️ 数据库健康检查失败，请检查数据库服务状态");
    }
  } catch (error) {
    logger.error("数据库健康检查出错:", { error });
  }
});

if (cacheType === "redis" && config.redis?.host && config.redis?.port) {
  scheduler.addFromConfig("redisHealthCheck", async () => {
    try {
      const connected = await performRedisHealthCheck();
      if (!connected) {
        logger.debug("Redis连接不可用，确认已切换到内存缓存");
      }
    } catch (error) {
      logger.debug("Redis健康检查出错(已预期)，系统应自动使用内存缓存:", {
        error: error,
      });
    }
  });
}

scheduler.addFromConfig("sseHeartbeat", () => {
  sseManager.checkHeartbeats();
  sseManager.cleanupInactiveConnections();
});

scheduler.addFromConfig("tokenCleanup", async () => {
  try {
    await authController.cleanupExpiredTokens();
  } catch (error) {
    logger.error("❌ Token清理任务失败", { error });
  }
});

// 20. 定时任务初始化函数
const initScheduledTasks = async () => {
  logger.info("⏰ 初始化定时任务...");

  // 启动时清理过期 Token
  try {
    const cleanedCount = await authController.cleanupExpiredTokens();
    if (isDev && cleanedCount > 0) {
      logger.info(`🚀 启动时清理了 ${cleanedCount} 个过期token`);
    }
  } catch (error) {
    logger.error("启动时清理失败", { error });
  }

  // 添加数据库健康检查
  scheduler.addFromConfig("databaseHealthCheck", async () => {
    // ...
  });

  // 添加 Redis 健康检查（如果启用）
  if (cacheType === "redis") {
    scheduler.addFromConfig("redisHealthCheck", async () => {
      // ...
    });
  }

  // 添加 SSE 心跳检查
  scheduler.addFromConfig("sseHeartbeat", () => {
    // ...
  });

  // 添加 Token 清理
  scheduler.addFromConfig("tokenCleanup", async () => {
    // ...
  });

  logger.info("✅ 所有定时任务初始化完成");
};

app.listen(envconfig.port, envconfig.host, async () => {
  // ... 其他初始化代码

  // 步骤2: 初始化定时任务系统
  await initScheduledTasks();
});

// 在 scheduler.js 中
shutdown() {
    this.removeAllTasks();
    logger.debug("🛑 定时任务管理器已关闭");
}

process.on("SIGINT", async () => {
  scheduler.shutdown();
  // ... 其他清理代码
  process.exit(0);
});

scheduler.addFromConfig("myTask", async () => {
  try {
    // 执行任务逻辑
    const result = await doSomething();
    logger.info("任务执行成功", { result });
  } catch (error) {
    // 捕获异常，避免影响调度器
    logger.error("任务执行失败", { error: error.message });
    // 不抛出异常，让调度器记录失败即可
  }
});

scheduler.addFromConfig("myTask", async () => {
  // ❌ 未捕获异常，可能导致调度器崩溃
  await doSomething();

  // ❌ 未记录日志，难以排查问题
  processData();
});

// 检查任务状态
const tasks = scheduler.getAllTasks();
console.log(tasks);

// 检查任务配置
const config = require("./config");
console.log(config.schedules);

scheduler.addTask("myTask", "*/5 * * * *", async () => {
  try {
    await doSomething();
  } catch (error) {
    logger.error("任务执行失败", { error });
    // 不抛出异常，让调度器记录失败
  }
});

scheduler.removeTask("myTask");
scheduler.addTask("myTask", "*/10 * * * *", taskFunction);

interface TaskStatus {
  taskId: string;
  status: {
    failed: boolean;
    failureCount?: number;
    lastError?: string;
    nextAttempt?: string; // ISO 时间字符串或 "Now"
  };
}

scheduler.addFromConfig("dataCleanup", async () => {
  try {
    // 清理 30 天前的监控数据
    const daysToKeep = 30;
    await monitorModel.cleanExpiredData(daysToKeep);
    logger.info("监控数据清理完成");
  } catch (error) {
    logger.error("数据清理失败", { error });
  }
});

scheduler.addTask(
  "dailyReport",
  "0 0 1 * * *", // 每天凌晨1点执行
  async () => {
    try {
      const report = await generateDailyReport();
      await saveReport(report);
      logger.info("日报生成完成");
    } catch (error) {
      logger.error("日报生成失败", { error });
    }
  }
);

scheduler.addTask(
  "cacheRefresh",
  300000, // 每5分钟执行一次
  async () => {
    try {
      await refreshUserCache();
      await refreshMenuCache();
      logger.debug("缓存刷新完成");
    } catch (error) {
      logger.error("缓存刷新失败", { error });
    }
  }
);