RuoYi-Vue/ruoyi-sim/src/main/java/com/ruoyi/sim/service/impl/RealExamFaultService.java

package com.ruoyi.sim.service.impl;

import java.util.ArrayList;
import java.util.List;

import com.github.jsonzou.jmockdata.JMockData;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.sim.constant.CommConst;
import com.ruoyi.sim.constant.FaultConst;
import com.ruoyi.sim.domain.vo.RealExamFaultReportPart1Vo;
import com.ruoyi.sim.domain.vo.RealExamFaultReportPart2Vo;
import com.ruoyi.sim.domain.vo.RealExamFaultReportPart3Vo;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.sim.mapper.RealExamFaultMapper;
import com.ruoyi.sim.domain.RealExamFault;
import org.springframework.transaction.annotation.Transactional;

/**
 * 考试故障关联Service业务层处理
 *
 * @author tom
 * @date 2024-12-15
 */
@Service
public class RealExamFaultService {
    @Autowired
    private RealExamFaultMapper realExamFaultMapper;
    @Autowired
    private FaultService faultService;

    /**
     * 查询考试故障关联
     *
     * @param refId 考试故障关联主键
     * @return 考试故障关联
     */
    public RealExamFault selectRealExamFaultByRefId(Long refId) {
        return realExamFaultMapper.selectRealExamFaultByRefId(refId);
    }

    /**
     * 查询考试故障关联列表
     *
     * @param realExamFault 考试故障关联
     * @return 考试故障关联
     */
    public List<RealExamFault> selectRealExamFaultList(RealExamFault realExamFault) {
        return realExamFaultMapper.selectRealExamFaultList(realExamFault);
    }

    /**
     * 新增考试故障关联
     *
     * @param realExamFault 考试故障关联
     * @return 结果
     */
    public int insertRealExamFault(RealExamFault realExamFault) {
        realExamFault.setCreateTime(DateUtils.getNowDate());
        return realExamFaultMapper.insertRealExamFault(realExamFault);
    }

    /**
     * 修改考试故障关联
     *
     * @param realExamFault 考试故障关联
     * @return 结果
     */
    @Transactional
    public int updateRealExamFault(RealExamFault realExamFault) {
        realExamFault.setUpdateTime(DateUtils.getNowDate());
        return realExamFaultMapper.updateRealExamFault(realExamFault);
    }

    /**
     * 批量删除考试故障关联
     *
     * @param refIds 需要删除的考试故障关联主键
     * @return 结果
     */
    public int deleteRealExamFaultByRefIds(Long[] refIds) {
        return realExamFaultMapper.deleteRealExamFaultByRefIds(refIds);
    }

    /**
     * 删除考试故障关联信息
     *
     * @param refId 考试故障关联主键
     * @return 结果
     */
    public int deleteRealExamFaultByRefId(Long refId) {
        return realExamFaultMapper.deleteRealExamFaultByRefId(refId);
    }

    // -------------------------------- tom add  --------------------------------

    private static final Logger l = LoggerFactory.getLogger(RealExamFaultService.class);

    public void updateRefStateByRefId(final long refId, final String state) {
        if (!existByRefId(refId)) {
            return;
        }
        RealExamFault f = selectRealExamFaultByRefId(refId);
        f.setRefState(state);
        updateRealExamFault(f);
    }

    public boolean existByRefId(final Long refId) {
        RealExamFault f = selectRealExamFaultByRefId(refId);
        return f != null;
    }

    /**
     * 初始化状态的 关联列表。
     *
     * @param examId
     * @return
     */
    public List<RealExamFault> listAllType2InitStateByExamId(Long examId) {
        RealExamFault q = new RealExamFault();
        q.setExamId(examId);
        q.setRefType(RealExamFault.Type.TYPE_2);
        q.setRefState(RealExamFault.State.INIT);
        return realExamFaultMapper.selectRealExamFaultList(q);
    }

    public List<RealExamFault> listAllType2FlagYesClearedStateByExamId(Long examId) {
        RealExamFault q = new RealExamFault();
        q.setExamId(examId);
        q.setRefType(RealExamFault.Type.TYPE_2);
        q.setRefState(RealExamFault.State.CLEARED);
        q.setFlag(RealExamFault.Flag.YES);
        return realExamFaultMapper.selectRealExamFaultList(q);
    }

    public List<RealExamFault> listAllType2ByExamId(Long examId) {
        RealExamFault q = new RealExamFault();
        q.setExamId(examId);
        q.setRefType(RealExamFault.Type.TYPE_2);
        return realExamFaultMapper.selectRealExamFaultList(q);
    }


    /**
     * reset real_exam_fault 表中关联数据
     *
     * @param examId
     */
    @Transactional
    public void resetAllType2(final Long examId) {
        listAllType2(examId).stream().forEach(ref -> {
            ref.setRefState(RealExamFault.State.INIT);
            ref.setAnswerRight(RealExamFault.AnswerRight.UNKNOWN);
            ref.setChoiceQuestionValue("");
            ref.setChoiceAnswerValue("");
            ref.setSimFaultQuestionValue("");
            ref.setSimFaultAnswerValue("");
            ref.setMinus(0L);
            updateRealExamFault(ref);
        });
    }

    public void reset(final Long examId) {
        RealExamFault q = new RealExamFault();
        q.setExamId(examId);
    }

    /**
     *
     * @param examId
     * @return
     */
    public List<RealExamFault> listAllType2State2and3ByExamId(Long examId) {
        List<RealExamFault> list = new ArrayList<>();
        {
            RealExamFault q = new RealExamFault();
            q.setExamId(examId);
            q.setRefType(RealExamFault.Type.TYPE_2);
            q.setRefState(RealExamFault.State.WRITTEN);
            list.addAll(realExamFaultMapper.selectRealExamFaultList(q));
        }
        {
            RealExamFault q = new RealExamFault();
            q.setExamId(examId);
            q.setRefType(RealExamFault.Type.TYPE_2);
            q.setRefState(RealExamFault.State.LOOP_READ);
            list.addAll(realExamFaultMapper.selectRealExamFaultList(q));
        }
        return list;
    }

    public List<RealExamFault> listAllType2(Long examId) {
        RealExamFault q = new RealExamFault();
        q.setExamId(examId);
        q.setRefType(RealExamFault.Type.TYPE_2);
        return realExamFaultMapper.selectRealExamFaultList(q);
    }

    /**
     * 全部下发Ok?
     *
     * @param examId
     * @return
     */
    public boolean isAllType2StateXiaFa(long examId) {
        List<RealExamFault> list = listAllType2(examId);
        for (RealExamFault ref : list) {
            String state = ref.getRefState();
            if (RealExamFault.State.WRITTEN.equals(state) || RealExamFault.State.LOOP_READ.equals(state)) {
                continue;
            } else {
                return false;
            }
        }
        return true;
    }

    /**
     * 全部清除并下发选中Ok?
     * // 如果全部下发完毕 修改RealExam状态
     * <p>
     * // todo:单独一个故障，特殊处理
     *
     * @param examId
     * @return
     */
    public boolean isType2ExamPrepareStartOk(long examId) {
        RealExamFault q = new RealExamFault();
        q.setExamId(examId);
        q.setRefType(RealExamFault.Type.TYPE_2);
        List<RealExamFault> list = selectRealExamFaultList(q);
        for (RealExamFault ref : list) {
            // 关于 flag
            String flag = ref.getFlag();
            if (RealExamFault.Flag.YES.equals(flag)) {
                if (!RealExamFault.State.WRITTEN.equals(ref.getRefState())) {
                    return false;
                }
            } else if (RealExamFault.Flag.NO.equals(flag)) {
                if (!RealExamFault.State.LOOP_READ.equals(ref.getRefState())) {
                    return false;
                }
            }
            // 关于答题值
            String qV = ref.getSimFaultQuestionValue();
            if (qV == null || qV.isBlank() || qV.length() != CommConst.LENGTH_8) {
                return false;
            }
        }
        return true;
    }

    /**
     * QuestionValue and AnswerValue not isBlank
     *
     * @param examId
     * @return
     */
    public boolean isType2ExamPrepareSubmitOk(long examId) {
        RealExamFault q = new RealExamFault();
        q.setExamId(examId);
        q.setRefType(RealExamFault.Type.TYPE_2);
        List<RealExamFault> list = selectRealExamFaultList(q);
        for (RealExamFault ref : list) {
            // todo:需要更多check
            if (StringUtils.isBlank(ref.getSimFaultQuestionValue()) || StringUtils.isBlank(ref.getSimFaultAnswerValue())) {
                return false;
            }
        }
        return true;
    }

    public boolean isState(Long refId, String state) {
        RealExamFault f = selectRealExamFaultByRefId(refId);
        if (f == null) {
            return false;
        }
        return state.equals(f.getRefState());
    }

    @Transactional
    public void calculateMinusByRealExamId(long examId) {
        l.info("calculateMinusByRealExamId realExamId : {}", examId);
        RealExamFault q = new RealExamFault();
        q.setExamId(examId);
        selectRealExamFaultList(q).forEach(ref -> {
            calculateMinus(ref.getRefId());
        });
    }

    /**
     * 计算减分 + 判断对错。
     *
     * @param refId
     * @return 每条关联计算结果。
     */
    @Transactional
    public AjaxResult calculateMinus(Long refId) {
        l.info("calculateMinus refId : {}", refId);
        RealExamFault ref = selectRealExamFaultByRefId(refId);
        // check
        if (ref == null) {
            throw new RuntimeException("calculateMinus");
        }
        if (!RealExamFault.Flag.YES.equals(ref.getFlag())) {
            // throw new RuntimeException("calculateMinus");
            l.warn("not yes");
            return AjaxResult.error("not yes");
        }
        // default minus 0
        int minus = 0;
        String answerRight = RealExamFault.AnswerRight.UNKNOWN;
        l.info("ref = {}", ref);
        String refType = ref.getRefType();
        final String qV = ref.getSimFaultQuestionValue();
        final String aV = ref.getSimFaultAnswerValue();

        if (RealExamFault.Type.TYPE_1.equals(refType)) {
            // todo:选择题的算减分
            // todo:细化实现
        }
        if (RealExamFault.Type.TYPE_2.equals(refType)) {
            // check
            if (StringUtils.isAnyBlank(qV, aV)) {
                // todo:一般不应该出现的情况
                return AjaxResult.error("数据报文异常！");
            }
            // 模拟器故障 的 计算减分 + 判断对错
            if (FaultConst.JUDGE_SET.contains(ref.getFaultId())) {
                String aVLast = aV.substring(6, 8);
                if (CommConst.ANSWER_LAST_RIGHT_MSG.equals(aVLast)) {
                    minus = 0;
                    answerRight = RealExamFault.AnswerRight.YES;
                } else if (CommConst.ANSWER_LAST_WRONG_MSG.equals(aVLast)) {
                    minus = 25;
                    answerRight = RealExamFault.AnswerRight.NO;
                } else {
                    return AjaxResult.error("数据报文异常！");
                }
            } else if (!StringUtils.equals(qV, aV)) {
                // 扣0分
                minus = 0;
                answerRight = RealExamFault.AnswerRight.YES;
            } else {
                // 扣25分 故障未排除
                minus = 25;
                answerRight = RealExamFault.AnswerRight.NO;
            }
        }
        ref.setMinus((long) minus);
        ref.setAnswerRight(answerRight);
        // 更新减分数据。
        updateRealExamFault(ref);
        return AjaxResult.success();
    }

    public List<RealExamFaultReportPart1Vo> getReportListPart1(final Long examId) {
        RealExamFault q = new RealExamFault();
        q.setExamId(examId);
        q.setRefType(RealExamFault.Type.TYPE_2);
        q.setFlag(RealExamFault.Flag.YES);
        List<RealExamFault> list1 = selectRealExamFaultList(q);
        List<RealExamFaultReportPart1Vo> list2 = new ArrayList<>();
        list1.forEach(ref -> {
            RealExamFaultReportPart1Vo vo = new RealExamFaultReportPart1Vo();
            BeanUtils.copyProperties(ref, vo);
            vo.setFault(faultService.selectFaultByFaultId(ref.getFaultId()));
            list2.add(vo);
        });
        return list2;
    }

    public List<RealExamFaultReportPart2Vo> getReportListPart2(final Long examId) {
        RealExamFaultReportPart2Vo r1 = JMockData.mock(RealExamFaultReportPart2Vo.class);
        RealExamFaultReportPart2Vo r2 = JMockData.mock(RealExamFaultReportPart2Vo.class);
        RealExamFaultReportPart2Vo r3 = JMockData.mock(RealExamFaultReportPart2Vo.class);
        List<RealExamFaultReportPart2Vo> list = new ArrayList<>();
        list.add(r1);
        list.add(r2);
        list.add(r3);
        // todo:
        return null;
    }

    public RealExamFaultReportPart3Vo getReportPart3(final Long examId) {
        RealExamFaultReportPart3Vo r1 = JMockData.mock(RealExamFaultReportPart3Vo.class);
        // todo:
        return null;
    }

    /**
     * 删除mx_real_exam_fault表关联数据
     *
     * @param examId
     */
    public void deleteRefByExamId(Long examId) {
        RealExamFault q = new RealExamFault();
        q.setExamId(examId);
        List<RealExamFault> list = selectRealExamFaultList(q);
        list.forEach(ef -> {
            deleteRealExamFaultByRefId(ef.getRefId());
        });
    }
}