import { watch } from "vue";
import { useMarkStore } from "@/store";
import useQuestion from "./useQuestion";

export default function useTaskWatch() {
  const markStore = useMarkStore();
  const { isArbitrated } = useQuestion();

  watch(
    () => markStore.currentTask,
    () => {
      // 初始化 task.markResult ，始终保证 task 下有 markResult
      // 1. 评卷时，如果没有 markResult ，则初始化一个 markResult 给它
      // 1. 回评时，先清空它的 markResult ，然后初始化一个 markResult 给它
      if (!markStore.currentTask) return;

      // 主观题检查时，记录修改的试题信息
      const currentTaskModifyQuestion = {};
      markStore.currentTask.questionList.forEach((q) => {
        const qno = `${q.mainNumber}_${q.subNumber}`;
        currentTaskModifyQuestion[qno] = false;
      });
      markStore.currentTaskModifyQuestion = currentTaskModifyQuestion;

      const task = markStore.currentTask;
      if (task.previous && task.markResult) {
        task.markResult = undefined;
      }
      if (task.markResult) return;
      // 管理后台可能不设置 questionList, 而且它不用 markResult
      if (!task.questionList) {
        task.questionList = [];
        // return;
      }
      // 初始化 __index
      task.questionList.forEach((q, i) => {
        q.__index = i;
        // 回评的时候，如果是自己标记问题卷的题目，则转成非自己标记问题卷的题目
        // 这样一来，就不能编辑问题卷，但是依旧可以编辑新设置未提交的问题卷
        if (markStore.historyOpen && q.problem && q.selfMark) {
          q.selfMark = false;
        }
      });

      task.__markStartTime = Date.now();
      const statusValue = markStore.setting.statusValue;
      const { examId, studentId, paperNumber } = task;

      const selfQuestions = task.questionList.filter(
        (q) => q.selfMark && !isArbitrated(q)
      );
      task.markResult = {
        examId,
        paperNumber,
        studentId,
        spent: 0,
        statusValue,
        questionList: task.questionList,
        markedQuestionId: "",
        markerTrackList: selfQuestions
          .map((q) => {
            const trackList =
              q.headerTrackList && q.headerTrackList.length
                ? q.headerTrackList
                : q.markerTrackList;
            return trackList || [];
          })
          .flat(),
        markerTagList: selfQuestions
          .map((q) => {
            const tagList =
              q.headerTagList && q.headerTagList.length
                ? q.headerTagList
                : q.markerTagList;
            return tagList || [];
          })
          .flat(),
        scoreList: task.questionList.map((q) =>
          q.selfMark && !isArbitrated(q) ? q.markerScore : null
        ),
        markerScore: 0, // 后期通过 scoreList 自动更新
      };
      task.markResult.markerTrackList.forEach((t) => {
        if (t.unanswered) {
          t.score = -0;
        }
      });
    }
  );

  // 唯一根据 scoreList 自动更新 markerScore
  watch(
    () => markStore.currentTask?.markResult.scoreList,
    () => {
      if (!markStore.currentTask) return;
      const scoreList = markStore.currentTask.markResult.scoreList.filter(
        (v) => v !== null
      );
      const result =
        scoreList.length === 0
          ? null
          : scoreList.reduce((acc, v) => (acc += Math.round(v * 1000)), 0) /
            1000;
      markStore.currentTask.markResult.markerScore = result;
    },
    { deep: true }
  );
}