EAI-Backend/src/main/java/com/njuzr/eaibackend/controller/AIController.java

package com.njuzr.eaibackend.controller;

import com.njuzr.eaibackend.dto.AIDTO;
import com.njuzr.eaibackend.po.AIEntry;
import com.njuzr.eaibackend.service.AIDialogueService;
import com.njuzr.eaibackend.service.AIRequestService;
import com.njuzr.eaibackend.vo.AIDialogueVO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.http.MediaType;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;

/**
 * @author: Leonezhurui
 * @Date: 2024/3/1 - 23:36
 * @Package: EAI-Backend
 */

@Slf4j
@RestController
@RequestMapping("/api/ai")
public class AIController {
    private final AIDialogueService aiDialogueService;

    private final AIRequestService aiRequestService;

    @Autowired
    public AIController(AIDialogueService aiDialogueService, AIRequestService aiRequestService) {
        this.aiDialogueService = aiDialogueService;
        this.aiRequestService = aiRequestService;
    }

    @PreAuthorize("hasRole('ROLE_STUDENT') or hasRole('ROLE_TEACHER')")
    @GetMapping
    public MyResponse getDialogues(
            @RequestParam Long assignmentId,
            @RequestParam Long userId,
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "20") int size

    ) {
        AIDialogueVO dialogues = aiDialogueService.getAIDialogue(assignmentId, userId, page, size);
        return MyResponse.success(dialogues);
    }

    /**
     * 获得AI智能评价的内容（取最后一个即可）
     * @return
     */
    @GetMapping("/rewrite/result")
    public MyResponse getRewriteResult(
            @RequestParam Long assignmentId,
            @RequestParam Long userId
    ) {

        return MyResponse.success(aiDialogueService.getRewriteResult(assignmentId, userId));
    }

    /**
     * 学生进入写作界面触发，创建AI会话
     * @param assignmentId
     * @param userId
     * @return
     */
    @PreAuthorize("hasRole('ROLE_STUDENT')")
    @PostMapping //这个接口实际上没用过，因为创建会话的操作已经放在了AssignmentController里面的参加作业接口里了
    public MyResponse createDialogue(
            @RequestParam Long assignmentId,
            @AuthenticationPrincipal(expression = "id") Long userId
    ) {
        aiDialogueService.ensureAIDialogueExists(assignmentId, userId);
        return MyResponse.success("创建AI会话成功");
    }

    /**
     * 学生请求AI：1WebClient请求，获得结果；2存储+返回
     * @param dialogueId
     * @param aidto
     * @return
     */
    @PreAuthorize("hasRole('ROLE_STUDENT')")
    @PutMapping
    public MyResponse requestAI(
            @RequestParam String dialogueId,
            @RequestBody AIDTO aidto
            ) {
        log.info("解析参数为{}, AI会话ID为{}", aidto.toString(), dialogueId);
        AIEntry entry = aiDialogueService.requestAI(dialogueId, aidto);
        return MyResponse.success(entry);
    }

    /**
     * 学生请求AI（流式响应）- 使用 DeepSeek
     * 返回 SSE 流式响应，实时显示AI回复内容
     * @param dialogueId 对话ID
     * @param aidto 对话请求DTO
     * @return SseEmitter 流式响应
     */
    @PutMapping(value = "/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public SseEmitter requestAIStream(
            @RequestParam String dialogueId,
            @RequestBody(required = false) AIDTO aidto,
            @AuthenticationPrincipal(expression = "id") Long principalUserId
    ) {
        log.info("========== 流式接口被调用 ==========");
        log.info("流式对话请求 - dialogueId={}, aidto={}, principalUserId={}", dialogueId, aidto, principalUserId);
        
        if (aidto == null) {
            log.error("【错误】请求体为空");
            SseEmitter emitter = new SseEmitter();
            emitter.completeWithError(new RuntimeException("请求体不能为空"));
            return emitter;
        }
        if (aidto.getMessages() == null) {
            log.error("【错误】消息列表为空");
            SseEmitter emitter = new SseEmitter();
            emitter.completeWithError(new RuntimeException("消息列表不能为空"));
            return emitter;
        }

        if (aidto.getUserId() == null && principalUserId != null) {
            aidto.setUserId(principalUserId);
        }
        
        log.info("【参数校验通过】dialogueId={}, 消息数={}", dialogueId, aidto.getMessages().size());
        
        try {
            SseEmitter result = aiDialogueService.requestAIStream(dialogueId, aidto);
            log.info("【成功】调用aiDialogueService.requestAIStream完成");
            return result;
        } catch (Exception e) {
            log.error("【异常】调用aiDialogueService.requestAIStream失败: {}", e.getMessage(), e);
            SseEmitter emitter = new SseEmitter();
            emitter.completeWithError(e);
            return emitter;
        }
    }

    @PostMapping("/rewrite")
    public MyResponse rewrite(
            @RequestParam Long assignmentId,
            @RequestParam Long studentId
    ) {
//        AIEntry entry = aiDialogueService.rewrite(assignmentId, studentId);
        return MyResponse.success(aiDialogueService.rewrite(assignmentId, studentId));
    }

    @PostMapping("/chatgpt")
    public MyResponse requestChatGPT(
            @RequestBody AIDTO aidto
    ) {
        AIRequestService.AIResponse res = aiRequestService.requestChatGPT(aidto.getMessages());
        return MyResponse.success(res);
    }

}