/**
 * @ProjectName: 智慧评标-主观分助手
 * @Package: com.zhpb.gdyd_zhpb_zgf.service
 * @ClassName: SummaryGenerationScheduleService
 * @Description: 摘要总结定时扫描服务 - 每3分钟扫描摘要为空的章节并调用模型生成摘要
 * @Author: 张志锋
 * @Date: 2025-12-13
 * @Version: 1.0
 * @Copyright: © 2025 智慧评标-主观分助手
 */
package com.zhpb.gdyd_zhpb_zgf.service;

import com.zhpb.gdyd_zhpb_zgf.context.ModelRequestContextHolder;
import com.zhpb.gdyd_zhpb_zgf.entity.mysql.FileDirectory;
import com.zhpb.gdyd_zhpb_zgf.entity.mysql.PromptTemplate;
import com.zhpb.gdyd_zhpb_zgf.repository.mysql.FileDirectoryRepository;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * 摘要总结定时扫描服务
 * 每3分钟扫描一次摘要为空的章节记录，调用模型生成摘要
 * 使用单线程处理，避免资源竞争
 */
@Service
public class SummaryGenerationScheduleService {

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

    /** 每批处理的最大数量 */
    private static final int BATCH_SIZE = 20;

    /** 标记是否正在执行，确保只有一个线程在处理 */
    private final AtomicBoolean isRunning = new AtomicBoolean(false);

    @Autowired
    private FileDirectoryRepository fileDirectoryRepository;

    @Autowired
    private PromptTemplateService promptTemplateService;

    @Autowired
    private AIModelService aiModelService;

    @Autowired
    private ChapterContentResolver chapterContentResolver;

    /**
     * 定时任务：每3分钟执行一次，扫描摘要为空的章节
     */
    @Scheduled(fixedRate = 3 * 60 * 1000, initialDelay = 2 * 60 * 1000) // 3分钟执行一次，启动后2分钟开始
    public void scanAndGenerateMissingSummaries() {
        // 使用原子操作确保只有一个线程在执行
        if (!isRunning.compareAndSet(false, true)) {
            logger.debug("[摘要定时扫描] 上一次任务尚未完成，跳过本次执行");
            return;
        }

        try {
            logger.info("[摘要定时扫描] ========== 开始扫描摘要为空的章节 ==========");
            
            // 查询摘要为空的章节记录
            List<FileDirectory> emptyDirectories = fileDirectoryRepository.findBySummaryIsNullOrEmpty();
            
            if (emptyDirectories.isEmpty()) {
                logger.info("[摘要定时扫描] 没有发现需要生成摘要的章节");
                return;
            }
            
            logger.info("[摘要定时扫描] 发现 {} 个需要生成摘要的章节，开始处理（最多处理{}个）", 
                emptyDirectories.size(), BATCH_SIZE);
            
            // 获取摘要提示词模板
            PromptTemplate summaryTemplate = promptTemplateService.getActiveTemplate("summary");
            if (summaryTemplate == null) {
                logger.error("[摘要定时扫描] 未找到激活的文档摘要提示词模板，请启用或创建summary类型的提示词模板");
                return;
            }
            
            String promptTemplate = summaryTemplate.getPromptContent();
            logger.info("[摘要定时扫描] 使用提示词模板: {} (ID: {})", 
                summaryTemplate.getTemplateName(), summaryTemplate.getTemplateId());
            
            int successCount = 0;
            int failCount = 0;
            int processedCount = 0;
            
            // 逐个处理，使用单线程避免资源竞争
            for (FileDirectory directory : emptyDirectories) {
                if (processedCount >= BATCH_SIZE) {
                    logger.info("[摘要定时扫描] 已达到本批次处理上限({})，剩余 {} 个章节将在下次执行时处理", 
                        BATCH_SIZE, emptyDirectories.size() - processedCount);
                    break;
                }
                
                try {
                    processedCount++;
                    logger.info("[摘要定时扫描] 处理章节 [{}/{}]: fileId={}, chapterId={}, title={}", 
                        processedCount, Math.min(emptyDirectories.size(), BATCH_SIZE),
                        directory.getFileId(), directory.getChapterId(), directory.getTitle());
                    
                    // 生成摘要
                    String summary = generateSummary(directory, promptTemplate);
                    
                    if (summary != null && !summary.trim().isEmpty()) {
                        // 保存摘要（不修改目录抽取状态）
                        directory.setSummary(summary.trim());
                        fileDirectoryRepository.save(directory);
                        successCount++;
                        logger.info("[摘要定时扫描] 摘要生成成功: chapterId={}, 摘要长度={}", 
                            directory.getChapterId(), summary.length());
                    } else {
                        failCount++;
                        logger.warn("[摘要定时扫描] 摘要生成返回空: chapterId={}", directory.getChapterId());
                    }
                    
                } catch (Exception e) {
                    failCount++;
                    logger.error("[摘要定时扫描] 处理章节失败: chapterId={}, error={}", 
                        directory.getChapterId(), e.getMessage(), e);
                }
            }
            
            logger.info("[摘要定时扫描] ========== 扫描完成: 处理{}个, 成功{}个, 失败{}个 ==========", 
                processedCount, successCount, failCount);
            
        } catch (Exception e) {
            logger.error("[摘要定时扫描] 扫描任务执行失败", e);
        } finally {
            isRunning.set(false);
        }
    }

    /**
     * 使用AI模型生成章节摘要
     */
    private String generateSummary(FileDirectory directory, String promptTemplate) {
        try {
            // 使用模板替换变量
            String prompt = promptTemplate.replace("{title}", 
                directory.getTitle() != null ? directory.getTitle() : "未命名章节");
            
            // 获取章节内容
            String userMessage = chapterContentResolver.buildUserMessage(directory);
            
            // 调用模型生成摘要
            ModelRequestContextHolder.setRequestSource("DOC_SUMMARY_SCHEDULED");
            try {
                return aiModelService.generateResponse(prompt, userMessage);
            } finally {
                ModelRequestContextHolder.clear();
            }
            
        } catch (Exception e) {
            logger.error("[摘要定时扫描] 生成摘要失败: chapterId={}", directory.getChapterId(), e);
            return null;
        }
    }

    /**
     * 手动触发摘要生成（可通过API调用）
     * @return 处理的章节数量
     */
    public int manualTriggerSummaryGeneration() {
        logger.info("[摘要定时扫描] 手动触发摘要生成");
        scanAndGenerateMissingSummaries();
        return 0;
    }

    /**
     * 获取当前待处理的摘要数量
     */
    public long getPendingSummaryCount() {
        return fileDirectoryRepository.findBySummaryIsNullOrEmpty().size();
    }
}
