package com.example.demo.service;

import java.time.LocalDateTime;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.example.demo.model.TaskQueue;
import com.example.demo.repository.TaskQueueRepository;

/**
 * 轮询查询服务
 * 注意：自动调度已禁用，避免与TaskQueueScheduler重复查询
 * 保留此服务用于手动调用或测试
 */
@Service
public class PollingQueryService {

    private static final Logger logger = LoggerFactory.getLogger(PollingQueryService.class);

    @Autowired
    private TaskQueueService taskQueueService;

    @Autowired
    private TaskQueueRepository taskQueueRepository;

    /**
     * 执行轮询查询（已禁用自动调度，避免与TaskQueueScheduler重复）
     * 保留此方法用于手动调用或测试
     * 注意：TaskQueueScheduler.checkTaskStatuses() 已经统一管理任务状态检查
     */
    // @Scheduled(fixedRate = 120000) // 已禁用：避免与TaskQueueScheduler重复查询
    public void executePollingQuery() {
        logger.info("=== 开始执行轮询查询 (每2分钟) ===");
        logger.info("轮询查询时间: {}", LocalDateTime.now());
        
        try {
            // 查询所有正在处理的任务
            List<TaskQueue> processingTasks = taskQueueRepository.findTasksToCheck();
            
            logger.info("找到 {} 个正在处理的任务需要轮询查询", processingTasks.size());
            
            if (processingTasks.isEmpty()) {
                logger.info("当前没有正在处理的任务，轮询查询结束");
                return;
            }
            
            // 逐个查询任务状态
            int successCount = 0;
            int errorCount = 0;
            
            for (TaskQueue task : processingTasks) {
                try {
                    logger.info("轮询查询任务: taskId={}, realTaskId={}, 创建时间={}", 
                        task.getTaskId(), task.getRealTaskId(), task.getCreatedAt());
                    
                    // 调用任务队列服务检查状态
                    taskQueueService.checkTaskStatus(task);
                    successCount++;
                    
                } catch (Exception e) {
                    logger.error("轮询查询任务失败: taskId={}, error={}", task.getTaskId(), e.getMessage(), e);
                    errorCount++;
                }
            }
            
            logger.info("=== 轮询查询完成 ===");
            logger.info("成功查询: {} 个任务", successCount);
            logger.info("查询失败: {} 个任务", errorCount);
            logger.info("总任务数: {} 个", processingTasks.size());
            
        } catch (Exception e) {
            logger.error("轮询查询执行失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 手动触发轮询查询（用于测试）
     */
    public void manualPollingQuery() {
        logger.info("手动触发轮询查询");
        executePollingQuery();
    }

    /**
     * 获取轮询查询统计信息
     */
    public String getPollingStats() {
        List<TaskQueue> allTasks = taskQueueRepository.findAll();
        long processingCount = allTasks.stream().filter(t -> t.getStatus() == TaskQueue.QueueStatus.PROCESSING).count();
        long completedCount = allTasks.stream().filter(t -> t.getStatus() == TaskQueue.QueueStatus.COMPLETED).count();
        long failedCount = allTasks.stream().filter(t -> t.getStatus() == TaskQueue.QueueStatus.FAILED).count();
        
        return String.format("轮询查询统计 - 处理中: %d, 已完成: %d, 已失败: %d", 
            processingCount, completedCount, failedCount);
    }
}
