import cn.com.qmth.stmms.ms.Application;
import cn.com.qmth.stmms.ms.commons.utils.RandomUtil;
import cn.com.qmth.stmms.ms.core.domain.Level;
import cn.com.qmth.stmms.ms.core.domain.MarkSubject;
import cn.com.qmth.stmms.ms.core.domain.Paper;
import cn.com.qmth.stmms.ms.core.domain.task.MarkTask;
import cn.com.qmth.stmms.ms.core.repository.*;
import cn.com.qmth.stmms.ms.core.vo.Subject;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = {Application.class})
// 指定启动类
public class BatchScoreTest {

    private static final Logger logger = LoggerFactory.getLogger(BatchScoreTest.class);

    @Autowired
    private ExamQuestionRepo examQuestionRepo;

    @Autowired
    private StudentRepo studentRepo;

    @Autowired
    private PaperRepo paperRepo;

    @Autowired
    private WorkRepo workRepo;

    @Autowired
    private MarkSubjectRepo markSubjectRepo;

    @Autowired
    private MarkUserRepo markUserRepo;

    @Autowired
    private MarkTaskRepo markTaskRepo;

    @Autowired
    private LevelRepo levelRepo;

    @Autowired
    RandomUtil randomUtil;

    // 工作id
    private static Long WORK_ID = 1L;
    // 生成科目
    private List<Subject> subjects = Arrays.asList(Subject.SC);

    /**
     * 批量打分
     *
     * @throws Exception
     */
    @Test
    public void level() {
        List<Level> levels = levelRepo.findByWorkIdOrderByCode(WORK_ID);
        doScore(levels);
    }

    private void doScore(List<Level> levels) {
        if (CollectionUtils.isEmpty(levels)) {
            throw new RuntimeException("档位值不存在");
        }

        for (Subject subject : subjects) {
            List<Paper> list = new ArrayList<>();
            List<MarkTask> listTask = new ArrayList<>();

            MarkSubject markSubject = markSubjectRepo.findOne(WORK_ID + "-" + subject.name());
            List<Paper> papers = paperRepo.findByWorkIdAndSubject(WORK_ID, subject);
            papers = papers.stream().filter(m -> Objects.nonNull(m.getScoreBatchNo()) && StringUtils.isEmpty(m.getScore())).collect(Collectors.toList());
            for (Paper paper : papers) {
                Double score = calcScore(levels, paper);
                paper.setScore(score);
                list.add(paper);

                List<MarkTask> markTasks = markTaskRepo.findByPaperIdAndStage(paper.getId(), markSubject.getStage());
                for (MarkTask markTask : markTasks) {
                    markTask.setResult(score.toString());
                    listTask.add(markTask);
                }
            }
            List<Paper> data1 = new ArrayList<>();
            for (Paper p : list) {
                if (data1.size() == 2000) {
                    paperRepo.save(data1);
                    data1.clear();
                }
                data1.add(p);
            }
            //将剩下的数据也导入
            if (!data1.isEmpty()) {
                paperRepo.save(data1);
            }

            List<MarkTask> data2 = new ArrayList<>();
            for (MarkTask p : listTask) {
                if (data2.size() == 2000) {
                    markTaskRepo.save(data2);
                    data2.clear();
                }
                data2.add(p);
            }
            //将剩下的数据也导入
            if (!data2.isEmpty()) {
                markTaskRepo.save(data2);
            }
        }

    }

    private Double calcScore(List<Level> levels, Paper paper) {
        Level level = levels.stream().filter(m -> m.getCode().equals(paper.getLevel())).findFirst().orElseGet(null);
        Double score = 0D;
        if (level != null) {
            int random = getRandom(level.getMaxScore().intValue() - level.getMinScore().intValue());
            int scoreTemp = level.getMinScore().intValue() + random;
            if(scoreTemp - level.getMaxScore().intValue() > 0){
                scoreTemp = level.getMaxScore().intValue();
            }
            score = Double.valueOf(scoreTemp);
        }
        return score;
    }

    private int getRandom(int size) {
        return (int) (Math.random() * size);
    }

}