lpt-be/src/main/java/com/guo/learningprogresstracker/controller/ReviewController.java

package com.guo.learningprogresstracker.controller;

import com.guo.learningprogresstracker.dto.ReviewFeedItem;
import com.guo.learningprogresstracker.dto.ReviewTaskStats;
import com.guo.learningprogresstracker.dto.request.RecallCompareRequest;
import com.guo.learningprogresstracker.dto.request.UpdateStandardMindMapRequest;
import com.guo.learningprogresstracker.dto.request.UpsertReviewMindMapRequest;
import com.guo.learningprogresstracker.entity.CommonResult;
import com.guo.learningprogresstracker.entity.ReviewMindMapEntity;
import com.guo.learningprogresstracker.entity.ReviewRecallRecordEntity;
import com.guo.learningprogresstracker.entity.ReviewStandardMindMapEntity;
import com.guo.learningprogresstracker.entity.StudyReportFragmentsEntity;
import com.guo.learningprogresstracker.entity.StudyReportsEntity;
import com.guo.learningprogresstracker.exception.NotFindEntitiesException;
import com.guo.learningprogresstracker.exception.OperationFailedException;
import com.guo.learningprogresstracker.service.ReviewService;
import com.guo.learningprogresstracker.service.StandardMindMapService;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.http.MediaType;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.util.List;
import java.util.Map;

/**
 * 复习模块控制层 — 复习内容滚动展示与交互
 */
@RequestMapping("/review")
@RestController
@Validated
@RequiredArgsConstructor
public class ReviewController {

    private final ReviewService reviewService;

    private final StandardMindMapService standardMindMapService;

    /**
     * 获取复习 feed，合并报告和残片按时间倒序
     */
    @GetMapping("/feed")
    public CommonResult<List<ReviewFeedItem>> getReviewFeed(
            @RequestParam(defaultValue = "30") int limit,
            @RequestParam(defaultValue = "recent") String mode) {
        return CommonResult.success(reviewService.getReviewFeed(limit, mode));
    }

    /**
     * 获取任务维度的复习统计汇总
     */
    @GetMapping("/tasks")
    public CommonResult<List<ReviewTaskStats>> getReviewTaskStats() {
        return CommonResult.success(reviewService.getReviewTaskStats());
    }

    /**
     * 获取指定任务的复习统计汇总
     */
    @GetMapping("/tasks/{taskNum}")
    public CommonResult<ReviewTaskStats> getReviewTaskStats(@PathVariable String taskNum) {
        return CommonResult.success(reviewService.getReviewTaskStats(taskNum));
    }

    /**
     * 获取指定任务下的所有报告和残片
     */
    @GetMapping("/task/{taskNum}")
    public CommonResult<List<ReviewFeedItem>> getTaskReview(@PathVariable String taskNum) {
        return CommonResult.success(reviewService.getTaskReview(taskNum));
    }

    /**
     * 获取报告详情
     */
    @GetMapping("/report/{id}")
    public CommonResult<StudyReportsEntity> getReportDetail(@PathVariable int id) throws NotFindEntitiesException {
        return CommonResult.success(reviewService.getReportDetail(id));
    }

    /**
     * 获取残片详情
     */
    @GetMapping("/fragment/{id}")
    public CommonResult<StudyReportFragmentsEntity> getFragmentDetail(@PathVariable int id) throws NotFindEntitiesException {
        return CommonResult.success(reviewService.getFragmentDetail(id));
    }

    /**
     * 获取指定任务的思维导图
     */
    @GetMapping("/mind-map/{taskNum}")
    public CommonResult<ReviewMindMapEntity> getMindMap(@PathVariable String taskNum) throws NotFindEntitiesException {
        return CommonResult.success(reviewService.getMindMap(taskNum));
    }

    /**
     * 创建或更新指定任务的思维导图
     */
    @PutMapping("/mind-map/{taskNum}")
    public CommonResult<ReviewMindMapEntity> upsertMindMap(
            @PathVariable String taskNum,
            @Valid @RequestBody UpsertReviewMindMapRequest request) throws NotFindEntitiesException {
        return CommonResult.success(reviewService.upsertMindMap(taskNum, request));
    }

    /**
     * 上传并解析指定任务的思维导图文件
     */
    @PostMapping(value = "/mind-map/{taskNum}/upload", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    public CommonResult<ReviewMindMapEntity> uploadMindMap(
            @PathVariable String taskNum,
            @RequestParam("file") MultipartFile file) throws NotFindEntitiesException, IOException {
        return CommonResult.success(reviewService.uploadMindMap(taskNum, file));
    }

    // ============ 标准思维导图与回忆对比 ============

    /**
     * 获取或自动生成任务的标准思维导图
     */
    @GetMapping("/standard-mind-map/{taskNum}")
    public CommonResult<ReviewStandardMindMapEntity> getStandardMindMap(
            @PathVariable String taskNum) throws NotFindEntitiesException, OperationFailedException {
        return CommonResult.success(standardMindMapService.getOrGenerate(taskNum));
    }

    /**
     * 强制重新生成任务的标准思维导图
     * @param mode 生成模式：full（全量覆盖，默认）或 incremental（增量合并）
     */
    @PostMapping("/standard-mind-map/{taskNum}/regenerate")
    public CommonResult<ReviewStandardMindMapEntity> regenerateStandardMindMap(
            @PathVariable String taskNum,
            @RequestParam(defaultValue = "full") String mode) throws NotFindEntitiesException, OperationFailedException {
        if ("incremental".equals(mode)) {
            return CommonResult.success(standardMindMapService.incrementalGenerate(taskNum));
        }
        return CommonResult.success(standardMindMapService.regenerate(taskNum));
    }

    /**
     * 用户编辑标准思维导图（大纲文本形式）
     */
    @PutMapping("/standard-mind-map/{taskNum}")
    public CommonResult<ReviewStandardMindMapEntity> updateStandardMindMap(
            @PathVariable String taskNum,
            @Valid @RequestBody UpdateStandardMindMapRequest request) throws NotFindEntitiesException {
        return CommonResult.success(standardMindMapService.updateByOutline(taskNum, request.getOutline()));
    }

    /**
     * 用户提交回忆大纲，与标准导图对比
     */
    @PostMapping("/standard-mind-map/{taskNum}/recall")
    public CommonResult<ReviewStandardMindMapEntity> recallCompare(
            @PathVariable String taskNum,
            @Valid @RequestBody RecallCompareRequest request) throws NotFindEntitiesException, OperationFailedException {
        return CommonResult.success(standardMindMapService.recallCompare(taskNum, request.getRecallOutline(), request.getFocusPath()));
    }

    /**
     * 在标准导图中查找与给定内容最匹配的节点
     */
    @PostMapping("/standard-mind-map/{taskNum}/find-node")
    public CommonResult<Map<String, Object>> findNode(
            @PathVariable String taskNum,
            @RequestBody Map<String, String> body) throws NotFindEntitiesException, OperationFailedException {
        String content = body != null ? body.getOrDefault("content", "") : "";
        return CommonResult.success(standardMindMapService.findNode(taskNum, content));
    }

    /**
     * 获取该任务的所有回忆对比记录
     */
    @GetMapping("/standard-mind-map/{taskNum}/recall-records")
    public CommonResult<List<ReviewRecallRecordEntity>> listRecallRecords(
            @PathVariable String taskNum) throws NotFindEntitiesException {
        return CommonResult.success(standardMindMapService.listRecallRecords(taskNum));
    }

    /**
     * 获取单条回忆对比记录详情
     */
    @GetMapping("/standard-mind-map/recall-records/{recordId}")
    public CommonResult<ReviewRecallRecordEntity> getRecallRecord(
            @PathVariable Integer recordId) throws NotFindEntitiesException {
        return CommonResult.success(standardMindMapService.getRecallRecord(recordId));
    }
}