ieplus-app/src/pagesStudy/pages/exam-start/exam-start.vue

<template>
  <ie-page :fix-height="true" :safe-area-inset-bottom="false">
    <block v-if="isReady">
      <exam-navbar :total-exam-time="totalExamTime" @left-click="handleLeftClick" @right-click="handleRightClick" />
      <exam-subtitle />
      <exam-swiper @submit="beforeSubmit" />
      <exam-toolbar ref="examToolbarRef" @submit="beforeSubmit" />
    </block>
  </ie-page>
  <fast-guide v-model:show="guideShow" :list="guideList" v-model:index="guideIndex" @close="handleGuideClose"
    @getQuery="getQuery"></fast-guide>
  <question-swiper-tip :visible="showSwiperTip" @next="handleSwiperTipNext" />
  <exam-mode ref="examModeRef" />
</template>

<script lang="ts" setup>
import ExamNavbar from './components/exam-navbar.vue';
import ExamSubtitle from './components/exam-subtitle.vue';
import ExamSwiper from './components/exam-swiper.vue';
import ExamToolbar from './components/exam-toolbar.vue';
import ExamMode from './components/exam-mode.vue';

import QuestionSwiperTip from './components/question-swiper-tip.vue';
import { useTransferPage } from '@/hooks/useTransferPage';
import { useUserStore } from '@/store/userStore';
import { EnumPaperType, EnumQuestionType } from '@/common/enum';
import { getOpenExaminee, getPaper, commitExamineePaper, beginExaminee, getExamineeResult } from '@/api/modules/study';
import { useExam } from '@/composables/useExam';
import { Study, Transfer } from '@/types';
import {
  EXAM_AUTO_SUBMIT,
  EXAM_PAGE_OPTIONS,
  EXAM_DATA
} from '@/types/injectionSymbols';
import { useAppStore } from '@/store/appStore';
import { useEnv } from '@/hooks/useEnv';
import { useReport } from '@/hooks/useReport';

const { report, events } = useReport();
const appStore = useAppStore();
const { platform } = useEnv();
const userStore = useUserStore();
// import { Examinee, ExamPaper, ExamPaperSubmit } from '@/types/study';
const { prevData, transferBack, transferTo } = useTransferPage<Transfer.ExamAnalysisPageOptions, {}>();
const examData = useExam();
const { setQuestionList, questionList, flatQuestionList, setSubQuestionIndex,
  notDoneCount, isAllDone,
  practiceDuration, startTiming, stopTiming, submit, changeIndex, setDuration } = examData;

//
const showSwiperTip = ref(false);
const guideShow = ref(false);
const guideList = ref([
  {
    ref: 'examToolbarRef',
    target: '#question-calendar-btn',
    position: 'top',
    msg: '[答题卡]\n查看答题卡，掌握考试进度'
  },
  {
    ref: 'examToolbarRef',
    target: '#question-favorite-btn',
    position: 'top',
    msg: '[题目收藏]\n收藏的题目可以在收藏夹查看'
  },
  {
    ref: 'examToolbarRef',
    target: '#question-mark-btn',
    position: 'top',
    msg: '[题目标记]\n标记的题目可以在答题卡中快速找到'
  },
  {
    ref: 'examToolbarRef',
    target: '#question-correct-btn',
    position: 'top',
    msg: '[试题纠错]\n点击试题纠错，帮助我们改进题目'
  }
]);
const guideIndex = ref(0);
const isReady = ref(false);
// 考试规定时间
const totalExamTime = ref<number>(0);
// 自动提交只提醒1次
const hasShowSubmitConfirm = ref(false);
const examineeId = ref<number | undefined>(undefined);
const paperData = ref<Study.ExamPaper>({} as Study.ExamPaper);
// 是否确认退出
const confirmQuit = ref(false);
const confirmShowing = ref(false);
/**
 * 自动提交
 */
const autoSubmit = () => {
  if (hasShowSubmitConfirm.value) {
    return;
  }
  hasShowSubmitConfirm.value = true;
  beforeSubmit();
}

provide(EXAM_PAGE_OPTIONS, prevData.value);
provide(EXAM_DATA, examData);
provide(EXAM_AUTO_SUBMIT, autoSubmit);

const isPracticeExam = computed(() => {
  return prevData.value.paperType === EnumPaperType.PRACTICE || prevData.value.paperType === EnumPaperType.COURSE;
});

const isSimulationExam = computed(() => {
  // prevData.value
  return prevData.value.paperType === EnumPaperType.SIMULATED;
});
const isTestExam = computed(() => {
  return prevData.value.paperType === EnumPaperType.TEST;
});

const isReadOnly = computed(() => {
  return prevData.value.readonly || false;
});
const handleLeftClick = () => {
  if (!isReady.value || isReadOnly.value) {
    confirmQuit.value = true;
    transferBack();
    return;
  }
  beforeQuit();
};
const examModeRef = ref();
const handleRightClick = () => {
  examModeRef.value.open();
}

const instance = getCurrentInstance();
const getQuery = (fn: () => void) => {
  fn.call(instance?.proxy)
}

const beforeQuit = () => {
  const { paperType } = prevData.value;
  if (!isReady.value || isReadOnly.value) {
    return;
  }
  stopTime();
  const msg = paperType === EnumPaperType.PRACTICE ? '当前练习未完成，确认退出？' : '当前考试未完成，确认退出？';
  confirmShowing.value = true;
  uni.$ie.showModal({
    title: '提示',
    content: msg,
  }).then(confirm => {
    if (confirm) {
      handleSubmit(true);
    } else {
      confirmQuit.value = false;
      confirmShowing.value = false;
      startTime();
    }
  });
};


const startTime = () => {
  startTiming();
}

const stopTime = () => {
  stopTiming();
}


const beforeSubmit = async () => {
  const text = notDoneCount.value > 0 ? `还有${notDoneCount.value}题未做，确认交卷？` : '是否确认交卷？';
  stopTime();
  uni.$ie.showModal({
    title: '提示',
    content: text,
  }).then(confirm => {
    if (confirm) {
      handleSubmit(false);
    } else {
      startTime();
    }
  });
}

/**
 * 提交试卷
 * @param tempSave 是否临时保存
 */
const handleSubmit = (tempSave: boolean = false) => {
  // 执行完后续逻辑
  submit();
  const msg = tempSave ? '保存中...' : '提交中...';
  uni.$ie.showLoading(msg);
  setTimeout(async () => {
    const params: Study.ExamPaperSubmit = {
      ...paperData.value,
      questions: questionList.value.map(item => {
        return {
          ...item,
          title: '',
          isDone: tempSave ? item.isDone : true,
          subQuestions: item.subQuestions.map(subItem => {
            return {
              ...subItem,
              title: '',
            };
          })
        };
      }),
      examineeId: examineeId.value,
      // examineeId: examineerData.value.examineeId,
      isDone: tempSave ? isAllDone.value : true,
      duration: practiceDuration.value
    };
    console.log('提交试卷参数', params)
    const start = Date.now();
    await commitExamineePaper(params);
    const costTime = Date.now() - start;
    report(events.ExamStartSubmitSuccess, { time: costTime });
    if (isSimulationExam.value || isTestExam.value) {
      if (!tempSave) {
        setTimeout(async () => {
          report(events.ExamStartExit);
          uni.$ie.hideLoading();
          await nextTick();
          confirmQuit.value = true;
          confirmShowing.value = false;
          transferTo('/pagesStudy/pages/simulation-analysis/simulation-analysis', {
            data: {
              examineeId: examineeId.value,
              paperType: prevData.value.paperType
            } as Transfer.SimulationAnalysisPageOptions,
            type: 'redirectTo'
          });
        }, 2500);
      } else {
        uni.$ie.hideLoading();
        confirmQuit.value = true;
        confirmShowing.value = false;
        nextTick(() => {
          transferBack();
        });
      }
    } else if (isPracticeExam.value) {
      if (!tempSave) {
        setTimeout(async () => {
          report(events.ExamStartExit);
          uni.$ie.hideLoading();
          await nextTick();
          confirmQuit.value = true;
          confirmShowing.value = false;
          transferTo('/pagesStudy/pages/knowledge-practice-detail/knowledge-practice-detail', {
            data: {
              paperType: prevData.value.paperType,
              examineeId: examineeId.value,
              name: prevData.value.practiceInfo?.name,
              directed: prevData.value.practiceInfo?.directed,
              questionType: prevData.value.practiceInfo?.questionType
            } as Transfer.PracticeResultPageOptions,
            type: 'redirectTo'
          });
        }, 2500);
      } else {
        report(events.ExamStartExit);
        uni.$ie.hideLoading();
        confirmQuit.value = true;
        confirmShowing.value = false;
        nextTick(() => {
          transferBack();
        });
      }
    }
  }, 300);
}

/**
 * 恢复上次做题历史数据
 * @param savedQuestion 上次做题历史数据
 * @param fullQuestion 当前试卷数据
 */
const restoreQuestion = (savedQuestion: Study.ExamineeQuestion[], fullQuestion: Study.ExamineeQuestion[]) => {
  if (!savedQuestion) {
    return fullQuestion;
  }
  for (let index = 0; index < fullQuestion.length; index++) {
    const item = fullQuestion[index];
    const savedQs = savedQuestion[index]
    if (savedQs) {
      if (savedQs.answers) {
        item.answers = savedQs.answers.filter(ans => ans.trim());
      }
      item.answer1 = savedQs.answer1;
      item.answer2 = savedQs.answer2;
      item.isMark = savedQs.isMark;
      item.isFavorite = savedQs.isFavorite;
      item.isNotKnow = savedQs.isNotKnow;
      item.parse = savedQs.parse;
      item.totalScore = savedQs.totalScore;
      if (item.subQuestions) {
        restoreQuestion(savedQs.subQuestions, item.subQuestions);
      }
    }
  }
  return fullQuestion;
}
/**
 * 带超时检测的 getOpenExaminee 请求
 * 在 3s, 5s, 10s, 15s, 20s 这 5 个时间点检测超时并上报
 * 每个时间点如果请求还未返回，都会上报一次
 */
const getOpenExamineeWithTimeoutCheck = async (params: Study.OpenExamineeRequestDTO) => {
  // 超时时间档次（单位：毫秒）
  const timeoutLevels = [3000, 5000, 10000, 15000, 20000];
  // 存储所有定时器ID，用于清理
  const timers: number[] = [];
  // 请求是否已完成
  let isCompleted = false;

  // 创建超时检测定时器
  timeoutLevels.forEach((timeout) => {
    const timer = setTimeout(() => {
      // 如果请求已完成，不进行上报
      if (isCompleted) {
        return;
      }
      // 上报超时数据，超时时间单位为秒
      // 每个时间点如果请求还未返回，都会上报一次
      report(events.ExamStartLoadSlow, { time: timeout });
    }, timeout) as unknown as number;
    timers.push(timer);
  });

  try {
    // 执行请求
    const result = await getOpenExaminee(params);
    // 标记请求已完成
    isCompleted = true;
    // 清除所有定时器
    timers.forEach((timer) => clearTimeout(timer));
    return result;
  } catch (error) {
    // 请求失败时也要清除定时器
    isCompleted = true;
    timers.forEach((timer) => clearTimeout(timer));
    throw error;
  }
};

/**
 * 带超时检测的 getPaper 请求
 * 在 3s, 5s, 10s, 15s, 20s 这 5 个时间点检测超时并上报
 * 每个时间点如果请求还未返回，都会上报一次
 */
const getPaperWithTimeoutCheck = async (params: Study.GetExamPaperRequestDTO) => {
  // 超时时间档次（单位：毫秒）
  const timeoutLevels = [3000, 5000, 10000, 15000, 20000];
  // 存储所有定时器ID，用于清理
  const timers: number[] = [];
  // 请求是否已完成
  let isCompleted = false;

  // 创建超时检测定时器
  timeoutLevels.forEach((timeout) => {
    const timer = setTimeout(() => {
      // 如果请求已完成，不进行上报
      if (isCompleted) {
        return;
      }
      // 上报超时数据，超时时间单位为秒
      // 每个时间点如果请求还未返回，都会上报一次
      report(events.ExamStartGetPaperSlow, { time: timeout });
    }, timeout) as unknown as number;
    timers.push(timer);
  });

  try {
    // 执行请求
    const result = await getPaper(params);
    // 标记请求已完成
    isCompleted = true;
    // 清除所有定时器
    timers.forEach((timer) => clearTimeout(timer));
    return result;
  } catch (error) {
    // 请求失败时也要清除定时器
    isCompleted = true;
    timers.forEach((timer) => clearTimeout(timer));
    throw error;
  }
};

/**
 * 带超时检测的 beginExaminee 请求
 * 在 3s, 5s, 10s, 15s, 20s 这 5 个时间点检测超时并上报
 * 每个时间点如果请求还未返回，都会上报一次
 */
const beginExamineeWithTimeoutCheck = async (examineeId: number) => {
  // 超时时间档次（单位：毫秒）
  const timeoutLevels = [3000, 5000, 10000, 15000, 20000];
  // 存储所有定时器ID，用于清理
  const timers: number[] = [];
  // 请求是否已完成
  let isCompleted = false;

  // 创建超时检测定时器
  timeoutLevels.forEach((timeout) => {
    const timer = setTimeout(() => {
      // 如果请求已完成，不进行上报
      if (isCompleted) {
        return;
      }
      // 上报超时数据，超时时间单位为秒
      // 每个时间点如果请求还未返回，都会上报一次
      report(events.ExamStartBeginExamineeSlow, { time: timeout });
    }, timeout) as unknown as number;
    timers.push(timer);
  });

  try {
    // 执行请求
    const result = await beginExaminee(examineeId);
    // 标记请求已完成
    isCompleted = true;
    // 清除所有定时器
    timers.forEach((timer) => clearTimeout(timer));
    return result;
  } catch (error) {
    // 请求失败时也要清除定时器
    isCompleted = true;
    timers.forEach((timer) => clearTimeout(timer));
    throw error;
  }
};

// 1、加载知识点练习数据
const loadPracticeData = async () => {
  const { paperType, readonly, practiceInfo } = prevData.value;
  let data: Study.Examinee | null = null;
  if (readonly) {
    if (practiceInfo?.examineeId) {
      const res = await getExamineeResult(practiceInfo.examineeId);
      data = res.data;
    }
  } else {
    try {
      const params = {
        paperType: paperType,
        relateId: practiceInfo?.relateId,
      } as Study.OpenExamineeRequestDTO;
      if (userStore.isVHS) {
        params.questionType = practiceInfo?.questionType;
      } else {
        params.directed = practiceInfo?.directed || false;
      }
      const start = Date.now();
      const res = await getOpenExamineeWithTimeoutCheck(params);
      data = res.data || {};
      const costTime = Date.now() - start;
      console.log('开卷用时：', costTime);
      report(events.ExamStartLoadSuccess, { time: costTime, request: params, response: res.data || {} });
    } catch (error) {
      report(events.ExamStartLoadError, { error: error });
    }
  }

  if (!data) {
    uni.$ie.hideLoading();
    transferBack();
    return;
  }
  // 练习没有规定时间，设置为最大值
  totalExamTime.value = Number.MAX_SAFE_INTEGER;
  combinePaperData(data, paperType);
}
// 2、加载模拟考试数据
const loadExamData = async () => {
  const { paperType, readonly, simulationInfo } = prevData.value;
  let data: Study.Examinee;
  if (simulationInfo?.examineeId) {
    if (readonly) {
      const res = await getExamineeResult(simulationInfo.examineeId);
      data = res.data;
    } else {
      try {
        const start = Date.now();
        const res = await beginExamineeWithTimeoutCheck(simulationInfo.examineeId);
        data = res.data || {};
        const costTime = Date.now() - start;
        report(events.ExamStartBeginExamineeSuccess, { time: costTime, request: { examineeId: simulationInfo.examineeId }, response: res.data || {} });
      } catch (error) {
        report(events.ExamStartBeginExamineeError, { error: error });
        throw error;
      }
    }
    if (!data) {
      uni.$ie.hideLoading();
      transferBack();
      return;
    }
    totalExamTime.value = data.paperInfo?.time || 0;
    combinePaperData(data, paperType);
  }
}
// 3、加载对口升学试卷数据
// const loadVHSPaperData = async () => {
//   const { paperType, readonly, simulationInfo } = prevData.value;
//   let data: Study.Examinee;
//   if (simulationInfo?.examineeId) {
//     if (readonly) {
//       const res = await getExamineeResult(simulationInfo.examineeId);
//       data = res.data;
//     } else {
//       const params = {
//         paperType: paperType,
//         relateId: simulationInfo?.examineeId,
//       } as Study.OpenExamineeRequestDTO;
//       const res = await getOpenExaminee(params);
//       data = res.data || {};
//     }
//     if (!data) {
//       uni.$ie.hideLoading();
//       transferBack();
//       return;
//     }
//     totalExamTime.value = data.paperInfo?.time || Number.MAX_SAFE_INTEGER;
//     combinePaperData(data, paperType);
//   }
// }
const combinePaperData = async (examinee: Study.Examinee, paperType: EnumPaperType) => {
  examineeId.value = examinee.examineeId;
  report(events.ExamStartCombineData, {
    envUser: uni.getStorageSync('ie-user'),
    envApp: uni.getStorageSync('ie-app'),
  });

  if (!examinee.paperId) {
    report(events.ExamStartGetPaperError, {
      error: '获取试卷数据失败，没有paperId',
      examineeId: examinee.examineeId
    });
    return;
  }

  // 第一步：请求试卷数据（单独 try-catch）
  let res;
  try {
    const start = Date.now();
    res = await getPaperWithTimeoutCheck({
      type: paperType,
      id: examinee.paperId
    });
    const costTime = Date.now() - start;
    report(events.ExamStartGetPaperSuccess, {
      time: costTime,
      paperId: examinee.paperId,
      paperType: paperType
    });
  } catch (error: any) {
    // 请求失败的错误上报
    report(events.ExamStartGetPaperError, {
      error: error
    });
    throw error; // 继续抛出，让外层处理
  }

  // 第二步：处理和组装数据（单独 try-catch）
  try {
    paperData.value = res.data;
    paperData.value.questions = restoreQuestion(examinee.questions, res.data.questions);
    console.log('初始化数据', paperData.value.questions)
    setQuestionList(paperData.value.questions);
    setDuration(examinee.duration || 0);

    await nextTick();
    const targetQuestion = flatQuestionList.value.find(item => item.id === prevData.value.questionId);
    if (targetQuestion) {
      changeIndex(targetQuestion.index);
    } else {
      changeIndex(0);
    }
    setTimeout(() => {
      if (targetQuestion?.isSubQuestion) {
        setSubQuestionIndex(targetQuestion.subIndex || 0);
      }
    }, 50);
    await new Promise(resolve => setTimeout(resolve, 50));
    await nextTick();
    // 读取用户练习设置
    // setPracticeSettings(userStore.practiceSettings);
    isReady.value = true;
    console.log('试卷信息', res)
    if (!userStore.isExamGuideShow) {
      setTimeout(() => {
        uni.$ie.hideLoading();
        setTimeout(() => {
          showSwiperTip.value = true;
        }, 100);
      }, 300);
    } else {
      uni.$ie.hideLoading();
      if (!isReadOnly.value) {
        startTime();
      }
    }
    report(events.ExamStartCombineDataSuccess, {
      paperId: examinee.paperId,
      paperType: paperType
    });
  } catch (error: any) {
    // 数据处理失败的错误上报
    report(events.ExamStartCombineDataError, {
      error: error
    });
    throw error; // 继续抛出，让外层处理
  }
}
const handleSwiperTipNext = () => {
  showSwiperTip.value = false;
  guideShow.value = true;
}
const handleGuideClose = () => {
  userStore.isExamGuideShow = true;
  if (!isReadOnly.value) {
    startTime();
  }
}
const loadData = async () => {
  uni.$ie.showLoading();
  const { paperType } = prevData.value;
  try {
    if (paperType === EnumPaperType.PRACTICE || paperType === EnumPaperType.COURSE) {
      loadPracticeData();
    } else if (paperType === EnumPaperType.SIMULATED || paperType === EnumPaperType.TEST) {
      loadExamData();
    }
  } catch (error) {
    report(events.ExamStartInitError, { error });
    uni.$ie.showToast('加载失败，请稍后重试');
    setTimeout(() => {
      uni.$ie.hideLoading();
      transferBack();
    }, 1000);
  }
};

onLoad(() => {
  console.log(prevData.value)
  report(events.ExamStartEnter);
  loadData();
  uni.addInterceptor('navigateBack', {
    invoke: (e) => {
      if (confirmShowing.value) {
        return false;
      }
      if (confirmQuit.value) {
        return e;
      }
      handleLeftClick();
      return false;
    }
  })
});
onUnload(() => {
  uni.removeInterceptor('navigateBack');
});
</script>

<style lang="scss" scoped></style>