import cn.com.qmth.stmms.ms.Application;
import cn.com.qmth.stmms.ms.admin.utils.BultInAccountUtil;
import cn.com.qmth.stmms.ms.admin.utils.RandomUtils;
import cn.com.qmth.stmms.ms.commons.utils.RandomUtil;
import cn.com.qmth.stmms.ms.core.cache.ParamCache;
import cn.com.qmth.stmms.ms.core.domain.*;
import cn.com.qmth.stmms.ms.core.domain.enums.TrialEnum;
import cn.com.qmth.stmms.ms.core.domain.task.MarkTask;
import cn.com.qmth.stmms.ms.core.domain.user.MarkRight;
import cn.com.qmth.stmms.ms.core.domain.user.MarkUser;
import cn.com.qmth.stmms.ms.core.domain.user.Role;
import cn.com.qmth.stmms.ms.core.repository.*;
import cn.com.qmth.stmms.ms.core.vo.Subject;
import com.lowagie.text.html.Markup;
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 java.util.*;
import java.util.concurrent.atomic.AtomicLong;

/**
 * 机构线上压测数据生成
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = {Application.class})
// 指定启动类
public class BatchCreateDataTest {

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

    @Autowired
    private OrganizationRepo organizationRepo;

    @Autowired
    private ExamQuestionRepo examQuestionRepo;

    @Autowired
    private StudentRepo studentRepo;

    @Autowired
    private PaperRepo paperRepo;

    @Autowired
    private WorkRepo workRepo;

    @Autowired
    private MarkTaskRepo markTaskRepo;

    @Autowired
    private MarkUserRepo markUserRepo;

    @Autowired
    private MarkSubjectRepo markSubjectRepo;

    @Autowired
    BultInAccountUtil bultInAccountUtil;

    @Autowired
    ParamSettingRepo paramSettingRepo;

    @Autowired
    private LevelRepo levelRepo;

    @Autowired
    RandomUtil randomUtil;

    @Autowired
    RandomUtils randomUtils;

    // 考号起始值
    private int initNumber = 20000;
    // 考生数量
    private static int STUDENT_COUNT = 6000;
    // 科目数量
    private List<Subject> subjects = Arrays.asList(Subject.SX, Subject.SC, Subject.SM);
    // 评卷员数量
    private static int MARKER_COUNT = 3;
    // 机构数量
    private static int ORG_COUNT = 7;
    // 工作数量
    private static int WORK_COUNT = 3;
    // 默认密码
    private static String INIT_PASSWORD = "123456";

//    @Test
    public void createSxTask() throws Exception {


        for (int i = 1; i <= ORG_COUNT; i++) {
            // 机构
            Organization org = createOrg(i);
            for (int i1 = 0; i1 < WORK_COUNT; i1++) {
                // 工作
                Long workId = createWork(org.getId(), i1);
                // 随机数
                randomUtil.getRandom(workId, false);

                // 5秒生成随机数
                Thread.sleep(5000);

                //exam_question
                createQuestions(workId);

                //生成student信息
                List<Student> students = createStudent(workId);

                for (Subject subject : subjects) {
                    // 试卷
                    List<Paper> papers = createPaper(workId, students, subject);

                    // 评卷员
                    List<MarkUser> markUsers = createMarkUsers(org, workId, subject);
                    if(i1 < WORK_COUNT - 1) {
                        //发分档任务
                        assignLevels(workId, papers, markUsers);
                        // 发打分任务
                        assignScores(workId, papers, markUsers);
                    }
                }
            }
        }
    }


    /**
     * 创建机构
     *
     * @param i
     * @return
     */
    private Organization createOrg(int i) {
        Organization organization = new Organization();
        //机构名称
        organization.setName("机构" + i);
        //默认启用
        organization.setEnabled(true);
        organization.setCreatedOn(new Date());
        //机构id号
        String abbreviation = randomUtils.organAbbreviation();
        organization.setAbbreviation(abbreviation);
        organizationRepo.save(organization);

        //账号(机构id-账号)
        MarkUser m = new MarkUser();
        m.setLoginName(abbreviation.toLowerCase() + "-admin");
        m.setName("机构" + i);
        m.setPassword(INIT_PASSWORD);
        m.setEnabled(true);
        m.setOrganizationId(organization.getId());
        m.setRole(Role.ADMIN);
        m.setWorkId(0l);
        m.setSubject(Subject.SC);
        m.setUserType("1");
        markUserRepo.save(m);

        MarkUser m1 = new MarkUser();
        m1.setLoginName(abbreviation.toLowerCase() + "-admin1");
        m1.setName("机构管理" + i);
        m1.setPassword(INIT_PASSWORD);
        m1.setEnabled(true);
        m1.setOrganizationId(organization.getId());
        m1.setRole(Role.ADMIN);
        m1.setWorkId(0l);
        m1.setSubject(Subject.SC);
        m1.setUserType("2");
        markUserRepo.save(m1);
        return organization;
    }

    /**
     * 创建工作
     *
     * @param orgId
     * @param i
     * @return
     */
    private Long createWork(Long orgId, int i) {
        Work work = new Work();
        work.setActive(false);
        work.setName("工作" + i);
        work.setOrganizationId(orgId);
        work.setCreatedOn(new Date());
        workRepo.save(work);

        for (Subject subject : subjects) {
            MarkSubject markSubject = new MarkSubject(subject, work.getId());
            markSubject.setWorkId(work.getId());
            markSubject.setEnable(true);
            markSubjectRepo.save(markSubject);
        }

        //新增工作的同时，初始化该工作的全局参数
        ParamSetting paramSetting = ParamSetting.init();
        paramSetting.setWorkId(work.getId());
        paramSettingRepo.save(paramSetting);
        ParamCache.resetParam(paramSetting);

        //默认增加档位
        Level A = new Level(work.getId(), "A", 0, 100, 90, Level.LevelType.ADMITED, 95);
        Level B = new Level(work.getId(), "B", 1, 89, 85, Level.LevelType.ADMITED, 87);
        Level C = new Level(work.getId(), "C", 2, 84, 80, Level.LevelType.ADMITED, 82);
        Level D = new Level(work.getId(), "D", 3, 79, 75, Level.LevelType.ADMITED, 77);
        Level E = new Level(work.getId(), "E", 4, 74, 70, Level.LevelType.ADMITED, 72);
        Level F = new Level(work.getId(), "F", 5, 69, 65, Level.LevelType.ADMITED, 67);
        Level G = new Level(work.getId(), "G", 6, 64, 60, Level.LevelType.ADMITED, 62);
        Level H = new Level(work.getId(), "H", 7, 59, 55, Level.LevelType.ADMITED, 57);
        Level I = new Level(work.getId(), "I", 8, 54, 50, Level.LevelType.ADMITED, 52);
        Level J = new Level(work.getId(), "J", 9, 49, 45, Level.LevelType.ADMITED, 47);
        Level K = new Level(work.getId(), "K", 10, 44, 0, Level.LevelType.ADMITED, 40);
        List<Level> levels = Arrays.asList(A, B, C, D, E, F, G, H, I, J, K);
        levelRepo.save(levels);

        //生成内置账号
        bultInAccountUtil.createAccout(work);
        return work.getId();
    }

    /**
     * 考区
     *
     * @param workId
     */
    private void createQuestions(Long workId) {
        List<ExamQuestion> questions = new ArrayList<>();
        for (Subject subject : subjects) {
            ExamQuestion examQuestion = new ExamQuestion();
            examQuestion.setAreaCode("1");
            examQuestion.setAreaName("湖北");
            examQuestion.setName(subject.name() + "1");
            examQuestion.setSubject(subject);
            examQuestion.setWorkId(workId);
            examQuestion.setTest(0);
            questions.add(examQuestion);
        }
        examQuestionRepo.save(questions);
        logger.info("questions新增成功：{}", questions.size());
    }

    /**
     * 考生
     *
     * @param workId
     * @return
     */
    private List<Student> createStudent(Long workId) {
        List<Student> students = new ArrayList<>();
        for (int i = 0; i < STUDENT_COUNT; i++) {
            Student student = new Student();
            student.setAreaCode("1");
            student.setAreaName("湖北");
            student.setExamNumber(String.valueOf(initNumber + i));
            student.setExamRoom("第一考场");
            student.setSchool("湖北美院");
            student.setAbsent(false);
            student.setName("考生" + i);
            student.setUploadStatus("SX:1,SC:1,SM:1");
            student.setWorkId(workId);
            student.setSourceName("湖北");
            student.setTest("0");
            student.setRelateExamNumber(student.getExamNumber());
            students.add(student);
        }

        List<Student> data = new ArrayList<>();
        for (Student stu : students) {
            if (data.size() == 2000) {
                studentRepo.save(data);
                data.clear();
            }
            data.add(stu);
        }
        //将剩下的数据也导入
        if (!data.isEmpty()) {
            studentRepo.save(data);
        }
        logger.info("students新增：{}", students.size());
        return students;
    }

    /**
     * 试卷
     *
     * @param workId
     * @param students
     * @param subject
     * @return
     * @throws Exception
     */
    private List<Paper> createPaper(Long workId, List<Student> students, Subject subject) throws Exception {
        List<Paper> papers = new ArrayList<>();

        ExamQuestion examQuestion = examQuestionRepo.findByWorkIdAndSubjectAndAreaCodeAndTest(workId, subject, "1", TrialEnum.DEFAULT.getId());
        for (Student student : students) {
            Long random = getRandom(student.getWorkId(), student.getExamNumber());
            Paper paper = new Paper(student.getWorkId(), null, subject, examQuestion, student, false, random);
            papers.add(paper);
        }

        List<Paper> data = new ArrayList<>();
        for (Paper p : papers) {
            if (data.size() == 2000) {
                paperRepo.save(data);
                data.clear();
            }
            data.add(p);
        }
        //将剩下的数据也导入
        if (!data.isEmpty()) {
            paperRepo.save(data);
        }
        logger.info("papers新增：{}", papers.size());

        return papers;
    }

    /**
     * 评卷员、科组长
     *
     * @param org
     * @param workId
     * @param subject
     * @return
     */
    private List<MarkUser> createMarkUsers(Organization org, Long workId, Subject subject) {
        List<MarkUser> markUsers = new ArrayList<>();
        for (int i = 1; i <= MARKER_COUNT; i++) {
            MarkUser markUser = new MarkUser();
            markUser.setEnabled(true);
            markUser.setLoginName(org.getAbbreviation().toLowerCase() + "-" + workId + "-" + subject.name().toLowerCase() + i);
            markUser.setName(markUser.getLoginName());
            markUser.setPassword(INIT_PASSWORD);
            markUser.setPwChangedCount(1);
            markUser.setRole(Role.MARKER);
            markUser.setSubject(subject);
            markUser.setWorkId(workId);
            markUser.setOrganizationId(org.getId());
            markUser.setWeight(1D);
            markUser.setOneClickLevel(false);
            markUser.setStandardVolume(false);
            markUser.setLevelCallback(false);
            markUser.setLeaderConfirm(false);
            markUser.setMarkRight(MarkRight.ALLOW_ALL);
            markUsers.add(markUser);

        }
        markUserRepo.save(markUsers);

        // 科组长
        MarkUser markUser = new MarkUser();
        markUser.setEnabled(true);
        markUser.setLoginName(org.getAbbreviation().toLowerCase() + "-" + workId + "-" + subject.name().toLowerCase() + "kzz");
        markUser.setName(markUser.getLoginName());
        markUser.setPassword(INIT_PASSWORD);
        markUser.setPwChangedCount(1);
        markUser.setRole(Role.MARK_LEADER);
        markUser.setSubject(subject);
        markUser.setWorkId(workId);
        markUser.setOrganizationId(org.getId());
        markUser.setWeight(1D);
        markUser.setOneClickLevel(true);
        markUser.setStandardVolume(true);
        markUser.setLevelCallback(true);
        markUser.setLeaderConfirm(true);
        markUser.setMarkRight(MarkRight.ALLOW_ALL);
        markUserRepo.save(markUser);

        return markUsers;
    }

    /**
     * 分档
     *
     * @param workId
     * @param papers
     * @param markUsers
     * @throws Exception
     */
    private void assignLevels(Long workId, List<Paper> papers, List<MarkUser> markUsers) throws Exception {
        List<MarkTask> markTaskList = new ArrayList<>();
        List<Paper> paperList = new ArrayList<>();
        Long batchNo = System.currentTimeMillis();
        for (Paper paper : papers) {
            for (MarkUser markUser : markUsers) {
                Long random = getRandomSecret(markUser.getId(), paper.getId(), markUser.getWorkId(), paper.getExamNumber(), null);
                MarkTask  markTask = new MarkTask(markUser, paper, MarkStage.LEVEL, random, 0);
                markTask.setBatchNo(batchNo);
                markTask.setResult("A");
                markTask.setLevel("A");
                markTaskList.add(markTask);
            }

            //将paper置为激活
            paper.setLevel("A");
            paper.setActive(true);
            paper.setBatchNo(batchNo);
            paperList.add(paper);
        }

        List<MarkTask> data = new ArrayList<>();
        //5000条提交一次
        for (MarkTask markTask : markTaskList) {
            if (data.size() == 2000) {
                markTaskRepo.save(data);
                data.clear();
            }
            data.add(markTask);
        }
        //将剩下的数据也导入
        if (!data.isEmpty()) {
            markTaskRepo.save(data);
        }
        paperRepo.save(paperList);

        List<MarkSubject> subjects = markSubjectRepo.findAllByWorkId(workId);
        for (MarkSubject subject : subjects) {
            subject.setStage(MarkStage.LEVEL);
            markSubjectRepo.save(subject);
        }
    }

    /**
     * 分档
     *
     * @param workId
     * @param papers
     * @param markUsers
     * @throws Exception
     */
    private void assignScores(Long workId, List<Paper> papers, List<MarkUser> markUsers) throws Exception {
        List<MarkTask> markTaskList = new ArrayList<>();
        List<Paper> paperList = new ArrayList<>();
        Long batchNo = System.currentTimeMillis();
        for (Paper paper : papers) {
            for (MarkUser markUser : markUsers) {
                Long random = getRandomSecret(markUser.getId(), paper.getId(), markUser.getWorkId(), paper.getExamNumber(), null);
                MarkTask  markTask = new MarkTask(markUser, paper, MarkStage.SCORE, random, 0);
                markTask.setBatchNo(batchNo);
                markTask.setResult("95");
                markTask.setLevel(paper.getLevel());
                markTaskList.add(markTask);
            }

            //将paper置为激活
            paper.setScore(95D);
            paper.setScoreBatchNo(batchNo);
            paperList.add(paper);
        }

        List<MarkTask> data = new ArrayList<>();
        //5000条提交一次
        for (MarkTask markTask : markTaskList) {
            if (data.size() == 2000) {
                markTaskRepo.save(data);
                data.clear();
            }
            data.add(markTask);
        }
        //将剩下的数据也导入
        if (!data.isEmpty()) {
            markTaskRepo.save(data);
        }
        paperRepo.save(paperList);

        List<MarkSubject> subjects = markSubjectRepo.findAllByWorkId(workId);
        for (MarkSubject subject : subjects) {
            subject.setStage(MarkStage.SCORE);
            markSubjectRepo.save(subject);
        }
    }

    /**
     * 获取随机号
     *
     * @param workId
     * @param examNumber
     * @return
     * @throws Exception
     */
    public Long getRandom(Long workId, String examNumber) throws Exception {
        int count = 0, result = 0;
        Long random = 0L;
        while (true) {
            random = randomUtil.getRandomMap().get(workId).get(new Random().nextInt(randomUtil.getRandomMap().get(workId).size()));
            result = paperRepo.countByWorkIdAndExamNumberAndRandomSeq(workId, examNumber, random);
            if (result == 0 && random != Long.parseLong(examNumber.substring(3))) {
                break;
            } else {
                count++;
            }
            if (count > 1000) {
                randomUtil.getRandom(workId, true);
                getRandom(workId, examNumber);
            }
        }
        return random;
    }

    public Long getRandomSecret(Long markerId, Long paperId, Long workId, String examNumber, Map<Long, Object> randomMap) throws Exception {
        int count = 0;
        Long random = 0L;
        while (true) {
            random = randomUtil.getRandomMap().get(workId).get(new Random().nextInt(randomUtil.getRandomMap().get(workId).size()));
            if (Objects.isNull(randomMap) || randomMap.size() == 0) {
                break;
            }
            if (Objects.isNull(randomMap.get(random))) {
                break;
            } else {
                count++;
            }
            if (count > 1000) {
//                throw new Exception("重复几率较高，建议重新生成随机号");
                randomUtil.getRandom(workId, true);
                getRandomSecret(markerId, paperId, workId, examNumber, randomMap);
            }
        }
        return random;
    }
}