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

import cn.dev33.satoken.stp.StpUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.xjrsoft.common.enums.DeleteMark;
import com.xjrsoft.common.enums.EnabledMark;
import com.xjrsoft.common.enums.EvaluateTypeEnum;
import com.xjrsoft.common.exception.MyException;
import com.xjrsoft.common.mybatis.SqlRunnerAdapter;
import com.xjrsoft.common.utils.VoToColumnUtil;
import com.xjrsoft.module.base.entity.BaseGrade;
import com.xjrsoft.module.courseTable.dto.ClassTeacherDto;
import com.xjrsoft.module.courseTable.mapper.CourseTableMapper;
import com.xjrsoft.module.courseTable.vo.ClassTeacherVo;
import com.xjrsoft.module.evaluate.dto.*;
import com.xjrsoft.module.evaluate.entity.EvaluateExecuter;
import com.xjrsoft.module.evaluate.entity.EvaluateManage;
import com.xjrsoft.module.evaluate.entity.EvaluateObject;
import com.xjrsoft.module.evaluate.entity.EvaluateTemplate;
import com.xjrsoft.module.evaluate.mapper.EvaluateExecuterMapper;
import com.xjrsoft.module.evaluate.mapper.EvaluateManageMapper;
import com.xjrsoft.module.evaluate.mapper.EvaluateObjectMapper;
import com.xjrsoft.module.evaluate.service.IEvaluateObjectService;
import com.xjrsoft.module.evaluate.vo.*;
import com.xjrsoft.module.organization.entity.User;
import com.xjrsoft.module.organization.service.IUserService;
import com.xjrsoft.module.student.dto.BaseStudentUserPageDto;
import com.xjrsoft.module.student.service.IBaseStudentService;
import com.xjrsoft.module.student.vo.BaseStudentUserPageVo;
import com.xjrsoft.module.teacher.entity.BaseTeacher;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.ZoneId;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @title: 评价管理
 * @Author dzx
 * @Date: 2024-01-16
 * @Version 1.0
 */
@Service
@AllArgsConstructor
public class EvaluateObjectServiceImpl extends MPJBaseServiceImpl<EvaluateObjectMapper, EvaluateObject> implements IEvaluateObjectService {
    private final EvaluateManageMapper evaluateManageMapper;

    private final EvaluateObjectMapper evaluateObjectMapper;
    private final EvaluateExecuterMapper evaluateExecuterMapper;
    private final CourseTableMapper courseTableMapper;
    private final IUserService userService;
    private final IBaseStudentService studentService;


    @Override
    public List<EvaluateObjectListVo> getObjectList(EvaluateObjectListDto dto) {
        List<EvaluateObjectListVo> objectList = evaluateObjectMapper.getObjectList(dto);
        List<EvaluateExecuterVo> allExecuterList = evaluateObjectMapper.getExecuterList(dto);

//        Map<String, List<EvaluateExecuterVo>> groupEvaluateExecuterByEvaluateObjectId = allExecuterList.stream()
//                .collect(Collectors.groupingBy(EvaluateExecuterVo::getEvaluateObjectId));
        for (EvaluateObjectListVo objectVo : objectList) {
//            List<EvaluateExecuterVo> executerVoList = groupEvaluateExecuterByEvaluateObjectId.get(objectVo.getId());
//            objectVo.setExecuterCount(executerVoList.size());
//            objectVo.setExecuterList(executerVoList);
            List<EvaluateExecuterVo> executerList = new ArrayList<>();
            for (EvaluateExecuterVo executerVo : allExecuterList) {
                if (objectVo.getId().equals(executerVo.getEvaluateObjectId())) {
                    executerList.add(executerVo);
                }
            }

            objectVo.setExecuterCount(executerList.size());
            objectVo.setExecuterList(executerList);
        }
        return objectList;
    }

    @Override
    public List<EvaluateObjectGradeListVo> getObjectGradeList(EvaluateObjectGradeListDto dto) {
        /*SELECT
            count(t1.id),
            t1.base_grade_id,
            t2.name,
            count(t4.id)
        FROM evaluate_object t1
                 LEFT JOIN base_grade t2 ON t2.id = t1.base_grade_id
                 LEFT JOIN evaluate_executer t4 ON t4.evaluate_object_id = t1.id
        WHERE t1.delete_mark = 0 and t1.evaluate_manage_id = 1747177686090969089
        group by t1.base_grade_id;*/
        MPJLambdaWrapper<EvaluateObject> evaluateObjectMPJLambdaWrapper = new MPJLambdaWrapper<>();
        evaluateObjectMPJLambdaWrapper
                .selectAs(EvaluateObject::getEvaluateManageId, EvaluateObjectGradeListVo::getEvaluateManageId)
                .select("count(distinct t.id) as objectCount")
                .selectAs(EvaluateObject::getBaseGradeId, EvaluateObjectGradeListVo::getGradeId)
                .selectAs(BaseGrade::getName, EvaluateObjectGradeListVo::getGradeName)
                .selectCount(EvaluateExecuter::getId, EvaluateObjectGradeListVo::getExecuterCount)
                .leftJoin(BaseGrade.class, BaseGrade::getId, EvaluateObject::getBaseGradeId)
                .leftJoin(EvaluateExecuter.class, EvaluateExecuter::getEvaluateObjectId, EvaluateObject::getId)
                .eq(EvaluateObject::getEvaluateManageId, dto.getEvaluateManageId())
                .groupBy(EvaluateObject::getBaseGradeId)
                .disableSubLogicDel();

        return this.selectJoinList(EvaluateObjectGradeListVo.class, evaluateObjectMPJLambdaWrapper);
    }

    @Override
    @Transactional
    public Boolean objectGradeDelete(ObjectGradeDeleteDto dto) {
        //获取当前评价管理的类型
        LambdaQueryWrapper<EvaluateManage> evaluateManageMPJLambdaWrapper = new LambdaQueryWrapper<>();
        evaluateManageMPJLambdaWrapper
                .eq(EvaluateManage::getId, dto.getEvaluateManageId());
        EvaluateManage evaluateManage = evaluateManageMapper.selectOne(evaluateManageMPJLambdaWrapper);
        if (evaluateManage == null) {
            throw new MyException("该评价管理已经失效");
        }

        if (evaluateManage.getStatus() != -1) {
            throw new MyException("该评价管理正在使用");
        }
        evaluateObjectMapper.objectGradeDeleteExecuter(dto);
        evaluateObjectMapper.objectGradeDeleteObject(dto);
        return true;
    }

    @Override
    @Transactional
    public Boolean save(SaveEvaluateObjectDto dto) {
        //获取当前评价管理的类型
        MPJLambdaWrapper<EvaluateManage> evaluateManageMPJLambdaWrapper = new MPJLambdaWrapper<>();
        evaluateManageMPJLambdaWrapper
                .select(EvaluateManage::getId)
                .selectAs(EvaluateTemplate::getEvaluateType, EvaluateManageVo::getEvaluateType)
                .select(EvaluateManage.class, x -> VoToColumnUtil.fieldsToColumns(EvaluateManageVo.class).contains(x.getProperty()))
                .innerJoin(EvaluateTemplate.class, EvaluateTemplate::getId, EvaluateManage::getEvaluateTemplateId)
                .eq(EvaluateManage::getId, dto.getEvaluateManageId())
                .disableSubLogicDel();
        EvaluateManageVo evaluateManageVo = evaluateManageMapper.selectJoinOne(EvaluateManageVo.class, evaluateManageMPJLambdaWrapper);
        if (evaluateManageVo == null) {
            throw new MyException("未查询到信息，evaluateManageId不正确");
        }

        if (evaluateManageVo.getStatus() != -1) {
            throw new MyException("该评价正在使用");
        }

        //清空原有数据
        String delSql = "DELETE FROM evaluate_executer WHERE evaluate_object_id IN (" +
                " SELECT id FROM evaluate_object WHERE evaluate_manage_id = #{dto.evaluateManageId}";
        if (dto.getObjectList() != null && !dto.getObjectList().isEmpty()) {
            List<String> gradeIds = dto.getObjectList().stream().map(AddEvaluateObjectDto::getGradeId).collect(Collectors.toList());
            delSql += " and base_grade_id in (" + gradeIds.toString().replace("[", "").replace("]", "") + ")";
        }
        delSql += ")";
        SqlRunnerAdapter.db().delete(delSql);

        delSql = "DELETE FROM evaluate_object WHERE evaluate_manage_id = " + dto.getEvaluateManageId();
        if (dto.getObjectList() != null && !dto.getObjectList().isEmpty()) {
            List<String> gradeIds = dto.getObjectList().stream().map(AddEvaluateObjectDto::getGradeId).collect(Collectors.toList());
            delSql += " and base_grade_id in (" + gradeIds.toString().replace("[", "").replace("]", "") + ")";
        }
        SqlRunnerAdapter.db().delete(delSql);

        //保存新数据
        Date createDate = new Date();
        long createUserId = StpUtil.getLoginIdAsLong();
        for (AddEvaluateObjectDto objectDto : dto.getObjectList()) {
            if (StrUtil.isEmpty(objectDto.getObjectId())) {
                continue;
            }
            EvaluateObject evaluateObject = new EvaluateObject();
            evaluateObject.setObjectId(Long.parseLong(objectDto.getObjectId()));
            evaluateObject.setEvaluateManageId(Long.parseLong(dto.getEvaluateManageId()));
            evaluateObject.setDeleteMark(DeleteMark.NODELETE.getCode());
            evaluateObject.setCreateDate(createDate);
            evaluateObject.setCreateUserId(createUserId);
            evaluateObject.setEnabledMark(EnabledMark.ENABLED.getCode());
            evaluateObject.setBaseGradeId(Long.parseLong(objectDto.getGradeId()));
            if (evaluateManageVo.getEvaluateType().equals(EvaluateTypeEnum.DRILLMASTER_EVALUATE_CLASS.getCode())) {
                evaluateObject.setObjectType("class");
            }
            if (evaluateManageVo.getEvaluateType().equals(EvaluateTypeEnum.STUDENT_EVALUATE_HEAD_TEACHER.getCode())) {
                evaluateObject.setObjectType("teacher");
            }
            evaluateObjectMapper.insert(evaluateObject);

            for (AddEvaluateExecuterDto executerDto : objectDto.getExecuterList()) {
                EvaluateExecuter executer = new EvaluateExecuter();
                executer.setCreateDate(createDate);
                executer.setCreateUserId(createUserId);
                executer.setEvaluateManageId(Long.parseLong(dto.getEvaluateManageId()));
                executer.setEvaluateObjectId(evaluateObject.getId());
                executer.setUserId(Long.parseLong(executerDto.getExecuterId().trim()));
                executer.setStatus(0);
                evaluateExecuterMapper.insert(executer);
            }
        }
        return true;
    }

    @Override
    public List<EvaluateObjectListVo> getNewObjectList(EvaluateObjectListDto dto) {
        List<EvaluateObjectListVo> newObjectList = new ArrayList<>();
        //入参评价类型是学生评价班主任
        if (dto.getEvaluateType() != null && dto.getEvaluateType().equals(EvaluateTypeEnum.STUDENT_EVALUATE_HEAD_TEACHER.getCode())) {
            newObjectList = evaluateObjectMapper.getNewObjectList(dto);
            List<EvaluateExecuterVo> newExecuterList = evaluateObjectMapper.getNewExecuterList(dto);

            //将学生按照班级处理成map
            Map<String, List<EvaluateExecuterVo>> evaluateExecuterVoMap = newExecuterList.stream()
                    .collect(Collectors.groupingBy(EvaluateExecuterVo::getClassId));

            for (EvaluateObjectListVo objectListVo : newObjectList) {
                List<EvaluateExecuterVo> dataList = new ArrayList<>();
                for (EvaluateExecuterVo executerVo : newExecuterList) {
                    if (!executerVo.getClassId().equals(objectListVo.getClassId())) {
                        continue;
                    }
                    dataList.add(executerVo);
                }
                List<EvaluateExecuterVo> executerList = new ArrayList<>();
                if (evaluateExecuterVoMap.get(objectListVo.getClassId()) != null) {
                    dataList.addAll(evaluateExecuterVoMap.get(objectListVo.getClassId()));
                    if ("random15".equals(dto.getExecuterCount()) && !dataList.isEmpty()) {
                        List<Integer> randomList = new ArrayList<>();
                        Random random = new Random();
                        while (randomList.size() < 15) {
                            int nextInt = random.nextInt(dataList.size());
                            if (!randomList.contains(nextInt)) {
                                randomList.add(nextInt);
                            }
                        }
                        for (Integer i : randomList) {
                            executerList.add(dataList.get(i));
                        }
                    } else {
                        executerList.addAll(dataList);
                    }
                }
                objectListVo.setExecuterCount(executerList.size());
                objectListVo.setExecuterList(executerList);
            }
        }
        else if (dto.getEvaluateType() != null && dto.getEvaluateType().equals(EvaluateTypeEnum.DRILLMASTER_EVALUATE_CLASS.getCode())) {//入参评价类型是教官评价班级
            newObjectList = evaluateObjectMapper.getNewObjectList(dto);
            List<EvaluateExecuterVo> newExecuterList = evaluateObjectMapper.getNewExecuterList(dto);

            for (EvaluateObjectListVo objectListVo : newObjectList) {
                objectListVo.setExecuterCount(newExecuterList.size());
                objectListVo.setExecuterList(newExecuterList);
            }
        }
        else if (dto.getEvaluateType() != null && dto.getEvaluateType().equals(EvaluateTypeEnum.TEACHER_EVALUATE_CLASS.getCode())) {//任课教师对班级评价
            EvaluateManage manage = evaluateManageMapper.selectById(dto.getEvaluateManageId());
            newObjectList = evaluateObjectMapper.getNewObjectList(dto);

            List<ClassTeacherVo> classTeacher = courseTableMapper.getClassTeacherIds(
                    new ClassTeacherDto() {{
                        setStartDate(manage.getStartTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate());
                        setGradeId(dto.getGradeId());
                        setEndDate(manage.getEndTime().toInstant().atZone(ZoneId.systemDefault()).toLocalDate());
                    }}
            );

            List<User> userList = userService.list(
                    new MPJLambdaWrapper<User>()
                            .select(User::getId)
                            .select(User.class, x -> VoToColumnUtil.fieldsToColumns(User.class).contains(x.getProperty()))
                            .innerJoin(BaseTeacher.class, BaseTeacher::getUserId, User::getId)
            );
            Map<Long, String> userMap = userList.stream().collect(Collectors.toMap(User::getId, User::getName));
            for (EvaluateObjectListVo objectListVo : newObjectList) {
                List<EvaluateExecuterVo> currentExecuterList = new ArrayList<>();
                for (ClassTeacherVo executerVo : classTeacher) {
                    if (!objectListVo.getObjectId().equals(executerVo.getClassId().toString())) {
                        continue;
                    }

                    String[] teacherIds = executerVo.getTeacherId().split(",");
                    for (String teacherId : teacherIds) {
                        EvaluateExecuterVo evaluateExecuterVo = new EvaluateExecuterVo();
                        evaluateExecuterVo.setExecuterId(teacherId);
                        evaluateExecuterVo.setEvaluateObjectId(objectListVo.getObjectId());
                        evaluateExecuterVo.setExecuterName(userMap.get(Long.parseLong(teacherId.trim())));
                        evaluateExecuterVo.setEvaluateManageId(dto.getEvaluateManageId().toString());
                        currentExecuterList.add(evaluateExecuterVo);
                    }
                }
                objectListVo.setExecuterCount(currentExecuterList.size());
                objectListVo.setExecuterList(currentExecuterList);
            }
        }
        else if (dto.getEvaluateType() != null && dto.getEvaluateType().equals(EvaluateTypeEnum.STUDENT_EVALUATE_COURSE_TEACHER.getCode())) {//入参评价类型是学生评价教师
            EvaluateManage manage = evaluateManageMapper.selectById(dto.getEvaluateManageId());
            //查询这个年级的所有学生
            List<EvaluateExecuterVo> newExecuterList = evaluateObjectMapper.getNewExecuterList(dto);
            Map<String, List<EvaluateExecuterVo>> classExcuterMap = newExecuterList.stream().collect(Collectors.groupingBy(EvaluateExecuterVo::getClassId));

            //查询每个班级的任课教师
            dto.setStartTime(manage.getStartTime());
            dto.setEndTime(manage.getEndTime());
            List<ClassTeachersListVo> classTeachers = evaluateObjectMapper.getClassTeachers(dto);
            List<ClassTeachersListVo> collect = classTeachers.stream().filter(p -> StrUtil.isNotEmpty(p.getTeacherId())).collect(Collectors.collectingAndThen(
                    Collectors.toMap(
                            ClassTeachersListVo::getUniqueKey,
                            p -> p,
                            (existing, replacement) -> existing
                    ),
                    map -> new ArrayList<>(map.values())
            ));
            Map<String, List<ClassTeachersListVo>> classTeacherMap = collect.stream().collect(Collectors.groupingBy(ClassTeachersListVo::getTeacherId));

            List<User> userList = userService.list(
                    new MPJLambdaWrapper<User>()
                            .select(User::getId)
                            .select(User.class, x -> VoToColumnUtil.fieldsToColumns(User.class).contains(x.getProperty()))
                            .innerJoin(BaseTeacher.class, BaseTeacher::getUserId, User::getId)
            );
            Map<Long, String> userMap = userList.stream().collect(Collectors.toMap(User::getId, User::getName));

            for (String teacherId : classTeacherMap.keySet()) {
                if (!userMap.containsKey(Long.parseLong(teacherId.trim()))) {
                    continue;
                }
                if ("15331003902918".equals(teacherId)) {
                    System.out.println(teacherId);
                }
                EvaluateObjectListVo objectListVo = new EvaluateObjectListVo();

                Set<Long> classIds = classTeacherMap.get(teacherId).stream().map(ClassTeachersListVo::getClassId).collect(Collectors.toSet());

                List<EvaluateExecuterVo> currentExecuterList = new ArrayList<>();
                for (Long classId : classIds) {
                    List<EvaluateExecuterVo> studentList = classExcuterMap.get(classId.toString());
                    if (studentList == null) {
                        continue;
                    }
                    if ("random15".equals(dto.getExecuterCount()) && !studentList.isEmpty()) {
                        List<Integer> randomList = new ArrayList<>();
                        Random random = new Random();
                        while (randomList.size() < 15) {
                            int nextInt = random.nextInt(studentList.size());
                            if (!randomList.contains(nextInt)) {
                                randomList.add(nextInt);
                            }
                        }
                        for (Integer i : randomList) {
                            currentExecuterList.add(studentList.get(i));
                        }
                    } else {
                        currentExecuterList.addAll(studentList);
                    }
                }

                objectListVo.setObjectId(teacherId.trim());
                objectListVo.setObjectName(userMap.get(Long.parseLong(teacherId.trim())));
                objectListVo.setExecuterCount(currentExecuterList.size());
                objectListVo.setExecuterList(currentExecuterList);
                newObjectList.add(objectListVo);
            }
        }
        else if (dto.getEvaluateType() != null && dto.getEvaluateType().equals(EvaluateTypeEnum.STU_SELF_EVALUATE.getCode())){//学生自评
            BaseStudentUserPageDto studentUserPageDto = new BaseStudentUserPageDto();
            studentUserPageDto.setGradeId(dto.getGradeId());
            List<Long> classIds = new ArrayList<>();
            classIds.add(dto.getClassId());
            studentUserPageDto.setClassIds(classIds);
            List<BaseStudentUserPageVo> studentList = studentService.getStudentList(studentUserPageDto);

            for (BaseStudentUserPageVo student : studentList) {
                EvaluateObjectListVo object = new EvaluateObjectListVo();
                object.setObjectName(student.getName());
                object.setObjectId(student.getId());
                object.setGradeId(student.getGradeId().toString());
                object.setGradeName(student.getGradeName());
                object.setClassId(student.getClassId().toString());

                List<EvaluateExecuterVo> executerList = new ArrayList<>();

                EvaluateExecuterVo executerVo = new EvaluateExecuterVo();
                executerVo.setEvaluateObjectId(student.getId());
                executerVo.setExecuterName(student.getName());
                executerVo.setExecuterId(student.getId());
                executerVo.setGradeId(student.getGradeId().toString());
                executerVo.setClassId(student.getClassId().toString());

                executerList.add(executerVo);
                object.setExecuterList(executerList);
                object.setExecuterCount(executerList.size());

                newObjectList.add(object);
            }
        }
        else if (dto.getEvaluateType() != null && dto.getEvaluateType().equals(EvaluateTypeEnum.CLASS_STU_EVALUATE.getCode())){//班级学生交叉互评
            BaseStudentUserPageDto studentUserPageDto = new BaseStudentUserPageDto();
            studentUserPageDto.setGradeId(dto.getGradeId());
            List<Long> classIds = new ArrayList<>();
            classIds.add(dto.getClassId());
            studentUserPageDto.setClassIds(classIds);
            List<BaseStudentUserPageVo> studentList = studentService.getStudentList(studentUserPageDto);
            Map<Long, List<BaseStudentUserPageVo>> classStudentMap = studentList.stream().collect(Collectors.groupingBy(BaseStudentUserPageVo::getClassId));
            for (BaseStudentUserPageVo student : studentList) {
                EvaluateObjectListVo object = new EvaluateObjectListVo();
                object.setObjectName(student.getName());
                object.setObjectId(student.getId());
                object.setGradeId(student.getGradeId().toString());
                object.setGradeName(student.getGradeName());
                object.setClassId(student.getClassId().toString());

                List<BaseStudentUserPageVo> classStudentList = classStudentMap.get(student.getClassId());

                List<EvaluateExecuterVo> executerList = new ArrayList<>();
                if(classStudentList != null){
                    for (BaseStudentUserPageVo otherStudent : classStudentList) {
                        if(otherStudent.getId().equals(student.getId())){
                            continue;
                        }
                        EvaluateExecuterVo executerVo = new EvaluateExecuterVo();
                        executerVo.setEvaluateObjectId(student.getId());
                        executerVo.setExecuterName(otherStudent.getName());
                        executerVo.setExecuterId(otherStudent.getId());
                        executerVo.setGradeId(otherStudent.getGradeId().toString());
                        executerVo.setClassId(otherStudent.getClassId().toString());

                        executerList.add(executerVo);
                    }
                }

                object.setExecuterList(executerList);
                object.setExecuterCount(executerList.size());
                newObjectList.add(object);
            }
        }
        else if (dto.getEvaluateType() != null && dto.getEvaluateType().equals(EvaluateTypeEnum.TEA_EVALUATE_STU.getCode())){//教师评价班级学生
            BaseStudentUserPageDto studentUserPageDto = new BaseStudentUserPageDto();
            studentUserPageDto.setGradeId(dto.getGradeId());
            List<Long> classIds = new ArrayList<>();
            classIds.add(dto.getClassId());
            studentUserPageDto.setClassIds(classIds);
            List<BaseStudentUserPageVo> studentList = studentService.getStudentList(studentUserPageDto);

        }

        return newObjectList;
    }
}