import { DataSource } from 'typeorm';
import * as cron from 'node-cron';
import { PrintTaskService } from './print-task.service';
import { FeieApiConfig } from '../types/feie.types';

export class DelaySchedulerService {
  private printTaskService: PrintTaskService;
  private isRunning: boolean = false;
  private cronJob: cron.ScheduledTask | null = null;
  private defaultDelaySeconds: number = 120; // 默认2分钟延迟

  constructor(dataSource: DataSource, feieConfig: FeieApiConfig) {
    this.printTaskService = new PrintTaskService(dataSource, feieConfig);
  }

  /**
   * 启动调度器
   */
  async start(): Promise<void> {
    if (this.isRunning) {
      throw new Error('调度器已经在运行中');
    }

    console.log('启动防退款延迟打印调度器...');

    // 每30秒检查一次待处理的延迟打印任务
    this.cronJob = cron.schedule('*/30 * * * * *', async () => {
      await this.processDelayedTasks();
    });

    this.isRunning = true;
    console.log('防退款延迟打印调度器已启动');
  }

  /**
   * 停止调度器
   */
  async stop(): Promise<void> {
    if (!this.isRunning) {
      throw new Error('调度器未在运行中');
    }

    console.log('停止防退款延迟打印调度器...');

    if (this.cronJob) {
      this.cronJob.stop();
      this.cronJob = null;
    }

    this.isRunning = false;
    console.log('防退款延迟打印调度器已停止');
  }

  /**
   * 处理延迟打印任务
   */
  private async processDelayedTasks(): Promise<void> {
    try {
      // 这里需要获取所有租户的ID
      // 在实际应用中，应该从租户服务获取所有活跃租户
      // 这里简化处理，假设我们需要处理所有租户

      // 由于我们无法获取所有租户列表，这里先记录日志
      console.log('检查延迟打印任务...');

      // 在实际实现中，应该遍历所有租户并处理每个租户的延迟任务
      // 示例代码：
      // const tenants = await this.getActiveTenants();
      // for (const tenant of tenants) {
      //   await this.processTenantDelayedTasks(tenant.id);
      // }

    } catch (error) {
      console.error('处理延迟打印任务失败:', error);
    }
  }

  /**
   * 处理指定租户的延迟打印任务
   */
  private async processTenantDelayedTasks(tenantId: number): Promise<void> {
    try {
      // 获取待处理的延迟打印任务
      const pendingTasks = await this.printTaskService.getPendingDelayedTasks(tenantId);

      if (pendingTasks.length === 0) {
        return;
      }

      console.log(`租户 ${tenantId} 有 ${pendingTasks.length} 个待处理的延迟打印任务`);

      // 处理每个任务
      for (const task of pendingTasks) {
        try {
          console.log(`执行延迟打印任务: ${task.taskId}`);
          await this.printTaskService.executePrintTask(tenantId, task.taskId);
          console.log(`延迟打印任务完成: ${task.taskId}`);
        } catch (error) {
          console.error(`执行延迟打印任务失败 ${task.taskId}:`, error);
        }
      }
    } catch (error) {
      console.error(`处理租户 ${tenantId} 的延迟打印任务失败:`, error);
    }
  }

  /**
   * 设置默认延迟时间
   */
  setDefaultDelaySeconds(seconds: number): void {
    if (seconds < 0) {
      throw new Error('延迟时间不能为负数');
    }

    this.defaultDelaySeconds = seconds;
    console.log(`默认延迟时间已设置为 ${seconds} 秒`);
  }

  /**
   * 获取默认延迟时间
   */
  getDefaultDelaySeconds(): number {
    return this.defaultDelaySeconds;
  }

  /**
   * 检查调度器状态
   */
  getStatus(): {
    isRunning: boolean;
    defaultDelaySeconds: number;
    lastProcessTime?: Date;
  } {
    return {
      isRunning: this.isRunning,
      defaultDelaySeconds: this.defaultDelaySeconds
    };
  }

  /**
   * 手动触发任务处理
   */
  async triggerManualProcess(tenantId: number): Promise<{
    success: boolean;
    processedTasks: number;
    message: string;
  }> {
    try {
      const pendingTasks = await this.printTaskService.getPendingDelayedTasks(tenantId);
      let processedCount = 0;

      for (const task of pendingTasks) {
        try {
          await this.printTaskService.executePrintTask(tenantId, task.taskId);
          processedCount++;
        } catch (error) {
          console.error(`手动处理任务失败 ${task.taskId}:`, error);
        }
      }

      return {
        success: true,
        processedTasks: processedCount,
        message: `成功处理 ${processedCount} 个延迟打印任务`
      };
    } catch (error) {
      return {
        success: false,
        processedTasks: 0,
        message: `手动处理失败: ${error instanceof Error ? error.message : '未知错误'}`
      };
    }
  }

  /**
   * 健康检查
   */
  async healthCheck(): Promise<{
    healthy: boolean;
    isRunning: boolean;
    lastError?: string;
    timestamp: Date;
  }> {
    try {
      // 简单的健康检查：检查调度器是否在运行
      return {
        healthy: this.isRunning,
        isRunning: this.isRunning,
        timestamp: new Date()
      };
    } catch (error) {
      return {
        healthy: false,
        isRunning: this.isRunning,
        lastError: error instanceof Error ? error.message : '健康检查失败',
        timestamp: new Date()
      };
    }
  }

  /**
   * 获取活跃租户列表（简化实现）
   * 在实际应用中，应该从租户服务获取
   */
  private async getActiveTenants(): Promise<Array<{ id: number; name: string }>> {
    // 这里返回一个空数组，实际实现应该查询租户表
    return [];
  }
}