Respan Dataset Explorer

能详细一下介绍算法吗

当然可以！该项目的核心算法基于认知心理学中的“**遗忘曲线**”和“**间隔重复(Spaced Repetition)**”理论，结合短期记忆与长期记忆两个阶段设计了一套单词复习管理机制。下面详细介绍这套算法的原理和具体实现：

---

# 一、总体思路

- **分阶段（短期记忆 vs 长期记忆）管理单词**：  
  - **短期记忆阶段**聚焦于新添加单词，通过频繁复习快速提升熟悉度。  
  - **长期记忆阶段**对已经较为熟悉的单词进行周期性的间隔复习，巩固记忆，防止遗忘。

- **每个阶段用特定的数据结构和规则管理单词的状态和复习时间。**

---

# 二、短期记忆算法

短期记忆阶段储存在`user_word_memory`表中，主要字段包括：`score`，`lastSeen`（表示上次复习轮次）。

## 1. 单词状态与分数（score）

- 初始插入时，`score=0`，`lastSeen=-1`（表示尚未开始复习）。
- 用户复习单词时，根据用户记忆反馈调整`score`：
  - **认识（remembered=true）**：`score += 1`  
  - **忘记（remembered=false）**：`score -= 1`，但最低不低于0。

## 2. 复习计划生成

- 按照“**轮次**”（round）和“**冷却时间**”（cooldown）过滤短期单词，生成复习候选：
  - 只有满足 `round - lastSeen >= cooldown` 的单词才可被纳入本轮复习。
  - 这样避免同一轮次短时间内重复复习，防止学习疲劳。
- 按分数（score）和上次复习轮次（lastSeen）排序，优先复习分数低、久未复习单词。

## 3. 达到通过标准迁移至长期记忆

- 当`score`达到预设阈值（比如3）认为短期阶段通过，触发迁移：
  - 在`long_term_memory`表中创建新条目，初始阶段（interval=0，nextReviewDate=当前时间）。
  - 从短期记忆表中删除该单词记录。
- 如果不通过，则仅更新score和lastSeen信息，留待后续轮次继续复习。

---

# 三、长期记忆算法

长期记忆阶段储存在`long_term_memory`表中，字段更多，主要用来管理复习间隔、阶段和复习次数。

## 1. 主要字段解释

- `reviewCount`：复习的总次数。
- `longmemoryScore` & `passCount`：统计本阶段内连续通过的次数（score用于动态调整，passCount用于累计判断是否进入下一阶段）。
- `longmemorySeen`：当前记忆阶段（阶段号或轮次），例如0代表最初阶段，数字越大表明阶段越深，复习间隔越长。
- `intervalDays`：当前阶段复习间隔（天数）。
- `nextReviewDate`：下一次复习的计划时间。
- `lastReviewDate`：上次复习时间。

## 2. 复习候选筛选

- 只获取`nextReviewDate <= 当前时间`的单词，意味着单词已经到了该进行复习的时间点。
- 按阶段优先级(`longmemorySeen`升序)和`nextReviewDate`排序，优先复习较浅阶段和时间较早的单词。

## 3. 复习结果处理

- **用户“认识”单词时**：
  - `longmemoryScore`（分数）+1，`passCount` +1。
  - 当`longmemoryScore >= 3`时（累计3次通过）：
    - 进入下一阶段：
      - 阶段号`longmemorySeen = min(longmemorySeen + 1, maxStage)`。
      - 更新`nextReviewDate = 当前时间 + 新阶段对应间隔`（间隔以小时计，如24h,48h,96h等）。
      - 更新`intervalDays`为当前阶段间隔的天数。
      - 重置`longmemoryScore`和`passCount`为0。
    - 通过分数清零，达到阶段跃迁的效果。
  - 更新`lastReviewDate`和`reviewCount`。

- **用户“忘记”单词时**：
  - `longmemoryScore` -1，但不低于0。
  - 不降低阶段号和不更新时间间隔，确保阶段稳定。
  - 复习次数`reviewCount`记录仍会增加。

## 4. 记忆间隔设计

- 定义阶段间隔数组，单位小时，例如：

  ```java
  int[] intervalsHours = {24, 48, 96, 168, 360};
  ```

  即1天、2天、4天、7天、15天，模拟遗忘曲线中逐渐加长的复习间隔。
  
- 这样用户经历多个阶段后，复习间隔逐渐变长，符合间隔重复的优化原则，减少无效重复，提高学习效率。

---

# 四、算法整体流程示意

```
用户 -> 选择单词 -> 短期记忆阶段管理：
    短期复习循环：（每个复习轮次）
        根据冷却时间筛选待复习词
        复习 - 调整score
        score达到阈值时
            迁移到长期记忆阶段
        否则继续短期复习

长期记忆阶段：
    定期（依据nextReviewDate）选择待复习单词
    复习 - 根据反馈调整score和passCount
    累计通过3次时升级阶段
    阶段升级则增加复习间隔，安排下次复习时间
```

---

# 五、该算法优点与特点

- **结合遗忘曲线刺激复习**：根据时间间隔，动态决定复习时间点，避免或减少遗忘。
- **分阶段设计更精准**：短期记忆用于快速积累和巩固新单词，长期记忆用于长期强化记忆，二者协同。
- **动态调整难度与节奏**：根据用户反馈智能调整复习频率，分数和间隔。
- **阶段边界明晰**：通过score和passCount控制阶段切换，控制复习强度。
- **支持批量多单词管理和分页**，便于扩展和优化。

---

# 六、可能的进一步优化建议

- 根据用户忘记和认识的比例动态调整阶段间隔。
- 引入遗忘概率模型（如SM-2算法）计算更科学的下次复习时间。
- 利用机器学习个性化调整复习计划和间隔。
- 复习结果支持更多反馈等级，精细化评分。
- 用户情绪和学习行为结合，进一步调节算法。

---

# 总结

该项目通过对单词的短期记忆复习和长期记忆分阶段复习，把握了记忆巩固的关键—**重复与间隔**，用简单明了的状态字段（如score、passCount、longmemorySeen等）实现复习状态追踪和阶段调整，帮助用户科学高效地进行单词记忆和复习。

---

如果你需要，我还可以帮你写一个示意伪代码，或者详细解读某个方法的实现逻辑！

按分数（score）和上次复习轮次（lastSeen）排序，这个是冒泡排序还是什么排序

“按分数（score）和上次复习轮次（lastSeen）排序”这个排序其实是由数据库层面的SQL语句完成的，而不是用程序中的冒泡排序或者其他手写排序算法实现。

---

## 具体情况说明：

### 1. 排序是在 SQL 查询中完成的

查看 `StudyMapper` 中用于获取复习单词的SQL：

```xml
<select id="selectReviewCandidates" resultType="com.example.springboot.entity.Study" parameterType="map">
    SELECT
        um.id,
        um.user_id AS userId,
        um.word_id AS wordId,
        um.score,
        um.last_seen AS lastSeen,
        w.word,
        w.definition,
        w.pronunciation
    FROM user_word_memory um
             JOIN words w ON um.word_id = w.id
    WHERE um.user_id = #{userId} AND (#{round} - um.last_seen) >= #{cooldown}
    ORDER BY um.score ASC, um.last_seen ASC
    LIMIT #{limit}
</select>
```

这里用的是 `ORDER BY um.score ASC, um.last_seen ASC`，表示先按照 `score` 从小到大排序（score低的优先复习），如果score相同，则按照 `lastSeen`（最近一次复习轮次）升序排序。

---

### 2. 数据库排序算法

- 该排序由数据库的查询优化器完成，常见数据库如MySQL、PostgreSQL等会采用**快速排序（Quick Sort）**、**归并排序（Merge Sort）**或者**堆排序（Heap Sort）**等高效排序算法。
- 对于大数据量和复杂查询，数据库还可能使用索引、排序缓冲等机制进行优化。

---

### 3. 这与冒泡排序无关

- **冒泡排序**是一种简单但效率较低（时间复杂度O(n²)）的排序算法，通常只用于教学和极小规模场景。
- 在这个项目中，排序不会在Java程序代码层实现手写排序，而是依赖数据库的排序性能。

---

## 小结

- 排序是交给数据库处理的，使用了`ORDER BY`子句。
- 数据库底层通常使用快速排序或归并排序等高效排序算法，而不是冒泡排序。
- 作为开发者，只需在SQL语句中指定排序顺序即可，无需关心具体排序实现细节。

---

如果你对某种排序算法感兴趣，或者想了解如果在Java里写排序代码，可以告诉我，我可以帮你讲解或者写示范代码。

package com.example.springboot.controller;

import com.example.springboot.dto.LongTermMemoryWithWord;
import com.example.springboot.entity.LongTermMemory;
import com.example.springboot.entity.Study;
import com.example.springboot.service.StudyService;
import org.springframework.web.bind.annotation.*;
import org.springframework.http.ResponseEntity;
import org.springframework.http.HttpStatus;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/study")
public class StudyController {

    @Resource
    private StudyService studyService;
    //  用户选择单词
    @PostMapping("/select-words")
    public ResponseEntity<?> userSelectWords(@RequestBody Map<String, Object> payload) {
        Integer userId = (Integer) payload.get("userId");
        List<Integer> wordIds = (List<Integer>) payload.get("wordIds");

        if (userId == null || wordIds == null || wordIds.isEmpty()) {
            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("参数错误");
        }

        int insertedCount = studyService.insertUserSelectedWords(userId, wordIds);

        if (insertedCount == 0) {
            return ResponseEntity.status(HttpStatus.CONFLICT).body("所有单词已存在，无需再添加");
        }

        return ResponseEntity.ok("成功添加 " + insertedCount + " 个新单词");
    }

   //  获取已经选择的单词列表
    @GetMapping("/select-words")
    public ResponseEntity<?> getSelectedWords(@RequestParam(value = "userId", required = false) String userIdStr) {
        if (userIdStr == null || !userIdStr.matches("\\d+")) {
            return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("缺少或非法的 userId");
        }

        Integer userId = Integer.valueOf(userIdStr);
        return ResponseEntity.ok(studyService.getSelectedWordsByUserId(userId));
    }

    // 获取用户可选的未学习单词（用于前端弹窗选择）
    @GetMapping("/pending-words")
    public ResponseEntity<?> getPendingWords(
            @RequestParam("userId") Integer userId,
            @RequestParam(value = "limit", defaultValue = "100") Integer limit) {
        return ResponseEntity.ok(studyService.getPendingWords(userId, limit));
    }

    // 删除用户选择的单词
    @PostMapping("/remove-word")
    public ResponseEntity<?> removeWord(@RequestBody Map<String, Object> payload) {
        Integer userId = (Integer) payload.get("userId");
        Integer wordId = (Integer) payload.get("wordId");
        if (userId == null || wordId == null) {
            return ResponseEntity.badRequest().body("参数错误");
        }
        int rows = studyService.deleteWord(userId, wordId);
        if (rows > 0) {
            return ResponseEntity.ok("删除成功");
        } else {
            return ResponseEntity.status(HttpStatus.NOT_FOUND).body("未找到单词");
        }
    }

    //  批量删除用户选择的单词
    @PostMapping("/remove-words")
    public ResponseEntity<?> removeWords(@RequestBody Map<String, Object> payload) {
        Integer userId = (Integer) payload.get("userId");
        List<Integer> wordIds = (List<Integer>) payload.get("wordIds");
        if (userId == null || wordIds == null || wordIds.isEmpty()) {
            return ResponseEntity.badRequest().body("参数错误");
        }
        int rows = studyService.deleteWords(userId, wordIds);
        if (rows > 0) {
            return ResponseEntity.ok("批量删除成功");
        } else {
            return ResponseEntity.status(HttpStatus.NOT_FOUND).body("未找到单词");
        }
    }

    // 获取当前轮复习列表
    @GetMapping("/review-list")
    public ResponseEntity<?> getReviewList(@RequestParam Integer userId, @RequestParam Integer round) {
        List<Study> reviewList = studyService.getReviewList(userId, round);
        return ResponseEntity.ok(reviewList);
    }

    // 处理复习结果
    @PostMapping("/review-result")
    public ResponseEntity<?> postReviewResult(@RequestBody Map<String, Object> payload) {
        Integer userId = (Integer) payload.get("userId");
        Integer wordId = (Integer) payload.get("wordId");
        Integer round = (Integer) payload.get("round");
        Boolean remembered = (Boolean) payload.get("remembered");

        if (userId == null || wordId == null || round == null || remembered == null) {
            return ResponseEntity.badRequest().body("参数错误");
        }

        studyService.processReviewResult(userId, wordId, round, remembered);
        return ResponseEntity.ok("复习结果处理成功");
    }

    // 获取用户待复习单词数量
    @GetMapping("/pending-count")
    public ResponseEntity<?> getPendingCount(@RequestParam Integer userId) {
        int count = studyService.getPendingCount(userId);
        return ResponseEntity.ok(count);
    }

    /**
     * 获取长期记忆阶段待复习单词列表（nextReviewDate <= 当前时间）
     */
//    @GetMapping("/long-term-review-list")
//    public ResponseEntity<?> getLongTermReviewList(
//            @RequestParam Integer userId,
//            @RequestParam(defaultValue = "0") int page,
//            @RequestParam(defaultValue = "3") int size,
//            @RequestParam(defaultValue = "0") int longmemorySeen
//    ) {
//        int offset = page * size;
//        List<LongTermMemoryWithWord> list = studyService.getLongTermReviewList(userId, longmemorySeen, offset, size);
//        return ResponseEntity.ok(list);
//    }
    @GetMapping("/long-term-review-list")
    public ResponseEntity<?> getLongTermReviewList(
            @RequestParam Integer userId,
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "10") int size
    ) {
        List<LongTermMemoryWithWord> list = studyService.getLongTermReviewList(userId, page, size);
        return ResponseEntity.ok(list);
    }
    /**
     * 处理长期记忆复习结果反馈
     * 请求体示例：
     * {
     *   "id": 123,
     *   "remembered": true
     * }
     */
    @PostMapping("/long-term-review-result")
    public ResponseEntity<?> postLongTermReviewResult(@RequestBody Map<String, Object> payload) {
        Integer id = (Integer) payload.get("id");
        Boolean remembered = (Boolean) payload.get("remembered");

        if (id == null || remembered == null) {
            return ResponseEntity.badRequest().body("参数错误");
        }

        LongTermMemory ltm = studyService.getLongTermMemoryById(id);
        if (ltm == null) {
            return ResponseEntity.status(HttpStatus.NOT_FOUND).body("未找到对应的长期记忆记录");
        }

        studyService.processLongTermReviewResult(ltm, remembered);
        return ResponseEntity.ok("长期记忆复习结果处理成功");
    }

}




package com.example.springboot.dto;

import com.example.springboot.entity.LongTermMemory;

public class LongTermMemoryWithWord extends LongTermMemory {
    private String word;
    private String definition;
    // getter/setter


    public String getWord() {
        return word;
    }

    public void setWord(String word) {
        this.word = word;
    }

    public String getDefinition() {
        return definition;
    }

    public void setDefinition(String definition) {
        this.definition = definition;
    }
}
package com.example.springboot.entity;

import java.time.LocalDateTime;

public class LongTermMemory {

    private Integer id;
    private Integer userId;
    private Integer wordId;

    private Integer reviewCount = 0;       // 总复习次数，默认0
    private Integer intervalDays = 0;      // 下次复习间隔（单位：天），默认0

    private LocalDateTime nextReviewDate;  // 下一次复习目标日期
    private LocalDateTime lastReviewDate;  // 上一次复习日期

    private Integer longmemoryScore = 0;  // 默认0
    private Integer longmemorySeen = 0;   // 默认0
    private Integer passCount = 0;         // 复习通过计数，默认0

    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;

    private Integer round;

    public LongTermMemory() {
        // 这里字段已赋默认值，无需额外赋值
    }


    public Integer getRound() {
        return round;
    }

    public void setRound(Integer round) {
        this.round = round;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public Integer getWordId() {
        return wordId;
    }

    public void setWordId(Integer wordId) {
        this.wordId = wordId;
    }

    public Integer getReviewCount() {
        return reviewCount;
    }

    public void setReviewCount(Integer reviewCount) {
        this.reviewCount = reviewCount;
    }

    public Integer getIntervalDays() {
        return intervalDays;
    }

    public void setIntervalDays(Integer intervalDays) {
        this.intervalDays = intervalDays;
    }

    public LocalDateTime getNextReviewDate() {
        return nextReviewDate;
    }

    public void setNextReviewDate(LocalDateTime nextReviewDate) {
        this.nextReviewDate = nextReviewDate;
    }

    public LocalDateTime getLastReviewDate() {
        return lastReviewDate;
    }

    public void setLastReviewDate(LocalDateTime lastReviewDate) {
        this.lastReviewDate = lastReviewDate;
    }

    public Integer getLongmemoryScore() {
        return longmemoryScore;
    }

    public void setLongmemoryScore(Integer longmemoryScore) {
        this.longmemoryScore = longmemoryScore;
    }

    public Integer getLongmemorySeen() {
        return longmemorySeen;
    }

    public void setLongmemorySeen(Integer longmemorySeen) {
        this.longmemorySeen = longmemorySeen;
    }

    public Integer getPassCount() {
        return passCount;
    }

    public void setPassCount(Integer passCount) {
        this.passCount = passCount;
    }

    public LocalDateTime getCreatedAt() {
        return createdAt;
    }

    public void setCreatedAt(LocalDateTime createdAt) {
        this.createdAt = createdAt;
    }

    public LocalDateTime getUpdatedAt() {
        return updatedAt;
    }

    public void setUpdatedAt(LocalDateTime updatedAt) {
        this.updatedAt = updatedAt;
    }
}
package com.example.springboot.entity;

public class Study {
    private Integer id;
    private Integer userId;
    private Integer wordId;
    private Integer score;
    private Integer lastSeen;
    private String word;        // 单词文本
    private String definition;  // 单词释义

    // Getters and setters
    public String getWord() { return word; }
    public void setWord(String word) { this.word = word; }

    public String getDefinition() { return definition; }
    public void setDefinition(String definition) { this.definition = definition; }



    public Integer getId() { return id; }
    public void setId(Integer id) { this.id = id; }

    public Integer getUserId() { return userId; }
    public void setUserId(Integer userId) { this.userId = userId; }

    public Integer getWordId() { return wordId; }
    public void setWordId(Integer wordId) { this.wordId = wordId; }

    public Integer getScore() { return score; }
    public void setScore(Integer score) { this.score = score; }

    public Integer getLastSeen() { return lastSeen; }
    public void setLastSeen(Integer lastSeen) { this.lastSeen = lastSeen; }
}
package com.example.springboot.mapper;

import com.example.springboot.dto.LongTermMemoryWithWord;
import com.example.springboot.entity.LongTermMemory;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

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

@Mapper
public interface LongTermMemoryMapper {
    int insertLongTermMemory(LongTermMemory ltm);

    List<Integer> selectExistingWordIds(@Param("userId") Integer userId, @Param("wordIds") List<Integer> wordIds);

    List<LongTermMemoryWithWord> selectDueReviews(@Param("userId") Integer userId,
                                                  @Param("now") LocalDateTime now,
                                                  @Param("offset") Integer offset,
                                                  @Param("size") Integer size,
                                                  @Param("longmemorySeenList") List<Integer> longmemorySeenList);

    int updateLongTermMemory(LongTermMemory ltm);

    LongTermMemory selectById(@Param("id") Integer id);
}
package com.example.springboot.mapper;

import com.example.springboot.entity.Study;
import com.example.springboot.entity.Word;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

import java.util.List;

@Mapper
public interface StudyMapper {

    // 从user_word_plan抽取指定数量且user_word_memory中不存在的单词
    List<Study> selectPendingWordsFromPlan(@Param("userId") Integer userId, @Param("limit") int limit);

    // 查询 user_word_memory 中对应记录
    Study selectStudyByUserIdAndWordId(@Param("userId") Integer userId, @Param("wordId") Integer wordId);

    // 插入 user_word_memory
    int insertStudy(Study study);

    // 更新 user_word_memory
    int updateStudy(Study study);

    // 查询单词详情
    Word selectWordById(@Param("id") Integer id);

    // 查询某个用户的所有已选单词详细信息
    List<Word> selectSelectedWordsByUserId(@Param("userId") Integer userId);

    //  单个删除
    int deleteStudyByUserIdAndWordId(@Param("userId") Integer userId, @Param("wordId") Integer wordId);

    //  批量删除
    int deleteStudiesByUserIdAndWordIds(@Param("userId") Integer userId, @Param("wordIds") List<Integer> wordIds);


    // 根据冷却轮数筛选出符合条件的单词，排序返回前N个
    List<Study> selectReviewCandidates(@Param("userId") Integer userId,
                                       @Param("round") int round,
                                       @Param("cooldown") int cooldown,
                                       @Param("limit") int limit);


    // 删除user_word_plan中对应记录
    int deletePlanWord(@Param("userId") Integer userId, @Param("wordId") Integer wordId);

    int countPendingWords(@Param("userId") Integer userId);
}
package com.example.springboot.service;

import com.example.springboot.dto.LongTermMemoryWithWord;
import com.example.springboot.entity.LongTermMemory;
import com.example.springboot.entity.Study;
import com.example.springboot.entity.Word;
import com.example.springboot.mapper.LongTermMemoryMapper;
import com.example.springboot.mapper.StudyMapper;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.List;

@Service
public class StudyService {

    // --- Mapper 注入 ---
    @Resource
    private StudyMapper studyMapper;

    @Resource
    private LongTermMemoryMapper longTermMemoryMapper;

    // ================= 短期记忆相关 =================

    private static final int COOLDOWN = 2;
    private static final int PASS_SCORE = 3;
    private static final int N = 3;

    /**
     * 获取当前轮次的短期记忆复习候选单词
     */
    public List<Study> getReviewList(Integer userId, int round) {
        return studyMapper.selectReviewCandidates(userId, round, COOLDOWN, N);
    }

    /**
     * 处理短期记忆复习结果：
     * 通过累加分数判断是否通过阶段，
     * 通过后迁移到长期记忆表，否则更新分数和复习轮次
     */
    public void processReviewResult(Integer userId, Integer wordId, int currentRound, boolean remembered) {
        Study study = studyMapper.selectStudyByUserIdAndWordId(userId, wordId);
        if (study == null) return;

        int newScore = study.getScore();
        if (remembered) {
            newScore += 1;
        } else {
            newScore = Math.max(newScore - 1, 0);
        }

        if (newScore >= PASS_SCORE) {
            // 通过短期考核，迁移到长期记忆，删除短期记录
            moveToLongTermMemory(study, currentRound, newScore);
            studyMapper.deleteStudyByUserIdAndWordId(userId, wordId);
        } else {
            // 未通过，更新短期记忆分数和最近复习的轮次
            study.setScore(newScore);
            study.setLastSeen(currentRound);
            studyMapper.updateStudy(study);
        }
    }

    /**
     * 短期记忆→长期记忆迁移
     * intervalDays=0 表示首次长期复习未完成，
     * nextReviewDate设置为当前时间以供首次长期复习
     */
    private void moveToLongTermMemory(Study study, int currentRound, int score) {
        LongTermMemory ltm = new LongTermMemory();

        ltm.setUserId(study.getUserId());
        ltm.setWordId(study.getWordId());
        ltm.setReviewCount(0);       // 首次长期复习前 复习计数0
        ltm.setIntervalDays(0);      // 0表示首次长期复习阶段
        LocalDateTime now = LocalDateTime.now();
        ltm.setLastReviewDate(now);
        ltm.setNextReviewDate(now);  // 立即可复习首次长期任务
        // longmemoryScore, longmemorySeen等字段保持默认即可

        longTermMemoryMapper.insertLongTermMemory(ltm);
    }

    /**
     * 用户手动添加单词到短期记忆
     */
    public int insertUserSelectedWords(Integer userId, List<Integer> wordIds) {
        int count = 0;
        for (Integer wordId : wordIds) {
            Study exist = studyMapper.selectStudyByUserIdAndWordId(userId, wordId);
            if (exist == null) {
                Study study = new Study();
                study.setUserId(userId);
                study.setWordId(wordId);
                study.setScore(0);
                study.setLastSeen(-1);
                studyMapper.insertStudy(study);
                count++;
                studyMapper.deletePlanWord(userId, wordId);
            }
        }
        return count;
    }

    /**
     * 获取用户已选短期记忆单词列表
     */
    public List<Word> getSelectedWordsByUserId(Integer userId) {
        return studyMapper.selectSelectedWordsByUserId(userId);
    }

    /**
     * 获取用户待学习的短期记忆单词（待加入短期记忆）
     */
    public List<Study> getPendingWords(Integer userId, int limit) {
        return studyMapper.selectPendingWordsFromPlan(userId, limit);
    }

    /**
     * 删除单个短期记忆单词记录
     */
    public int deleteWord(Integer userId, Integer wordId) {
        return studyMapper.deleteStudyByUserIdAndWordId(userId, wordId);
    }

    /**
     * 批量删除短期记忆单词记录
     */
    public int deleteWords(Integer userId, List<Integer> wordIds) {
        return studyMapper.deleteStudiesByUserIdAndWordIds(userId, wordIds);
    }

    /**
     * 查询用户短期记忆待复习单词总数（用于展示）
     */
    public int getPendingCount(Integer userId) {
        return studyMapper.countPendingWords(userId);
    }


    // ================= 长期记忆相关 =================

    // 长期记忆复习阶段间隔（单位：天）
    private static final int[] INTERVALS = {1, 2, 4, 7, 15};

    /**
     * 获取长期记忆阶段待复习单词列表（nextReviewDate <= 当前时间）
     */
//    public List<LongTermMemoryWithWord> getLongTermReviewList(Integer userId, int longMemorySeen, int offset, int size) {
//        LocalDateTime now = LocalDateTime.now();
//        return longTermMemoryMapper.selectDueReviews(userId, now, offset, size, longMemorySeen);
//    }

    public List<LongTermMemoryWithWord> getLongTermReviewList(Integer userId, int page, int size) {
        int offset = page * size;
        LocalDateTime now = LocalDateTime.now();

        List<Integer> stages = Arrays.asList(0,1,2,3,4,5); // 支持多阶段轮换查询

        return longTermMemoryMapper.selectDueReviews(userId, now, offset, size, stages);
    }


    /**
     * 根据长期记忆ID查询对应实体
     */
    public LongTermMemory getLongTermMemoryById(Integer id) {
        return longTermMemoryMapper.selectById(id);
    }

    /**
     * 处理长期记忆复习结果：
     * 需累计通过3次才进入下一阶段间隔；
     * 未通过扣减分数，但不降低阶段；
     * 通过后更新时间间隔及复习时间。
     */
    public void processLongTermReviewResult(LongTermMemory ltm, boolean remembered) {
        if (ltm == null) return;

        int reviewCount = (ltm.getReviewCount() == null ? 0 : ltm.getReviewCount()) + 1;
        int score = ltm.getLongmemoryScore() == null ? 0 : ltm.getLongmemoryScore();
        int passCount = ltm.getPassCount() == null ? 0 : ltm.getPassCount();
        int round = ltm.getLongmemorySeen() == null ? 0 : ltm.getLongmemorySeen();

        // 阶段间隔小时数，依次递增
        int[] intervalsHours = {24, 48, 96, 168, 360};

        if (remembered) {
            score++;
            passCount++;

            if (score >= 3) {
                int currentInterval = intervalsHours[round];

                ltm.setNextReviewDate(LocalDateTime.now().plusHours(currentInterval));
                ltm.setLastReviewDate(LocalDateTime.now());
                ltm.setIntervalDays(currentInterval / 24);

                score = 0;
                passCount = 0;

                // 轮次后移，将在下一轮复习时使用该轮次
                round = Math.min(round + 1, intervalsHours.length - 1);
                ltm.setLongmemorySeen(round);
            }
        } else {
            score = Math.max(score - 1, 0);
            // 不更新复习时间和阶段
        }

        ltm.setReviewCount(reviewCount);
        ltm.setLongmemoryScore(score);
        ltm.setPassCount(passCount);

        longTermMemoryMapper.updateLongTermMemory(ltm);
    }

}
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.example.springboot.mapper.LongTermMemoryMapper">

    <insert id="insertLongTermMemory" parameterType="com.example.springboot.entity.LongTermMemory" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO long_term_memory(
            user_id, word_id, review_count, pass_count, interval_days,
            next_review_date, last_review_date,
            longmemory_score, longmemory_seen, created_at, updated_at
        )
        VALUES(
                  #{userId}, #{wordId}, #{reviewCount}, #{passCount}, #{intervalDays},
                  #{nextReviewDate}, #{lastReviewDate},
                  #{longmemoryScore}, #{longmemorySeen}, NOW(), NOW()
              )
    </insert>

    <select id="selectExistingWordIds" resultType="int" parameterType="map">
        SELECT word_id
        FROM long_term_memory
        WHERE user_id = #{userId}
        AND word_id IN
        <foreach collection="wordIds" item="wordId" open="(" separator="," close=")">
            #{wordId}
        </foreach>
    </select>

    <select id="selectDueReviews" resultType="com.example.springboot.dto.LongTermMemoryWithWord" parameterType="map">
        SELECT ltm.*, w.word, w.definition
        FROM long_term_memory ltm
        LEFT JOIN words w ON ltm.word_id = w.id
        WHERE ltm.user_id = #{userId}
        <if test="longmemorySeenList != null and longmemorySeenList.size() > 0">
            AND ltm.longmemory_seen IN
            <foreach collection="longmemorySeenList" item="item" open="(" separator="," close=")">
                #{item}
            </foreach>
        </if>
        AND ltm.next_review_date &lt;= #{now}
        ORDER BY
        CASE
        WHEN ltm.longmemory_seen = 0 THEN 1
        WHEN ltm.longmemory_seen = 1 THEN 2
        WHEN ltm.longmemory_seen = 2 THEN 3
        WHEN ltm.longmemory_seen = 3 THEN 4
        WHEN ltm.longmemory_seen = 4 THEN 5
        WHEN ltm.longmemory_seen = 5 THEN 6
        ELSE 7
        END ASC,
        ltm.next_review_date ASC,
        ltm.last_review_date ASC
        LIMIT #{offset}, #{size}
    </select>

    <update id="updateLongTermMemory" parameterType="com.example.springboot.entity.LongTermMemory">
        UPDATE long_term_memory
        SET review_count = #{reviewCount},
            pass_count = #{passCount},
            interval_days = #{intervalDays},
            next_review_date = #{nextReviewDate},
            last_review_date = #{lastReviewDate},
            longmemory_score = #{longmemoryScore},
            longmemory_seen = #{longmemorySeen},
            updated_at = NOW()
        WHERE id = #{id}
    </update>

    <select id="selectById" resultType="com.example.springboot.entity.LongTermMemory" parameterType="int">
        SELECT *
        FROM long_term_memory
        WHERE id = #{id}
    </select>

</mapper>
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.example.springboot.mapper.StudyMapper">

    <!-- 从 user_word_plan 中抽取待学习且 user_word_memory 中不存在的单词 -->
    <select id="selectPendingWordsFromPlan" parameterType="map" resultType="com.example.springboot.entity.Study">
        SELECT
            NULL AS id,
            up.user_id AS userId,
            up.word_id AS wordId,
            w.word AS word,
            w.definition AS definition,
            0 AS score,
            -1 AS lastSeen
        FROM user_word_plan up
                 JOIN words w ON up.word_id = w.id
                 LEFT JOIN user_word_memory um ON up.user_id = um.user_id AND up.word_id = um.word_id
        WHERE up.user_id = #{userId} AND up.status = 'pending' AND um.id IS NULL
        ORDER BY up.added_at ASC
        LIMIT #{limit}
    </select>


    <!-- 查询 user_word_memory -->
    <select id="selectStudyByUserIdAndWordId" parameterType="map" resultType="com.example.springboot.entity.Study">
        SELECT id, user_id AS userId, word_id AS wordId, score, last_seen AS lastSeen
        FROM user_word_memory
        WHERE user_id = #{userId} AND word_id = #{wordId}
    </select>

    <!-- 插入 user_word_memory -->
    <insert id="insertStudy" parameterType="com.example.springboot.entity.Study" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO user_word_memory(user_id, word_id, score, last_seen)
        VALUES(#{userId}, #{wordId}, #{score}, #{lastSeen})
    </insert>

    <!-- 更新 user_word_memory -->
    <update id="updateStudy" parameterType="com.example.springboot.entity.Study">
        UPDATE user_word_memory
        SET score = #{score},
            last_seen = #{lastSeen}
        WHERE id = #{id}
    </update>

    <!-- 查询单词详情 -->
    <select id="selectWordById" parameterType="int" resultType="com.example.springboot.entity.Word">
        SELECT id, word, definition, pronunciation, custom_content AS customContent, created_at AS createdAt
        FROM words
        WHERE id = #{id}
    </select>

    <!-- 查询用户已选择的单词 -->
    <select id="selectSelectedWordsByUserId" parameterType="int" resultType="com.example.springboot.entity.Word">
        SELECT
            w.id,
            w.word,
            w.definition,
            w.pronunciation,
            w.custom_content AS customContent,
            w.created_at AS createdAt
        FROM user_word_memory uwm
                 JOIN words w ON uwm.word_id = w.id
        WHERE uwm.user_id = #{userId}
    </select>

    <!--  删除单个单词 -->
    <delete id="deleteStudyByUserIdAndWordId" parameterType="map">
        DELETE FROM user_word_memory WHERE user_id = #{userId} AND word_id = #{wordId}
    </delete>

    <!--  批量删除单词 -->
    <delete id="deleteStudiesByUserIdAndWordIds" parameterType="map">
        DELETE FROM user_word_memory WHERE user_id = #{userId} AND word_id IN
        <foreach item="wordId" collection="wordIds" open="(" separator="," close=")">
            #{wordId}
        </foreach>
    </delete>

    <select id="selectReviewCandidates" resultType="com.example.springboot.entity.Study" parameterType="map">
        SELECT
            um.id,
            um.user_id AS userId,
            um.word_id AS wordId,
            um.score,
            um.last_seen AS lastSeen,
            w.word,
            w.definition,
            w.pronunciation
        FROM user_word_memory um
                 JOIN words w ON um.word_id = w.id
        WHERE um.user_id = #{userId} AND (#{round} - um.last_seen) >= #{cooldown}
        ORDER BY um.score ASC, um.last_seen ASC
        LIMIT #{limit}
    </select>

    <!-- 删除user_word_plan中对应记录 -->
    <delete id="deletePlanWord" parameterType="map">
        DELETE FROM user_word_plan WHERE user_id = #{userId} AND word_id = #{wordId}
    </delete>

    <select id="countPendingWords" resultType="int" parameterType="int">
        SELECT COUNT(*) FROM user_word_memory WHERE user_id = #{userId}
    </select>




</mapper>
<template>
  <el-row style="height: 100vh; padding: 20px;" :gutter="20">

    <!-- 左侧：学习单词区域 -->
    <el-col :span="12" class="left-panel" style="height: 100%;">

      <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 20px;">
        <h2>短期记忆区域</h2>
        <div>
          <el-button type="primary" @click="openSelectedDialog">查看已选单词</el-button>
          <el-button type="success" @click="openDialog" style="margin-left: 10px;">选择单词</el-button>
        </div>
      </div>

      <!-- 待复习单词数量 -->
      <div class="pending-count" v-if="reviewList.length">
        待复习单词数量: {{ pendingCount }}
      </div>

      <!-- 单词卡片 -->
      <div class="card-container" v-if="reviewList.length">

        <div class="card-wrapper">
          <div class="card" :class="{ flipped: isFlipped }">

            <div class="card-face card-front">
              <!-- 正面不显示通过次数，如果需要，类似写这里 -->
              <h1>{{ currentWord.word }}</h1>
              <el-button @click.stop="speakWord(currentWord.word)">🔊 发音</el-button>
            </div>

            <div class="card-face card-back" style="position: relative;">
              <!-- 通过次数左上角绝对定位 -->
              <div class="score-badge">
                通过次数: {{ currentWord.score ?? 0 }}
              </div>
              <h1 style="margin-top: 40px;">{{ currentWord.word }}</h1>
              <p><strong>释义：</strong>{{ currentWord.definition }}</p>
              <el-button @click.stop="speakWord(currentWord.word)">🔊 发音</el-button>
            </div>

          </div>

          <div class="btn-group">
            <el-button type="danger" v-if="!isFlipped" @click="flipCard">忘记</el-button>
            <el-button type="success" v-if="!isFlipped" @click="flipCard">认识</el-button>
            <el-button type="danger" v-if="isFlipped" @click="submitReviewResult(false)">忘记</el-button>
            <el-button type="success" v-if="isFlipped" @click="submitReviewResult(true)">认识</el-button>
          </div>
        </div>
      </div>

      <!-- 无可复习单词提示 -->
      <div v-else style="text-align:center; margin-top: 50px; font-size: 20px; color: #999;">
        无可复习单词，复习完成！
      </div>

      <!-- 已选单词弹窗 -->
      <el-dialog v-model="selectedDialogVisible" title="已选单词列表" width="800px">
        <el-table
            :data="selectedWords"
            style="width: 100%;"
            border
            @selection-change="handleSelectedChange"
        >
          <el-table-column type="selection" width="55" />
          <el-table-column prop="id" label="ID" width="80" />
          <el-table-column prop="word" label="单词" />
          <el-table-column prop="definition" label="释义" />
          <el-table-column label="操作" width="100">
            <template #default="scope">
              <el-button type="danger" size="small" @click="removeWord(scope.row)">删除</el-button>
            </template>
          </el-table-column>
        </el-table>
        <template #footer>
          <span class="dialog-footer">
            <el-button @click="selectedDialogVisible = false">关闭</el-button>
            <el-button type="danger" :disabled="!selectedToDelete.length" @click="batchRemoveWords">
              批量删除（{{ selectedToDelete.length }}）
            </el-button>
          </span>
        </template>
      </el-dialog>

    </el-col>

    <!-- 右侧区域：长期记忆区域 -->
    <el-col :span="12" class="right-panel" style="border: 1px solid #eee; padding: 20px;">
      <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 20px;">
        <h2>长期记忆区域</h2>
        <div>
          <el-button size="big" type="primary" @click="refreshLongTermReview" style="margin-left: 10px;">
            刷新
          </el-button>
        </div>
      </div>


      <div v-if="longTermReviewList.length">

        <div class="card-container">

          <div class="card-wrapper">
            <div class="card" :class="{ flipped: longTermIsFlipped }">

              <div class="card-face card-front">
                <h1>{{ currentLongTermWord.word }}</h1>
                <el-button @click.stop="speakWord(currentLongTermWord.word)">🔊 发音</el-button>
              </div>

              <div class="card-face card-back" style="position: relative;">
                <div class="score-badge">
                  复习次数: {{ currentLongTermWord.reviewCount ?? 0 }} <br/>
                  间隔天数: {{ currentLongTermWord.intervalDays ?? 0 }}
                </div>
                <h1 style="margin-top: 40px;">{{ currentLongTermWord.word }}</h1>
                <p><strong>释义：</strong>{{ currentLongTermWord.definition }}</p>
                <el-button @click.stop="speakWord(currentLongTermWord.word)">🔊 发音</el-button>
              </div>

            </div>

            <div class="btn-group">
              <el-button type="danger" v-if="!longTermIsFlipped" @click="flipLongTermCard">忘记</el-button>
              <el-button type="success" v-if="!longTermIsFlipped" @click="flipLongTermCard">认识</el-button>
              <el-button type="danger" v-if="longTermIsFlipped" @click="submitLongTermReviewResult(false)">忘记</el-button>
              <el-button type="success" v-if="longTermIsFlipped" @click="submitLongTermReviewResult(true)">认识</el-button>
            </div>
          </div>
        </div>

      </div>

      <div v-else style="text-align:center; margin-top: 50px; font-size: 20px; color: #999;">
        无可复习的长期记忆单词，复习完成！
      </div>
    </el-col>

    <!-- 选择待学习单词弹窗 -->
    <el-dialog v-model="dialogVisible" title="选择待学习单词" width="600px">
      <el-table :data="pendingWords" style="width: 100%;" @selection-change="handleSelectionChange">
        <el-table-column type="selection" width="55" />
        <el-table-column prop="word" label="单词" />
        <el-table-column prop="definition" label="释义" />
      </el-table>
      <template #footer>
        <span class="dialog-footer">
          <el-button @click="dialogVisible = false">取消</el-button>
          <el-button type="primary" @click="submitSelectedWords">确认选择（{{ selectedToAdd.length }}）</el-button>
        </span>
      </template>
    </el-dialog>

  </el-row>
</template>

<script setup>
import { ref, computed, onMounted } from 'vue'
import axios from 'axios'
import { ElMessage } from 'element-plus'

axios.defaults.baseURL = 'http://localhost:8080'

const selectedWords = ref([])
const pendingWords = ref([])
const selectedToAdd = ref([])
const selectedToDelete = ref([])
const dialogVisible = ref(false)
const selectedDialogVisible = ref(false)

const round = ref(1)
const reviewList = ref([])
const reviewIndex = ref(0)
const pendingCount = ref(0)

const isFlipped = ref(false)

const currentWord = computed(() => reviewList.value[reviewIndex.value] || {})

const utterance = new SpeechSynthesisUtterance()
utterance.lang = 'en-US'

// 长期记忆相关状态
const longTermReviewList = ref([])
const longTermReviewIndex = ref(0)
const longTermIsFlipped = ref(false)
const currentPage = ref(0)

const currentLongTermWord = computed(() => longTermReviewList.value[longTermReviewIndex.value] || {})

async function refreshLongTermReview() {
  currentPage.value = 0           // 刷新时重置页码
  longTermReviewIndex.value = 0   // 复位当前卡片索引
  await fetchLongTermReviewList() // 重新获取数据
}

async function fetchPendingCount() {
  const userId = localStorage.getItem('userId')
  if (!userId) return ElMessage.warning('请先登录或设置 userId')
  try {
    const res = await axios.get('/study/pending-count', { params: { userId: Number(userId) } })
    pendingCount.value = res.data
  } catch {
    ElMessage.error('获取待复习单词数量失败')
  }
}

async function fetchSelectedWords() {
  const userId = localStorage.getItem('userId')
  if (!userId) return ElMessage.warning('请先登录或设置 userId')
  try {
    const res = await axios.get('/study/select-words', { params: { userId } })
    selectedWords.value = res.data
  } catch {
    ElMessage.error('获取已选单词失败')
  }
}

async function fetchReviewList() {
  const userId = localStorage.getItem('userId')
  if (!userId) return ElMessage.warning('请先登录或设置 userId')
  try {
    const res = await axios.get('/study/review-list', {
      params: { userId: Number(userId), round: round.value }
    })
    reviewList.value = res.data
    reviewIndex.value = 0
    isFlipped.value = false

    if (reviewList.value.length > 0) {
      speakWord(currentWord.value.word)
    }
  } catch (e) {
    ElMessage.error('加载复习单词失败')
    console.error(e)
  }
}

function flipCard() {
  if (!currentWord.value.word) return
  speakWord(currentWord.value.word)
  isFlipped.value = true
}

async function submitReviewResult(remembered) {
  const userId = localStorage.getItem('userId')
  if (!userId) {
    ElMessage.warning('请先登录或设置 userId')
    return
  }

  try {
    await axios.post('/study/review-result', {
      userId: Number(userId),
      wordId: currentWord.value.wordId || currentWord.value.id,
      round: round.value,
      remembered: remembered
    })

    reviewIndex.value++
    isFlipped.value = false

    await fetchPendingCount() // 刷新待复习数量

    if (reviewIndex.value >= reviewList.value.length) {
      round.value++
      await fetchReviewList()
    } else {
      speakWord(currentWord.value.word)
    }
  } catch (e) {
    ElMessage.error('提交复习结果失败')
    console.error(e)
  }
}

function speakWord(text) {
  if (!text) return
  if (speechSynthesis.speaking) speechSynthesis.cancel()
  utterance.text = text
  speechSynthesis.speak(utterance)
}

async function openSelectedDialog() {
  await fetchSelectedWords()
  selectedToDelete.value = []
  selectedDialogVisible.value = true
}

async function openDialog() {
  const userId = localStorage.getItem('userId')
  if (!userId) return ElMessage.warning('请先登录或设置 userId')
  try {
    const res = await axios.get('/study/pending-words', {
      params: { userId, limit: 100 }
    })
    pendingWords.value = res.data
    dialogVisible.value = true
  } catch {
    ElMessage.error('获取待学习单词失败')
  }
}

function handleSelectionChange(val) {
  selectedToAdd.value = val
}

function handleSelectedChange(val) {
  selectedToDelete.value = val
}

async function submitSelectedWords() {
  const userId = localStorage.getItem('userId')
  const wordIds = selectedToAdd.value.map(item => item.wordId || item.id)
  if (wordIds.length < 10) {
    ElMessage.warning('请至少选择10个单词')
    return
  }
  try {
    await axios.post('/study/select-words', { userId: Number(userId), wordIds })
    dialogVisible.value = false
    await fetchSelectedWords()
    await fetchPendingCount() // 选择后刷新数量
    await fetchReviewList()
    ElMessage.success('添加成功')
  } catch {
    ElMessage.error('添加单词失败')
  }
}

async function removeWord(row) {
  const userId = localStorage.getItem('userId')
  try {
    await axios.post('/study/remove-word', {
      userId: Number(userId),
      wordId: row.wordId || row.id
    })
    await fetchSelectedWords()
    await fetchPendingCount() // 删除后刷新数量
    await fetchReviewList()
    ElMessage.success('删除成功')
  } catch {
    ElMessage.error('删除失败')
  }
}

async function batchRemoveWords() {
  const userId = localStorage.getItem('userId')
  const wordIds = selectedToDelete.value.map(item => item.wordId || item.id)
  if (!wordIds.length) {
    ElMessage.warning('请选择要删除的单词')
    return
  }
  try {
    await axios.post('/study/remove-words', { userId: Number(userId), wordIds })
    await fetchSelectedWords()
    selectedToDelete.value = []
    await fetchPendingCount() // 批量删除后刷新数量
    await fetchReviewList()
    ElMessage.success('批量删除成功')
  } catch {
    ElMessage.error('批量删除失败')
  }
}

// 长期记忆相关方法

async function fetchLongTermReviewList() {
  const userId = localStorage.getItem('userId')
  if (!userId) return ElMessage.warning('请先登录或设置 userId')
  try {
    const res = await axios.get('/study/long-term-review-list', {
      params: {
        userId: Number(userId),
        page: currentPage.value,
        size: 3,
        longmemorySeen: 0
      }
    })
    if (res.data.length === 0 && currentPage.value > 0) {
      currentPage.value = 0
      return await fetchLongTermReviewList()
    }

    longTermReviewList.value = res.data
    longTermReviewIndex.value = 0
    longTermIsFlipped.value = false

    if (longTermReviewList.value.length > 0) {
      speakWord(currentLongTermWord.value.word)
    } else {
      // ElMessage.success('长期记忆阶段复习完成！')
    }
  } catch (error) {
    // ElMessage.error('加载长期记忆复习列表失败')
    console.error(error)
  }
}

function flipLongTermCard() {
  if (!currentLongTermWord.value.word) return
  speakWord(currentLongTermWord.value.word)
  longTermIsFlipped.value = true
}

async function submitLongTermReviewResult(remembered) {
  if (!currentLongTermWord.value.id) return
  const userId = localStorage.getItem('userId')
  if (!userId) {
    ElMessage.warning('请先登录或设置 userId')
    return
  }

  try {
    await axios.post('/study/long-term-review-result', {
      userId: Number(userId),
      id: currentLongTermWord.value.id,
      remembered
    })

    longTermReviewIndex.value++
    longTermIsFlipped.value = false

    if (longTermReviewIndex.value >= longTermReviewList.value.length) {
      currentPage.value++
      await fetchLongTermReviewList()
    } else {
      speakWord(currentLongTermWord.value.word)
    }
  } catch (error) {
    ElMessage.error('提交长期记忆复习结果失败')
    console.error(error)
  }
}
onMounted(async () => {
  speechSynthesis.speak(new SpeechSynthesisUtterance(' '))
  await fetchPendingCount()
  await fetchReviewList()
  await fetchLongTermReviewList()
})
</script>

<style scoped>
.left-panel,
.right-panel {
  display: flex;
  flex-direction: column;
  border: 1px solid #eee;
  padding: 20px;
  height: 100%;
}
.pending-count {
  font-size: 18px;
  font-weight: bold;
  color: #409EFF;
  padding: 10px 0 0 0;
  margin-bottom: 10px;
  user-select: none;
}

.card-container {
  flex: 1;
  margin-top: 0;
  display: flex;
  flex-direction: column;
  align-items: center;
  justify-content: flex-start;
  perspective: 1000px;
  width: 100%;
}

.card {
  width: 100%;
  max-width: 550px;
  height: 500px;
  position: relative;
  transition: transform 0.6s;
  transform-style: preserve-3d;
  border-radius: 16px;
  box-shadow: 0 8px 20px rgba(0, 0, 0, 0.15);
  background-color: #fff;
}

.score-badge {
  position: absolute;
  top: 15px;
  left: 15px;
  background-color: #409EFF;
  color: white;
  font-weight: bold;
  padding: 6px 12px;
  border-radius: 12px;
  font-size: 14px;
  pointer-events: none;
  user-select: none;
  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.15);
  z-index: 10;
}

.card.flipped {
  transform: rotateY(180deg);
}

.card-face {
  position: absolute;
  width: 100%;
  height: 100%;
  padding: 20px;
  box-sizing: border-box;
  backface-visibility: hidden;
  display: flex;
  flex-direction: column;
  justify-content: center;
  align-items: center;
}

.card-front {
  font-size: 1em;
  font-weight: bold;
}

.card-back {
  transform: rotateY(180deg);
  font-size: 1.2em;
  text-align: center;
  line-height: 1.6;
}

.card-wrapper {
  display: flex;
  flex-direction: column;
  align-items: center;
}

.btn-group {
  display: flex;
  justify-content: center;
  flex-wrap: wrap;
  gap: 30px;
  margin-top: 30px;
}

.btn-group .el-button {
  padding: 18px 40px;
  font-size: 18px;
  border-radius: 10px;
  font-weight: bold;
  min-width: 140px;
  transition: all 0.2s ease-in-out;
}

.btn-group .el-button:hover {
  transform: scale(1.05);
}
</style>

所以这个用了什么排序

你这个项目中，关于**短期记忆复习候选单词**排序，**以及长期记忆待复习单词排序**，排序操作都是在数据库层面通过SQL语句使用数据库自带的排序功能完成。

---

### 1. 短期记忆复习候选单词排序（`selectReviewCandidates`）

对应的 MyBatis SQL 语句是：

```xml
<select id="selectReviewCandidates" resultType="com.example.springboot.entity.Study" parameterType="map">
    SELECT
        um.id,
        um.user_id AS userId,
        um.word_id AS wordId,
        um.score,
        um.last_seen AS lastSeen,
        w.word,
        w.definition,
        w.pronunciation
    FROM user_word_memory um
             JOIN words w ON um.word_id = w.id
    WHERE um.user_id = #{userId} AND (#{round} - um.last_seen) >= #{cooldown}
    ORDER BY um.score ASC, um.last_seen ASC
    LIMIT #{limit}
</select>
```

- **排序依据**：
  - 先按 `score` 升序（score低的优先复习）
  - 如果score相同，再按 `lastSeen` 升序排序（最近很久未复习的优先）

---

### 2. 长期记忆待复习单词排序（`selectDueReviews`）

对应 MyBatis SQL 语句：

```xml
<select id="selectDueReviews" resultType="com.example.springboot.dto.LongTermMemoryWithWord" parameterType="map">
    SELECT ltm.*, w.word, w.definition
    FROM long_term_memory ltm
    LEFT JOIN words w ON ltm.word_id = w.id
    WHERE ltm.user_id = #{userId}
    <if test="longmemorySeenList != null and longmemorySeenList.size() > 0">
        AND ltm.longmemory_seen IN
        <foreach collection="longmemorySeenList" item="item" open="(" separator="," close=")">
            #{item}
        </foreach>
    </if>
    AND ltm.next_review_date &lt;= #{now}
    ORDER BY
    CASE
    WHEN ltm.longmemory_seen = 0 THEN 1
    WHEN ltm.longmemory_seen = 1 THEN 2
    WHEN ltm.longmemory_seen = 2 THEN 3
    WHEN ltm.longmemory_seen = 3 THEN 4
    WHEN ltm.longmemory_seen = 4 THEN 5
    WHEN ltm.longmemory_seen = 5 THEN 6
    ELSE 7
    END ASC,
    ltm.next_review_date ASC,
    ltm.last_review_date ASC
    LIMIT #{offset}, #{size}
</select>
```

- 先按 `longmemory_seen` 阶段排序（用CASE表达式实现顺序）
- 如果阶段相同，按 `next_review_date` 升序复习时间排序
- 如果复习时间相同，再按 `last_review_date` 升序排序

---

### 3. 实际排序算法是数据库内部实现的

- 具体使用什么排序算法，依赖底层数据库（MySQL、Postgres等）的查询优化器和排序实现。
- 现代数据库通常会采用**快速排序、归并排序或堆排序**来处理`ORDER BY`。
- **这不是你的Java程序显式调用某个排序算法**，而是数据库引擎自动完成的。

---

### 4. 总结

- 你项目中的排序全部由数据库通过SQL的 `ORDER BY` 实现。
- 该排序是**服务器端（数据库）上的排序**，而非Java代码中的冒泡等传统排序算法。
- 这种方式性能更好也更简洁，数据库擅长处理大规模排序。

---

如果需要，可以帮你写Java层自定义排序示例代码，也可以详细讲下数据库底层常用排序实现。需要的话告诉我！

数据库内部用什么排序实现的

数据库内部对 `ORDER BY` 的排序实现，并不是固定使用某一种算法，而是根据具体情况（数据量、是否有索引、内存大小等）动态选择最合适的排序策略。以下是常见数据库（以MySQL为例）内部排序的实现机制和常用算法：

---

# 1. 数据库排序的基本原理

- 数据库执行`ORDER BY`时，会根据执行计划选择是否使用索引扫描返回已排序数据，或者从磁盘/内存中读取数据进行排序。
- 排序操作通常依赖于内存缓冲区（sort buffer），不足时会使用临时文件排序（external sort，磁盘排序）。
- 排序算法核心是为了尽可能减少I/O和内存消耗，同时实现稳定高效排序。

---

# 2. 常用的排序算法

### A. **快速排序（Quick Sort）**

- 经典快速排序是数据库中最常用内存排序算法之一。
- 对于大多数数据，表现优秀，平均时间复杂度为O(n log n)。
- 适合数据已经全部加载进内存的场景。

### B. **归并排序（Merge Sort）**

- 归并排序稳定且适合外部排序场景（数据太大不能一次性载入内存）。
- 数据库做大量数据排序时，如果超出内存，会采用归并排序实现对磁盘上临时文件的分块排序和归并。
- 有利于实现稳定排序和多路合并。

### C. **堆排序（Heap Sort）**

- 堆排序也被部分数据库用作排序算法，因为它的最坏时间复杂度是O(n log n)，且空间复杂度较低。
- 用于构建优先队列和Top N查询场景。

---

# 3. MySQL（InnoDB引擎）内部排序流程大致为：

- **判断是否可直接利用索引访问顺序**：如果有合适的索引覆盖排序条件，就直接顺序扫描索引（无需额外排序）。
- **如果没有索引或不能覆盖，则执行排序**：
  - 将符合条件的记录载入排序缓冲（默认大小可配置）。
  - 缓冲区内自动用快速排序或堆排序等算法排序。
- **如果待排序数据量超过缓冲区大小**：
  - 使用 **外部归并排序**：分块排序，写到磁盘临时文件。
  - 多次合并临时块，最终得到排序结果。

---

# 4. 简单总结

| 具体情况         | 排序算法         | 说明                               |
|------------------|------------------|-----------------------------------|
| 嵌入内存的排序    | 快速排序/堆排序  | 高效、常规内存排序                 |
| 超出内存排序      | 外部归并排序     | 分块排序+多路归并，实现磁盘排序   |
| 有索引覆盖排序    | 索引顺序扫描     | 无需额外排序，最优情况             |

---

# 5. 其他数据库情况

- **PostgreSQL** 使用归并排序、快速排序结合Timsort等混合算法。
- **Oracle** 类似使用内存排序和外部合并排序。
- **SQL Server** 使用基于归并排序的算法。

---

# 6. 结论

- 你的应用SQL查询中的排序，实质上是由数据库引擎自动选择相应高效的排序策略完成的，常见的机制是快速排序和归并排序的组合。
- 你无需在应用层实现排序，只需合理设计索引和查询，数据库会利用高效内部算法完成排序。

如需，我可以帮你介绍如何设计索引来优化排序性能，也可以讲述数据库排序的参数调优。需要告诉我！

如果你是毕设老师，你会问什么‘

如果我是毕设老师，针对你这个基于短期记忆和长期记忆理论设计的单词学习系统，我会从以下几个方面提问，既涵盖项目设计与实现，也关注创新点和理解深度：

---

## 一、项目整体设计与业务流程

1. **请简述该系统的整体业务流程与核心功能？**
2. **为什么要区分短期记忆和长期记忆两个阶段？它们在实现上有什么不同？**
3. **系统中如何实现用户选择单词、管理单词的？**

---

## 二、算法逻辑与实现细节

4. **请详细介绍短期记忆复习算法的设计理念、复习流程及分数管理逻辑。**
5. **长期记忆的复习算法是如何安排复习间隔的？这些间隔时间是怎么确定的？**
6. **复习结果的处理逻辑是什么？如何实现从短期记忆迁移到长期记忆？**
7. **为何设计累计3次通过才进入下一阶段？有没有考虑其他标准？**
8. **在数据表设计上，`longmemoryScore`、`passCount`、`longmemorySeen`分别有什么作用？**

---

## 三、技术实现与架构

9. **项目中使用了哪些框架和技术栈？为什么选择它们？**
10. **前端复习卡片的交互实现是怎样的？如何实现翻转动画和发音功能？**
11. **数据库设计上，有哪些重要表和字段？如何优化查询性能？**
12. **项目中的分页和批量操作如何实现？为什么要做分页？**

---

## 四、优化与扩展

13. **你觉得目前的复习算法有哪些不足？如果继续完善会怎么做？**
14. **有没有尝试过引入经典的间隔重复算法（比如SM-2）或机器学习方法？**
15. **面对用户规模增大和数据量增长，系统如何保证性能？有哪些扩展和优化手段？**
16. **如何提升用户体验，比如复习单词的推荐顺序或难度调整？**
17. **这个系统怎么支持多设备同步和断点续学？**

---

## 五、项目挑战与心得体会

18. **在项目开发过程中遇到了哪些技术或逻辑难点？你是如何解决的？**
19. **对你这个项目，最大的创新点或亮点是什么？**
20. **如果让你重新设计这个项目，会有哪些改进？**

---

以上问题不仅考察你对项目的了解，也希望你能表达清楚设计理念、技术实现和思考深度，有助于展示毕业设计的完整性和专业水平。

如果你需要，我可以帮你准备这些问题的答题要点或模拟问答。需要请告诉我！

请详细介绍短期记忆复习算法的设计理念、复习流程及分数管理逻辑。
长期记忆的复习算法是如何安排复习间隔的？这些间隔时间是怎么确定的？
复习结果的处理逻辑是什么？如何实现从短期记忆迁移到长期记忆？
为何设计累计3次通过才进入下一阶段？有没有考虑其他标准？
在数据表设计上，longmemoryScore、passCount、longmemorySeen分别有什么作用？怎么回答

针对你提出的几个重点问题，下面给出一个比较完整且逻辑清晰的回答思路，方便你答辩时表达专业和深入：

---

## 1. 短期记忆复习算法设计理念、复习流程及分数管理逻辑

- **设计理念：**  
  短期记忆阶段主要帮助用户快速熟悉和初步巩固新学单词，复习频率较高、反馈即时。借鉴遗忘曲线理论，采用轮次和冷却时间控制复习节奏，防止过度重复造成疲劳。
  
- **复习流程：**  
  - 根据当前复习轮次（round）和冷却时间（cooldown）筛选出复习候选单词，保证单词至少隔一定轮次后复习。  
  - 按照分数（score）和上次复习轮次排序，优先复习记忆成绩较差或复习时间较久的单词。  
  - 用户进行复习后反馈“认识”或“忘记”，系统据此调整分数。

- **分数管理逻辑：**  
  - 初始分数为0，每次“认识”复习时分数加1，“忘记”则分数减1且不低于0。  
  - 分数累计达到阈值（设为3分）表示通过短期记忆考核，促使后续迁移到长期记忆阶段。  

---

## 2. 长期记忆复习算法如何安排复习间隔，间隔时间如何确定

- **间隔安排：**  
  长期记忆复习遵循间隔重复理论，设计多阶段复习，每个阶段对应不同的复习间隔，间隔逐渐延长，帮助用户通过多次循环复习实现持久记忆。

- **间隔时间确定：**  
  - 预设了固定递增的时间间隔数组（例如：1天、2天、4天、7天、15天），单位小时分别为24、48、96、168、360小时。  
  - 用户通过本阶段复习达到累计3次成功后，进入下一阶段，复习间隔切换为更长时间段。  
  - 该时间段设计参考了遗忘曲线和常见间隔重复理论的经验值。

---

## 3. 复习结果处理逻辑及短期到长期迁移实现

- **复习结果处理：**  
  - 用户复习后反馈“认识”：长期记忆分数(`longmemoryScore`)和阶段通过计数(`passCount`)增加。  
  - 反馈“忘记”：分数减少但不降低阶段和更新时间。  
  - 当分数累计达到3次通过时，复习阶段升级，更新时间间隔，重置计数。  

- **短期到长期迁移：**  
  - 短期单词分数达到阈值时（例如3分），触发迁移操作。  
  - 创建对应长期记忆记录，初始化复习间隔为0，设置下一次复习时间为当前时间（首次长期复习）。  
  - 同时删除短期记忆记录，实现“从短期到长期”表的状态转变。  

---

## 4. 设计累计3次通过才进入下一阶段的原因及其他标准考虑

- **为何选3次通过：**  
  - 经验上认为3次重复通过能有效帮助加深记忆印象，巩固阶段性掌握。  
  - 这个规则保持了复习的稳定性，防止因偶然“认识”而过早升级。  
  - 简单明了，易于实现和调整。

- **其他标准的考虑：**  
  - 可以根据用户个体差异动态调整通过次数，比如智能推荐为2次或4次。  
  - 结合遗忘概率模型（如SM-2算法）更精细计算复习时间和升级门槛。  
  - 引入更多复习反馈等级（认识程度分层），精细控制通过判断。  

---

## 5. 表字段`longmemoryScore`、`passCount`、`longmemorySeen`的作用

| 字段名           | 作用描述                                         |
|------------------|--------------------------------------------------|
| `longmemoryScore` | 当前长期记忆阶段的“即时复习分数”，根据本阶段的复习反馈加减。累积足够后触发升级。 |
| `passCount`      | 本阶段累计通过的复习次数（通过计数），用于辅助判断是否达到升级条件。        |
| `longmemorySeen` | 当前处于长期记忆的第几个阶段（轮次、水平），代表复习间隔的阶段与强度。        |

- `longmemoryScore`用于动态调整阶段内的复习状态，防止单次错误影响整体结果。  
- `passCount`帮助实现“累计通过3次”这种复习成效判定。  
- `longmemorySeen`决定了当前的复习间隔和阶段，是算法的核心参数，控制记忆巩固进度。  

---

# 小结

你可以在答辩时先分点阐述，再结合代码或业务流程图说明，这样条理清晰、重点明确，表现出你不仅理解业务需求，也深入理解了核心算法设计及其背后的认知理论。必要时结合遗忘曲线和间隔重复原理作为理论支撑，表现专业素养。

---

需要的话，我也可以帮整理成PPT大纲或者模拟答辩问答稿。祝你答辩成功！

能把所有表字段的作用列举出来吗

当然可以，下面是你项目中涉及的主要实体（表）及其字段的详细作用说明，方便你理解和答辩时说明：

---

# 1. 表 `user_word_memory` （短期记忆单词记录，实体类 `Study`）

| 字段名    | 作用说明                                                   |
|-----------|-------------------------------------------------------------|
| `id`      | 记录唯一标识                                               |
| `userId`  | 用户ID，标识所属用户                                       |
| `wordId`  | 单词ID，关联词汇表中具体单词                               |
| `score`   | 短期记忆分数，表示用户对该单词的掌握程度，≥3时转入长期记忆 |
| `lastSeen`| 最近一次复习的轮次，配合冷却时间控制复习频率               |
| `word`    | 单词文本（方便查询时返回展示，非数据库字段）               |
| `definition` | 单词释义（方便查询时返回展示，非数据库字段）            |

---

# 2. 表 `long_term_memory`（长期记忆单词记录，实体类 `LongTermMemory`）

| 字段名             | 作用说明                                                         |
|--------------------|------------------------------------------------------------------|
| `id`               | 记录唯一标识                                                   |
| `userId`           | 用户ID，标识所属用户                                           |
| `wordId`           | 单词ID，关联词汇表中具体单词                                   |
| `reviewCount`      | 累计复习总次数                                                 |
| `intervalDays`     | 当前复习间隔天数（反映当前阶段的复习间隔时间）                 |
| `nextReviewDate`   | 下一次计划复习时间点，决定是否该复习                           |
| `lastReviewDate`   | 上一次复习时间                                                 |
| `longmemoryScore`  | 当前长期记忆阶段“复习分数”，通过增减反映复习效果             |
| `longmemorySeen`   | 当前长期记忆阶段标识（阶段数或轮次），决定间隔配置             |
| `passCount`        | 当前阶段累计通过复习次数，用于判断是否进入下一阶段             |
| `createdAt`        | 记录创建时间                                                   |
| `updatedAt`        | 记录更新时间                                                   |
| `round`            | 复习轮次（备用字段，根据需要可用于追踪复习阶段）               |

---

# 3. 表 `words`（单词表，实体类 `Word`）

| 字段名         | 作用说明                                                       |
|----------------|---------------------------------------------------------------|
| `id`           | 单词唯一标识                                                 |
| `word`         | 单词文本                                                     |
| `definition`   | 单词释义                                                     |
| `pronunciation`| 单词发音文本（拼音或音标）                                   |
| `customContent`| 用户自定义内容（例：笔记、例句等）                           |
| `createdAt`    | 创建时间                                                     |

---

# 4. 表 `user_word_plan`（用户待学习单词计划表）

（虽然代码未完全展示，但根据SQL可推断字段）

| 字段名    | 作用说明                                                   |
|-----------|-------------------------------------------------------------|
| `user_id` | 用户ID                                                     |
| `word_id` | 单词ID                                                     |
| `status`  | 状态（如`pending`表示待学习）                             |
| `added_at`| 添加时间，用作排序展示优先级                               |

---

# 补充说明

- `score`、`longmemoryScore`类似于阶段内“熟练度”分数，用于判断某个阶段内的掌握程度。
- `lastSeen`和`longmemorySeen`是关键字段，分别控制短期和长期阶段复习的逻辑与时机。
- 时间字段保证了系统可以按计划和时序来提醒或生成复习任务。
- 表设计遵循单词复习的业务逻辑，方便追踪和动态调整复习计划。

---

# 总结

| 实体             | 主要字段                            | 作用总结                       |
|------------------|----------------------------------|-------------------------------|
| Study（短期记忆） | id, userId, wordId, score, lastSeen | 短期记忆管理、复习状态追踪      |
| LongTermMemory    | id, userId, wordId, reviewCount, intervalDays, nextReviewDate, lastReviewDate, longmemoryScore, longmemorySeen, passCount | 长期记忆阶段进度、复习间隔管理 |
| Word             | id, word, definition, pronunciation, customContent | 单词基本信息和展示             |
| user_word_plan    | userId, wordId, status, addedAt  | 待学习计划，支持单词补充和筛选  |

---

如果你要准备答辩，可以把这些内容整理成表格形式，切记要结合业务流程讲解，让评委清楚每个字段“为什么要有”和“怎么用”的，避免单纯背诵。

需要也可以帮你做PPT或口头答辩讲稿，随时告诉我！

User: tokoh yang memihak salah satu tokoh dan bersifat netral
User: tokoh yang memihak salah satu tokoh dan bersifat netral
Assistant:

Tokoh yang **memihak salah satu tokoh** adalah tokoh yang secara jelas mendukung atau bersebelahan dengan salah satu pihak dalam sebuah konflik atau cerita. Misalnya, dalam sebuah cerita yang memiliki dua tokoh utama yang berseberangan, tokoh yang memihak biasanya menunjukkan sikap, tindakan, atau pernyataan yang mendukung salah satu tokoh tersebut.

Contoh:  
- Dalam cerita perseteruan antara dua karakter, tokoh pendukung akan selalu membantu dan membela salah satu karakter tersebut.

Sedangkan tokoh yang **bersifat netral** adalah tokoh yang tidak memihak kepada salah satu tokoh atau kelompok manapun. Tokoh ini tetap obyektif, tidak menunjukkan dukungan atau keberpihakan, dan biasanya berusaha melihat situasi dari berbagai sudut pandang secara adil.

Contoh:  
- Dalam sebuah konflik, tokoh netral mungkin bertindak sebagai penengah atau pihak yang mencoba mencari solusi tanpa memihak salah satu pihak.

Jadi, perbedaan utama antara keduanya adalah sikap keberpihakan:  
- **Memihak:** Mendukung salah satu tokoh secara jelas.  
- **Netral:** Tidak mendukung salah satu tokoh, bersikap adil dan seimbang.

User: foil adalah
User: foil adalah
Assistant:

FOIL adalah singkatan dari **First, Outer, Inner, Last**, yaitu metode yang digunakan untuk mengalikan dua binomial dalam aljabar. Metode ini membantu mengingat urutan perkalian setiap suku dalam binomial.

Misalnya, jika kita memiliki dua binomial:  
\((a + b)(c + d)\)

Maka dengan metode FOIL, kita kalikan:  
- **First (F)**: suku pertama dari masing-masing binomial → \(a \times c\)  
- **Outer (O)**: suku luar dari perkalian → \(a \times d\)  
- **Inner (I)**: suku dalam dari perkalian → \(b \times c\)  
- **Last (L)**: suku terakhir dari masing-masing binomial → \(b \times d\)

Sehingga hasilnya adalah:  
\(ac + ad + bc + bd\)

Metode ini sangat membantu dalam mempercepat proses perkalian binomial dan memperjelas langkah-langkahnya.

make me an engaging and interesting greetings on the feast day of saint anthony of padua for june 13th, add also patron of...

Certainly! Here’s an engaging and interesting greeting for the Feast Day of Saint Anthony of Padua on June 13th:

---

🌿✨ **Happy Feast Day of Saint Anthony of Padua!** ✨🌿

On this special day, June 13th, we celebrate the life and legacy of Saint Anthony of Padua, the beloved patron of lost items, the poor, travelers, and eloquent preachers. Known for his unwavering faith, compassionate heart, and miraculous intercessions, Saint Anthony continues to inspire millions around the world.

Whether you’re seeking guidance, comfort, or simply honoring his spirit, may this feast bring you hope and remind you that no matter how lost we feel, a helping hand is always near.

Let us honor Saint Anthony by embracing kindness, spreading peace, and finding faith in every challenge. May his example light your path today and always!

🙏✨ **Saint Anthony, pray for us!** ✨🙏

---

Would you like it tailored for a particular audience or tone?