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

import cn.dev33.satoken.stp.StpUtil;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
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.YesOrNoEnum;
import com.xjrsoft.common.exception.MyException;
import com.xjrsoft.common.model.result.RT;
import com.xjrsoft.common.utils.VoToColumnUtil;
import com.xjrsoft.module.banding.dto.BandingTaskClassPageDto;
import com.xjrsoft.module.banding.dto.BandingTaskClassStudentPageDto;
import com.xjrsoft.module.banding.dto.UpdateBandingClassDto;
import com.xjrsoft.module.banding.entity.BandingTask;
import com.xjrsoft.module.banding.entity.BandingTaskClass;
import com.xjrsoft.module.banding.entity.BandingTaskClassStudent;
import com.xjrsoft.module.banding.mapper.BandingTaskClassMapper;
import com.xjrsoft.module.banding.mapper.BandingTaskClassStudentMapper;
import com.xjrsoft.module.banding.mapper.BandingTaskMapper;
import com.xjrsoft.module.banding.service.IBandingTaskClassService;
import com.xjrsoft.module.banding.vo.BandingTaskClassPageVo;
import com.xjrsoft.module.banding.vo.BandingTaskClassStudentListVo;
import com.xjrsoft.module.banding.vo.BandingTaskClassSureListVo;
import com.xjrsoft.module.base.entity.BaseClass;
import com.xjrsoft.module.base.entity.BaseClassroom;
import com.xjrsoft.module.base.entity.BaseMajorSet;
import com.xjrsoft.module.base.mapper.BaseClassMapper;
import com.xjrsoft.module.base.service.IBaseClassroomService;
import com.xjrsoft.module.base.service.IBaseMajorSetService;
import com.xjrsoft.module.organization.entity.User;
import com.xjrsoft.module.organization.service.IUserService;
import com.xjrsoft.module.system.entity.DictionaryDetail;
import com.xjrsoft.module.system.entity.DictionaryItem;
import com.xjrsoft.module.system.mapper.DictionarydetailMapper;
import com.xjrsoft.module.teacher.entity.BaseTeacher;
import lombok.AllArgsConstructor;
import org.camunda.bpm.engine.TaskService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
* @title: 新生分班任务
* @Author dzx
* @Date: 2024-07-01
* @Version 1.0
*/
@Service
@AllArgsConstructor
public class BandingTaskClassServiceImpl extends MPJBaseServiceImpl<BandingTaskClassMapper, BandingTaskClass> implements IBandingTaskClassService {

    private final BandingTaskMapper bandingTaskMapper;
    private final BandingTaskClassStudentMapper classStudentMapper;
    private final IBaseClassroomService classroomService;
    private final IUserService userService;
    private final IBaseMajorSetService majorSetService;
    private final DictionarydetailMapper detailMapper;
    private final BaseClassMapper classMapper;
    @Override
    public Boolean add(BandingTaskClass bandingTaskClass) {
        bandingTaskClass.setCreateDate(new Date());
        this.baseMapper.insert(bandingTaskClass);
        return true;
    }

    @Override
    public Boolean update(BandingTaskClass bandingTaskClass) {
        bandingTaskClass.setModifyDate(new Date());
        this.baseMapper.updateById(bandingTaskClass);
        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean delete(List<Long> ids) {
        this.baseMapper.deleteBatchIds(ids);
        return true;
    }

    @Override
    public List<BandingTaskClassPageVo> getList(BandingTaskClassPageDto dto) {
        BandingTask bandingTask = bandingTaskMapper.selectById(dto.getBandingTaskId());
        dto.setGradeId(bandingTask.getGradeId());
        dto.setEnrollType(bandingTask.getEnrollType());
        return this.baseMapper.getList(dto);
    }

    @Override
    public Boolean reset(Long bandingTaskId) {
        List<BandingTaskClass> classList = this.baseMapper.selectList(
                new QueryWrapper<BandingTaskClass>().lambda()
                        .eq(BandingTaskClass::getBandingTaskId, bandingTaskId)
                        .eq(BandingTaskClass::getStatus, 0)
        );

        for (BandingTaskClass bandingTaskClass : classList) {
            bandingTaskClass.setModifyDate(new Date());
            bandingTaskClass.setHeight(null);
            bandingTaskClass.setScore(null);
            this.baseMapper.updateById(bandingTaskClass);
        }

        List<Long> classIds = classList.stream().map(BandingTaskClass::getId).collect(Collectors.toList());
        if(!classIds.isEmpty()){
            classStudentMapper.delete(
                    new QueryWrapper<BandingTaskClassStudent>().lambda()
                            .in(BandingTaskClassStudent::getBandingTaskClassId, classIds)
            );
        }
        return true;
    }

    @Override
    public List<BandingTaskClassStudentListVo> classStudent(BandingTaskClassStudentPageDto dto) {
        BandingTask bandingTask = bandingTaskMapper.selectById(dto.getBandingTaskId());
        dto.setGradeId(bandingTask.getGradeId());
        dto.setEnrollType(bandingTask.getEnrollType());
        return this.baseMapper.getClassStudent(dto);
    }

    @Override
    public List<BandingTaskClassSureListVo> getClassSure(BandingTaskClassStudentPageDto dto) {
        return this.baseMapper.getClassSure(dto);
    }

    @Override
    public Boolean importData(Long bandingTaskId, List<Map<Integer, Object>> excelDataList) {
        List<BaseClassroom> classroomList = classroomService.list(
                new QueryWrapper<BaseClassroom>().lambda()
                        .eq(BaseClassroom::getDeleteMark, DeleteMark.NODELETE.getCode())
        );
        Map<String, Long> classroomMap = new HashMap<>();
        for (BaseClassroom classroom : classroomList) {
            classroomMap.put(classroom.getName(), classroom.getId());
        }
        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<String, Long> userMap = new HashMap<>();
        for (User user : userList) {
            userMap.put(user.getName(), user.getId());
        }

        List<BaseMajorSet> majorSetList = majorSetService.list(
                new QueryWrapper<BaseMajorSet>().lambda()
        );

        Map<String, Long> majorSetMap = new HashMap<>();
        for (BaseMajorSet majorSet : majorSetList) {
            majorSetMap.put(majorSet.getName(), majorSet.getId());
        }
        List<DictionaryDetail> classType = detailMapper.selectJoinList(DictionaryDetail.class,
                new MPJLambdaWrapper<DictionaryDetail>()
                        .select(DictionaryDetail::getId)
                        .select(DictionaryDetail.class, x -> VoToColumnUtil.fieldsToColumns(DictionaryDetail.class).contains(x.getProperty()))
                        .innerJoin(DictionaryItem.class, DictionaryItem::getId, DictionaryDetail::getItemId)
                        .eq(DictionaryItem::getCode, "class_type")
        );
        Map<String, String> classTypeMap = classType.stream().collect(Collectors.toMap(DictionaryDetail::getName, DictionaryDetail::getCode));
        List<BandingTaskClass> classList = new ArrayList<>();
        Date createDate = new Date();
        for (Map<Integer, Object> taskClass : excelDataList) {
            classList.add(new BandingTaskClass(){{
                setBandingTaskId(bandingTaskId);
                setCreateDate(createDate);
                setName(taskClass.get(1).toString());
                setMajorSetId(majorSetMap.get(taskClass.get(0).toString().trim()));
                setNumber(Integer.parseInt(taskClass.get(2).toString()));
                setClassroomId(classroomMap.get(taskClass.get(4).toString()));
                if(taskClass.get(5) != null){
                    setClassType(classTypeMap.get(taskClass.get(5).toString()));
                }
                if(taskClass.get(6) != null){
                    setIsOrderClass(YesOrNoEnum.getCode(taskClass.get(6).toString()));
                }
                if(taskClass.get(7) != null){
                    setSortCode(Integer.parseInt(taskClass.get(7).toString()));
                }
                setTeacherId(userMap.get(taskClass.get(3).toString()));
            }});
        }
        Boolean result = this.saveBatch(classList);
        return result;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean updateNull(List<BandingTaskClass> updNullList) {
        for (BandingTaskClass taskClass : updNullList) {
            UpdateWrapper<BandingTaskClass> updateWrapper = new UpdateWrapper<>();
            updateWrapper.eq("id", taskClass.getId());
            updateWrapper.setSql("sort_code = null");
            this.baseMapper.update(taskClass, updateWrapper);
        }

        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean saveClass(List<UpdateBandingClassDto> dtoList) {
        List<BandingTaskClass> insList = new ArrayList<>();//新增班级
        List<BandingTaskClass> updList = new ArrayList<>();//修改班级
        List<BandingTaskClass> updNullList = new ArrayList<>();//修改班级
        List<String> errorList = new ArrayList<>();//修改班级

        BandingTask task = bandingTaskMapper.selectById(dtoList.get(0).getBandingTaskId());
        List<BaseClass> classList = classMapper.selectList(
                new QueryWrapper<BaseClass>().lambda()
                        .eq(BaseClass::getDeleteMark, DeleteMark.NODELETE.getCode())
                        .eq(BaseClass::getGradeId, task.getGradeId())
        );

        Map<String, BaseClass> classMap = classList.stream().collect(Collectors.toMap(BaseClass::getName, x -> x));
        List<BaseClass> updateClassList = new ArrayList<>();//修改班级
        List<BaseClass> insertClassList = new ArrayList<>();//修改班级

        List<BaseMajorSet> majorSetList = majorSetService.list(
                new QueryWrapper<BaseMajorSet>().lambda()
                        .eq(BaseMajorSet::getDeleteMark, DeleteMark.NODELETE.getCode())
        );
        Map<Long, Long> majorDeptMap = majorSetList.stream().collect(Collectors.toMap(BaseMajorSet::getId, BaseMajorSet::getDepartmentId));

        for (UpdateBandingClassDto dto : dtoList) {
            if(dto.getSortCode() != null){
                List<BandingTaskClass> list = this.list(
                        new QueryWrapper<BandingTaskClass>().lambda()
                                .eq(BandingTaskClass::getSortCode, dto.getSortCode())
                                .eq(BandingTaskClass::getBandingTaskId, dto.getBandingTaskId())
                                .ne(dto.getId() != null,BandingTaskClass::getId, dto.getId())
                );
                if(!list.isEmpty()){
                    errorList.add(dto.getName());
                }
            }

            BandingTaskClass taskClass = BeanUtil.toBean(dto, BandingTaskClass.class);
            if(taskClass.getId() != null){
                taskClass.setModifyDate(new Date());
                if(taskClass.getSortCode() == null){
                    updNullList.add(taskClass);
                }else{
                    updList.add(taskClass);
                }
            }else{
                taskClass.setCreateDate(new Date());
                insList.add(taskClass);
            }
            if(classMap.containsKey(taskClass.getName())){
                BaseClass baseClass = classMap.get(taskClass.getName());
                baseClass.setClassType(taskClass.getClassType());
                baseClass.setTeacherId(taskClass.getTeacherId());
                baseClass.setMajorSetId(taskClass.getMajorSetId());
                baseClass.setClassroomId(taskClass.getClassroomId());
                baseClass.setIsOrderClass(taskClass.getIsOrderClass());
                baseClass.setOrgId(majorDeptMap.get(taskClass.getMajorSetId()));
                updateClassList.add(baseClass);
            }else{
                BaseClass baseClass = new BaseClass();
                baseClass.setClassType(taskClass.getClassType());
                baseClass.setTeacherId(taskClass.getTeacherId());
                baseClass.setMajorSetId(taskClass.getMajorSetId());
                baseClass.setClassroomId(taskClass.getClassroomId());
                baseClass.setIsOrderClass(taskClass.getIsOrderClass());
                baseClass.setOrgId(majorDeptMap.get(taskClass.getMajorSetId()));
                baseClass.setGradeId(task.getGradeId());
                insertClassList.add(baseClass);
            }
        }
        if(!errorList.isEmpty()){
            throw new MyException(errorList.toString().replace("[", "").replace("]", "") + "，分班排序重复");
        }

        if(!updNullList.isEmpty()){
            this.updateNull(updNullList);
        }

        if(!insertClassList.isEmpty()){
            for (BaseClass baseClass : insertClassList) {
                classMapper.insert(baseClass);
            }
        }
        if(!updateClassList.isEmpty()){
            for (BaseClass baseClass : updateClassList) {
                classMapper.updateById(baseClass);
            }
        }

        this.saveBatch(insList);
        return this.updateBatchById(updList);
    }

    /**
     * 班级管理中，修改信息时同步修改新生分班中的班级信息
     * @param baseClass
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean updateByBaseClass(BaseClass baseClass) {
        List<BandingTask> bandingTasks = bandingTaskMapper.selectList(
                new QueryWrapper<BandingTask>().lambda()
                        .eq(BandingTask::getDeleteMark, DeleteMark.NODELETE.getCode())
                        .eq(BandingTask::getGradeId, baseClass.getGradeId())
                        .orderByDesc(BandingTask::getId)
                        .eq(BandingTask::getStatus, 0)
        );
        if(bandingTasks.isEmpty()){
            return true;
        }
        BandingTaskClass one = this.getOne(
                new MPJLambdaWrapper<BandingTaskClass>()
                        .select(BandingTask::getId)
                        .select(BandingTask.class, x -> VoToColumnUtil.fieldsToColumns(BandingTask.class).contains(x.getProperty()))
                        .innerJoin(BandingTask.class, BandingTask::getId, BandingTaskClass::getBandingTaskId)
                        .eq(BandingTaskClass::getDeleteMark, DeleteMark.NODELETE.getCode())
                        .eq(BandingTaskClass::getName, baseClass.getName())
                        .eq(BandingTask::getGradeId, baseClass.getGradeId())
                        .eq(BandingTask::getStatus, 1)
        );
        if(one == null){
            BandingTask task = bandingTasks.get(0);
            one = new BandingTaskClass();
            one.setBandingTaskId(task.getId());
            one.setIsOrderClass(baseClass.getIsOrderClass());
            one.setClassType(baseClass.getClassType());
            one.setTeacherId(baseClass.getTeacherId());
            one.setMajorSetId(baseClass.getMajorSetId());
            one.setClassroomId(baseClass.getClassroomId());
            one.setDeleteMark(DeleteMark.NODELETE.getCode());
            one.setCreateDate(new Date());
            one.setEnabledMark(EnabledMark.ENABLED.getCode());
            one.setName(baseClass.getName());
            one.setCreateUserId(StpUtil.getLoginIdAsLong());
            this.save(one);
        }else{
            one.setIsOrderClass(baseClass.getIsOrderClass());
            one.setClassType(baseClass.getClassType());
            one.setTeacherId(baseClass.getTeacherId());
            one.setMajorSetId(baseClass.getMajorSetId());
            one.setClassroomId(baseClass.getClassroomId());
            one.setModifyDate(new Date());
            one.setModifyUserId(StpUtil.getLoginIdAsLong());
            this.updateById(one);
        }
        return true;
    }
}