package com.xjrsoft.module.assessment.service.impl;

import cn.dev33.satoken.stp.StpUtil;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.IdUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.xjrsoft.common.enums.DeleteMark;
import com.xjrsoft.module.assessment.dto.AddAssessmentTemplatePlanDto;
import com.xjrsoft.module.assessment.dto.AssessmentPlanAnswerPageDto;
import com.xjrsoft.module.assessment.dto.AssessmentTemplatePlanPageDto;
import com.xjrsoft.module.assessment.dto.AssessmentTemplatePlanSureDto;
import com.xjrsoft.module.assessment.dto.UpdateAssessmentTemplatePlanDto;
import com.xjrsoft.module.assessment.dto.UpdateAssessmentTemplatePlanTimeDto;
import com.xjrsoft.module.assessment.entity.AssessmentPlanAnswerClass;
import com.xjrsoft.module.assessment.entity.AssessmentPlanAnswerStudent;
import com.xjrsoft.module.assessment.entity.AssessmentPlanQuestion;
import com.xjrsoft.module.assessment.entity.AssessmentQuestion;
import com.xjrsoft.module.assessment.entity.AssessmentTemplate;
import com.xjrsoft.module.assessment.entity.AssessmentTemplatePlan;
import com.xjrsoft.module.assessment.mapper.AssessmentPlanAnswerClassMapper;
import com.xjrsoft.module.assessment.mapper.AssessmentPlanAnswerStudentMapper;
import com.xjrsoft.module.assessment.mapper.AssessmentPlanQuestionMapper;
import com.xjrsoft.module.assessment.mapper.AssessmentQuestionMapper;
import com.xjrsoft.module.assessment.mapper.AssessmentTemplateMapper;
import com.xjrsoft.module.assessment.mapper.AssessmentTemplatePlanMapper;
import com.xjrsoft.module.assessment.service.IAssessmentTemplatePlanService;
import com.xjrsoft.module.assessment.vo.AssessmentPlanAnswerPageVo;
import com.xjrsoft.module.assessment.vo.AssessmentQuestionVo;
import com.xjrsoft.module.assessment.vo.AssessmentTemplatePlanPageVo;
import com.xjrsoft.module.assessment.vo.AssessmentTemplateQuestionVo;
import com.xjrsoft.module.student.entity.BaseStudentSchoolRoll;
import com.xjrsoft.module.teacher.entity.XjrUser;
import com.xjrsoft.module.teacher.mapper.XjrUserMapper;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;

/**
* @title: 考核计划
* @Author dzx
* @Date: 2024-04-01
* @Version 1.0
*/
@Service
@AllArgsConstructor
public class AssessmentTemplatePlanServiceImpl extends MPJBaseServiceImpl<AssessmentTemplatePlanMapper, AssessmentTemplatePlan> implements IAssessmentTemplatePlanService {
    private final AssessmentTemplatePlanMapper templatePlanMapper;

    private final AssessmentPlanQuestionMapper planQuestionMapper;
    private final AssessmentPlanAnswerClassMapper answerClassMapper;
    private final AssessmentPlanAnswerStudentMapper studentMapper;
    private final AssessmentTemplateMapper assessmentTemplateMapper;
    private final AssessmentQuestionMapper questionMapper;

    private final XjrUserMapper xjrUserMapper;


    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean add(AddAssessmentTemplatePlanDto dto) {
        AssessmentTemplate template = assessmentTemplateMapper.selectById(dto.getAssessmentTemplateId());
        AssessmentTemplatePlan assessmentTemplatePlan = BeanUtil.toBean(dto, AssessmentTemplatePlan.class);
        assessmentTemplatePlan.setScore(template.getScore());
        templatePlanMapper.insert(assessmentTemplatePlan);

        //查询模板下面的题目信息
        List<AssessmentQuestion> questionList = questionMapper.selectList(
            new QueryWrapper<AssessmentQuestion>().lambda()
            .eq(AssessmentQuestion::getDeleteMark, DeleteMark.NODELETE.getCode())
            .eq(AssessmentQuestion::getAssessmentTemplateId, dto.getAssessmentTemplateId())
        );
        Map<Long, Long> parentMap = new HashMap<>();
        for (AssessmentQuestion assessmentQuestion : questionList) {
            parentMap.put(assessmentQuestion.getId(), IdUtil.getSnowflakeNextId());
        }
        for (AssessmentQuestion assessmentQuestion : questionList) {
            AssessmentPlanQuestion planQuestion = BeanUtil.toBean(assessmentQuestion, AssessmentPlanQuestion.class);
            planQuestion.setId(parentMap.get(assessmentQuestion.getId()));
            planQuestion.setParentId(parentMap.get(assessmentQuestion.getParentId()));
            planQuestion.setAssessmentTemplatePlanId(assessmentTemplatePlan.getId());
            planQuestionMapper.insert(planQuestion);
        }

        //存入班级，并根据选人方式存入答题学生
        for (Long classId : dto.getClassIds()) {
            AssessmentPlanAnswerClass answerClass = new AssessmentPlanAnswerClass();
            answerClass.setAssessmentTemplatePlanId(assessmentTemplatePlan.getId());
            answerClass.setClassId(classId);
            answerClassMapper.insert(answerClass);

            MPJLambdaWrapper<XjrUser> query = new MPJLambdaWrapper<>();
            query.leftJoin(BaseStudentSchoolRoll.class, BaseStudentSchoolRoll::getUserId, XjrUser::getId)
            .eq(BaseStudentSchoolRoll::getClassId, classId);
            List<XjrUser> studentList = xjrUserMapper.selectJoinList(XjrUser.class, query);
            List<XjrUser> needStudentList = new ArrayList<>();
            if("all".equals(dto.getType())){
                needStudentList.addAll(studentList);
            }else if("random".equals(dto.getType())){
                int maxCount = studentList.size();//班级最大人数
                if(dto.getRandomNumber() > maxCount){
                    needStudentList.addAll(studentList);
                }else{
                    List<Integer> randomList = new ArrayList<>();
                    Random random = new Random();
                    while(randomList.size() < dto.getRandomNumber()){
                        int nextInt = random.nextInt(studentList.size());
                        if(!randomList.contains(nextInt) && nextInt >= 0){
                            randomList.add(nextInt);

                        }
                    }
                    for (Integer i : randomList) {
                        needStudentList.add(studentList.get(i));
                    }
                }
            }
            for (XjrUser xjrUser : needStudentList) {
                AssessmentPlanAnswerStudent answer = new AssessmentPlanAnswerStudent();
                answer.setAssessmentTemplatePlanId(assessmentTemplatePlan.getId());
                answer.setStudentUserId(xjrUser.getId());
                studentMapper.insert(answer);
            }
        }

        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean update(UpdateAssessmentTemplatePlanDto dto) {
        AssessmentTemplate template = assessmentTemplateMapper.selectById(dto.getAssessmentTemplateId());
        AssessmentTemplatePlan assessmentTemplatePlan = BeanUtil.toBean(dto, AssessmentTemplatePlan.class);
        assessmentTemplatePlan.setScore(template.getScore());
        templatePlanMapper.updateById(assessmentTemplatePlan);

        //删除以前的题目
        planQuestionMapper.deleteByPlanId(assessmentTemplatePlan.getId(), StpUtil.getLoginIdAsLong());
        //查询模板下面的题目信息
        List<AssessmentQuestion> questionList = questionMapper.selectList(
            new QueryWrapper<AssessmentQuestion>().lambda()
            .eq(AssessmentQuestion::getDeleteMark, DeleteMark.NODELETE.getCode())
            .eq(AssessmentQuestion::getAssessmentTemplateId, dto.getAssessmentTemplateId())
            .orderByAsc(AssessmentQuestion::getCategory)
        );
        Map<Long, Long> parentMap = new HashMap<>();
        for (AssessmentQuestion assessmentQuestion : questionList) {
            parentMap.put(assessmentQuestion.getId(), IdUtil.getSnowflakeNextId());
        }
        for (AssessmentQuestion assessmentQuestion : questionList) {
            AssessmentPlanQuestion planQuestion = BeanUtil.toBean(assessmentQuestion, AssessmentPlanQuestion.class);
            planQuestion.setId(parentMap.get(assessmentQuestion.getId()));
            planQuestion.setParentId(parentMap.get(assessmentQuestion.getParentId()));
            planQuestion.setAssessmentTemplatePlanId(assessmentTemplatePlan.getId());
            planQuestionMapper.insert(planQuestion);
        }
        //删除班级和学生
        answerClassMapper.deleteByPlanId(assessmentTemplatePlan.getId(), StpUtil.getLoginIdAsLong());
        studentMapper.deleteByPlanId(assessmentTemplatePlan.getId(), StpUtil.getLoginIdAsLong());
        //存入班级，并根据选人方式存入答题学生
        for (Long classId : dto.getClassIds()) {
            AssessmentPlanAnswerClass answerClass = new AssessmentPlanAnswerClass();
            answerClass.setAssessmentTemplatePlanId(assessmentTemplatePlan.getId());
            answerClass.setClassId(classId);
            answerClassMapper.insert(answerClass);

            MPJLambdaWrapper<XjrUser> query = new MPJLambdaWrapper<>();
            query.leftJoin(BaseStudentSchoolRoll.class, BaseStudentSchoolRoll::getUserId, XjrUser::getId)
                    .eq(BaseStudentSchoolRoll::getClassId, classId);
            List<XjrUser> studentList = xjrUserMapper.selectJoinList(XjrUser.class, query);
            List<XjrUser> needStudentList = new ArrayList<>();
            if("all".equals(dto.getType())){
                needStudentList.addAll(studentList);
            }else if("random".equals(dto.getType())){
                int maxCount = studentList.size();//班级最大人数
                if(dto.getRandomNumber() > maxCount){
                    needStudentList.addAll(studentList);
                }else{
                    List<Integer> randomList = new ArrayList<>();
                    Random random = new Random();
                    while(randomList.size() < dto.getRandomNumber()){
                        int nextInt = random.nextInt(studentList.size());
                        if(!randomList.contains(nextInt) && nextInt >= 0){
                            randomList.add(nextInt);

                        }
                    }
                    for (Integer i : randomList) {
                        needStudentList.add(studentList.get(i));
                    }
                }
            }
            for (XjrUser xjrUser : needStudentList) {
                AssessmentPlanAnswerStudent answer = new AssessmentPlanAnswerStudent();
                answer.setAssessmentTemplatePlanId(assessmentTemplatePlan.getId());
                answer.setStudentUserId(xjrUser.getId());
                studentMapper.insert(answer);
            }
        }
        return true;
    }

    @Override
    public Boolean updateTime(UpdateAssessmentTemplatePlanTimeDto dto) {
        AssessmentTemplatePlan assessmentTemplatePlan = BeanUtil.toBean(dto, AssessmentTemplatePlan.class);
        templatePlanMapper.updateById(assessmentTemplatePlan);
        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean delete(List<Long> ids) {
        templatePlanMapper.deleteBatchIds(ids);
        planQuestionMapper.delete(Wrappers.lambdaQuery(AssessmentPlanQuestion.class).in(AssessmentPlanQuestion::getAssessmentTemplatePlanId, ids));
        answerClassMapper.delete(Wrappers.lambdaQuery(AssessmentPlanAnswerClass.class).in(AssessmentPlanAnswerClass::getAssessmentTemplatePlanId, ids));
        studentMapper.delete(Wrappers.lambdaQuery(AssessmentPlanAnswerStudent.class).in(AssessmentPlanAnswerStudent::getAssessmentTemplatePlanId, ids));

        return true;
    }

    @Override
    public Page<AssessmentTemplatePlanPageVo> getPage(Page<AssessmentTemplatePlanPageVo> page, AssessmentTemplatePlanPageDto dto) {
        return templatePlanMapper.getPage(page, dto);
    }

    @Override
    public Page<AssessmentPlanAnswerPageVo> getStudentPage(Page<AssessmentPlanAnswerPageVo> page, AssessmentPlanAnswerPageDto dto) {
        return templatePlanMapper.getStudentPage(page, dto);
    }

    @Override
    public Page<AssessmentPlanAnswerPageVo> getTeacherPage(Page<AssessmentPlanAnswerPageVo> page, AssessmentPlanAnswerPageDto dto) {
        return templatePlanMapper.getTeacherPage(page, dto);
    }

    @Override
    public Boolean sure(AssessmentTemplatePlanSureDto dto) {
        long teacherId = StpUtil.getLoginIdAsLong();
        answerClassMapper.sure(dto, teacherId);
        studentMapper.sure(dto, teacherId);
        return true;
    }

    @Override
    public AssessmentTemplateQuestionVo getQuestionsById(Long id) {
        AssessmentTemplatePlan templatePlan = templatePlanMapper.selectById(id);
        AssessmentTemplateQuestionVo vo = BeanUtil.toBean(templatePlan, AssessmentTemplateQuestionVo.class);
        List<AssessmentPlanQuestion> questionList = planQuestionMapper.selectList(
            new QueryWrapper<AssessmentPlanQuestion>().lambda()
            .eq(AssessmentPlanQuestion::getDeleteMark, DeleteMark.NODELETE.getCode())
            .eq(AssessmentPlanQuestion::getAssessmentTemplatePlanId, id)
        );

        //循环大题
        List<AssessmentQuestionVo> oneList = new ArrayList<>();
        for (AssessmentPlanQuestion assessmentQuestion : questionList) {
            if(assessmentQuestion.getCategory() == 1){
                oneList.add(BeanUtil.toBean(assessmentQuestion, AssessmentQuestionVo.class));
            }
        }

        //循环小题
        for (AssessmentQuestionVo oneQuestion : oneList) {
            List<AssessmentQuestionVo> twoList = new ArrayList<>();
            for (AssessmentPlanQuestion assessmentQuestion : questionList) {
                if(assessmentQuestion.getCategory() == 2 && assessmentQuestion.getParentId().equals(oneQuestion.getId())){
                    twoList.add(BeanUtil.toBean(assessmentQuestion, AssessmentQuestionVo.class));
                }
            }
            oneQuestion.setChildren(twoList);
        }

        //循环选项
        for (AssessmentQuestionVo oneQuestion : oneList) {
            for (AssessmentQuestionVo twoQuestion : oneQuestion.getChildren()) {
                List<AssessmentQuestionVo> optionList = new ArrayList<>();
                for (AssessmentPlanQuestion assessmentQuestion : questionList) {
                    if(assessmentQuestion.getCategory() == 3 && assessmentQuestion.getParentId().equals(twoQuestion.getId())){
                        optionList.add(BeanUtil.toBean(assessmentQuestion, AssessmentQuestionVo.class));
                    }
                }
                twoQuestion.setOptions(optionList);
            }
        }

        vo.setChildren(oneList);
        return vo;
    }
}