package com.project.interaction.controller;



import com.project.base.domain.exception.MissingParameterException;
import com.project.base.domain.result.Result;
import com.project.classicpaper.domain.service.ClassicPaperQuestionCallbackService;
import com.project.interaction.application.AiExtractCallbackApplicationService;
import com.project.interaction.application.AlgorithmApplicationService;
import com.project.interaction.application.DataExtractCallbackApplicationService;
import com.project.interaction.domain.dto.AiExtractCallbackDTO;
import com.project.interaction.domain.dto.ClusterCallbackDTO;
import com.project.interaction.domain.dto.DataExtractCallbackDTO;
import com.project.interaction.domain.dto.QuestionCallBackDTO;
import com.project.interaction.domain.service.GenerateQuestionQueueService;
import com.project.question.domain.enums.QuestionSourceTypeEnum;
import com.project.question.domain.service.GenerateQuestionDomainService;
import com.project.task.application.TaskApplicationService;
import com.project.task.domain.enums.QuestionTypeEnum;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/interaction")
public class InteractionController {

    @Autowired
    private AlgorithmApplicationService algorithmApplicationService;
    @Autowired
    private TaskApplicationService taskApplicationService;
    @Autowired
    private GenerateQuestionQueueService generateQuestionQueueService;
    @Autowired
    private GenerateQuestionDomainService generateQuestionDomainService;

    // =============== V1.1 新增：数据服务/算法服务回调 ============
    @Autowired
    private DataExtractCallbackApplicationService dataExtractCallbackApplicationService;
    @Autowired
    private AiExtractCallbackApplicationService aiExtractCallbackApplicationService;

    @Autowired
    private ClassicPaperQuestionCallbackService classicPaperQuestionCallbackService;


//    @PostMapping("/saveCluster")
//    public Result<String> saveCluster(ClusterCallbackDTO dto) throws Exception{
//        algorithmApplicationService.saveCluster(dto.getTaskId(), dto.getClusters());
//        return Result.success("保存成功");
//    }

    @PostMapping("/saveCluster")
    public Result<String> saveCluster(ClusterCallbackDTO dto) throws Exception{
        algorithmApplicationService.saveClusterByInformationId(dto.getTaskId(), dto.getClusters());
        return Result.success("保存成功");
    }

    /**
     * 生题结果回调（通用题库 + 经典套卷）
     * 通过 bizKey 区分业务场景：
     *   - "PQ:paperQuestionId" → 经典套卷生题
     *   其他或 null → 通用题库（暂未实现，静默忽略）
     */
    @PostMapping("/saveQuestion")
    public Result<String> saveQuestion(@RequestBody QuestionCallBackDTO dto) throws Exception {
        String bizKey = dto.getBizKey();
        if (bizKey != null && bizKey.startsWith("PQ:")) {
            classicPaperQuestionCallbackService.handleCallback(dto);
        }
        // 其他 bizKey 或 null → 暂不处理（兼容旧逻辑）
        return Result.success("回调处理成功");
    }

    /**
     * 判断任务是否删除
     */
    @PostMapping("/isDeletedTask")
    public Result<Boolean> isDeletedTask(Long taskId,@RequestParam("taskKpIds") List<Long> taskKpIds,Integer type){
        return taskApplicationService.isDeletedTask(taskId,taskKpIds,type);
    }

    /**
     * 获取当前队列大小
     */
    @GetMapping("/getQueueSize")
    public Result<Integer> getQueueSize(){
        return Result.success(generateQuestionQueueService.getQueueSize());
    }

    /**
     * 生题请求
     */
    @PostMapping("/generateQuestion")
    public Result<String> generateQuestion(Long sourceId, Integer questionType , int needCount){
        QuestionTypeEnum questionTypeEnum = QuestionTypeEnum.findByValue(questionType);
        if (questionTypeEnum == null){
            throw new MissingParameterException("题型不存在");
        }

        generateQuestionDomainService.produce(sourceId,questionTypeEnum,
                QuestionTypeEnum.MULTIPLE_CHOICE.equals(questionTypeEnum) ? QuestionSourceTypeEnum.Multi_Concept : QuestionSourceTypeEnum.Single_Concept,
                needCount,Boolean.TRUE);

        return Result.success(null);
    }

    // =============== V1.1 新增回调路由 ============

    /**
     * 数据服务解析完成回调
     * 每个子文件解析完成后回调，检查批次是否全部完成
     */
    @PostMapping("/dataExtractCallback")
    public Result<String> dataExtractCallback(@RequestBody DataExtractCallbackDTO dto) {
        dataExtractCallbackApplicationService.handleCallback(dto);
        return Result.success("回调处理成功");
    }

    /**
     * 算法服务知识点提取回调
     * 算法服务返回草稿知识点，写入草稿表
     */
    @PostMapping("/aiExtractCallback")
    public Result<String> aiExtractCallback(@RequestBody AiExtractCallbackDTO dto) {
        aiExtractCallbackApplicationService.handleCallback(dto);
        return Result.success("回调处理成功");
    }

}