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

import cn.dev33.satoken.stp.StpUtil;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
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.toolkit.MPJWrappers;
import com.xjrsoft.common.enums.DeleteMark;
import com.xjrsoft.common.utils.VoToColumnUtil;
import com.xjrsoft.module.base.entity.BaseClass;
import com.xjrsoft.module.base.mapper.BaseClassMapper;
import com.xjrsoft.module.room.dto.AdjustBedPageDto;
import com.xjrsoft.module.room.dto.AdjustClassPageDto;
import com.xjrsoft.module.room.dto.AdjustStudentBedDto;
import com.xjrsoft.module.room.dto.DistributeClassPageDto;
import com.xjrsoft.module.room.dto.DistributeRoomBedDto;
import com.xjrsoft.module.room.dto.DistributeRoomBedPageDto;
import com.xjrsoft.module.room.dto.RoomBedPageDto;
import com.xjrsoft.module.room.entity.Room;
import com.xjrsoft.module.room.entity.RoomBed;
import com.xjrsoft.module.room.entity.RoomBedRecord;
import com.xjrsoft.module.room.mapper.RoomBedMapper;
import com.xjrsoft.module.room.mapper.RoomBedRecordMapper;
import com.xjrsoft.module.room.mapper.RoomMapper;
import com.xjrsoft.module.room.service.IRoomBedService;
import com.xjrsoft.module.room.vo.AdjustBedClassPageVo;
import com.xjrsoft.module.room.vo.AdjustBedClassStudentPageVo;
import com.xjrsoft.module.room.vo.AdjustBedStudentPageVo;
import com.xjrsoft.module.room.vo.DistributeClassPageVo;
import com.xjrsoft.module.room.vo.DistributeResultClassVo;
import com.xjrsoft.module.room.vo.DistributeResultListVo;
import com.xjrsoft.module.room.vo.DistributeRoomBedPageVo;
import com.xjrsoft.module.room.vo.NoBedStudentPageVo;
import com.xjrsoft.module.room.vo.RoomBedPageVo;
import com.xjrsoft.module.room.vo.RoomBedVo;
import com.xjrsoft.module.room.vo.RoomClassCountVo;
import com.xjrsoft.module.student.entity.BaseStudent;
import com.xjrsoft.module.student.entity.BaseStudentSchoolRoll;
import com.xjrsoft.module.student.mapper.BaseStudentMapper;
import com.xjrsoft.module.teacher.entity.XjrUser;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;

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

/**
* @title: 寝室床位
* @Author dzx
* @Date: 2023-12-27
* @Version 1.0
*/
@Service
@AllArgsConstructor
public class RoomBedServiceImpl extends MPJBaseServiceImpl<RoomBedMapper, RoomBed> implements IRoomBedService {
    private final RoomMapper roomMapper;
    private final RoomBedMapper roomBedMapper;
    private final BaseStudentMapper baseStudentMapper;
    private final BaseClassMapper baseClassMapper;
    private final RoomBedRecordMapper roomBedRecordMapper;
    @Override
    public Page<RoomBedPageVo> getPage(Page<RoomBedPageVo> page, RoomBedPageDto dto) {
        Page<RoomBedPageVo> result = roomBedMapper.getPage(page, dto);
        return result;
    }

    @Override
    public Boolean clearStudentInfo(List<Long> ids) {
        for (Long id : ids) {
            RoomBed roomBed = roomBedMapper.selectById(id);
            roomBed.setStudentUserId(null);
//            RoomBed roomBedData = BeanUtil.toBean(roomBed, RoomBed.class);
//            roomBedMapper.updateById(new RoomBed(){{
//                setId(id);
//                setStudentUserId(null);
//            }});
            UpdateWrapper<RoomBed> updateWrapper = new UpdateWrapper<>();
            updateWrapper.eq("id", id);
            updateWrapper.setSql("student_user_id = null");
            updateWrapper.setSql("is_check_in = 0");
            roomBedMapper.update(roomBed, updateWrapper);
        }
        return true;
    }

    @Override
    public Boolean clearStudentInfoByRoomId(Long id) {
        List<RoomBed> bedList = roomBedMapper.selectList(
                MPJWrappers.<RoomBed>lambdaJoin().eq(RoomBed::getRoomId, id)
        );
        for (RoomBed roomBed : bedList) {
            UpdateWrapper<RoomBed> updateWrapper = new UpdateWrapper<>();
            updateWrapper.eq("id", roomBed.getId());
            updateWrapper.setSql("student_user_id = null");
            updateWrapper.setSql("is_check_in = 0");
            roomBedMapper.update(roomBed, updateWrapper);
        }
        return true;
    }

    @Override
    public Boolean clearStudentInfoByBedId(Long id) {
        UpdateWrapper<RoomBed> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("id", id);
        updateWrapper.setSql("student_user_id = null");
        updateWrapper.setSql("is_check_in = 0");

        RoomBed roomBed = roomBedMapper.selectById(id);
        roomBedMapper.update(roomBed, updateWrapper);
        return true;
    }

    @Override
    public Page<DistributeClassPageVo> getDistributeClassInfo(Page<DistributeClassPageDto> page, DistributeClassPageDto dto) {
        return roomBedMapper.getDistributeClassInfo(page, dto);
    }

    @Override
    public Page<DistributeRoomBedPageVo> getDistributeRoomBedInfo(Page<DistributeRoomBedPageDto> page, DistributeRoomBedPageDto dto) {
        return roomBedMapper.getDistributeRoomBedInfo(page, dto);
    }

    @Override
    public Boolean distributeRoomBed(DistributeRoomBedDto dto) {
        //查询出所有床位信息
        List<RoomBedVo> bedInfoList = roomBedMapper.getBedInfo(dto.getRoomIds());

        Room room = roomMapper.selectById(dto.getRoomIds().get(0));
        String gender = room.getGender();
        Integer genderNumber = null;
        if("SB10001".equals(gender)){
            genderNumber = 1;
        }else if("SB10002".equals(gender)){
            genderNumber = 2;
        }

        Date modifyDate = new Date();
        Long modifyUserId = StpUtil.getLoginIdAsLong();

        //查询每个班的学生，修改床位信息
        int i = 0;
        Map<Long, Integer> classDistributeBedNumber = new HashMap<>();
        Map<Long, Integer> classStudent = new HashMap<>();
        for (Long classId : dto.getClassIds()) {
            List<BaseStudent> studentList = baseStudentMapper.selectList(
                MPJWrappers.<BaseStudent>lambdaJoin()
                .select(BaseStudent::getUserId)
                .eq(BaseClass::getId, classId)
                .eq(XjrUser::getGender, genderNumber)
                .eq(BaseStudentSchoolRoll::getStduyStatus, "FB3002")
                .eq(BaseStudent::getDeleteMark, DeleteMark.NODELETE.getCode())
                .eq(XjrUser::getDeleteMark, DeleteMark.NODELETE.getCode())
                .innerJoin(XjrUser.class, XjrUser::getId, BaseStudent::getUserId)
                .leftJoin(BaseStudentSchoolRoll.class, BaseStudentSchoolRoll::getUserId, BaseStudent::getUserId)
                .leftJoin(BaseClass.class, BaseClass::getId, BaseStudentSchoolRoll::getClassId)
            );
            //已分配床位数
            int distributeBedNumber = 0;
            for (BaseStudent studentInfoVo : studentList) {
                if(i >= bedInfoList.size()){
                    continue;
                }
                RoomBedVo roomBedVo = bedInfoList.get(i);
                RoomBed roomBed = BeanUtil.toBean(roomBedVo, RoomBed.class);
                roomBed.setStudentUserId(studentInfoVo.getUserId());
                roomBed.setModifyDate(modifyDate);
                roomBed.setModifyUserId(modifyUserId);
                roomBedMapper.updateById(roomBed);
                i ++;
                distributeBedNumber ++;

            }
            classDistributeBedNumber.put(classId, distributeBedNumber);
            classStudent.put(classId, studentList.size());
        }
        Map<Long, Long> classGradeMap = new HashMap<>();
        baseClassMapper.selectList(
            MPJWrappers.<BaseClass>lambdaJoin().in(BaseClass::getId, dto.getClassIds())
        ).forEach((baseClass)->{
            classGradeMap.put(baseClass.getId(), baseClass.getGradeId());
        });
        //插入记录表 room_bed_record
        Integer maxSortCode = roomBedRecordMapper.getMaxSortCode();
        for (Long classId : classGradeMap.keySet()) {
            maxSortCode ++;
            Integer studentCount = classStudent.get(classId);
            RoomBedRecord record = new RoomBedRecord();
            record.setClassId(classId);
            record.setGradeId(classGradeMap.get(classId));
            record.setCreateDate(modifyDate);
            record.setSortCode(maxSortCode);
            record.setNeedBedNumber(classStudent.get(classId));
            record.setDistributeBedNumber(classDistributeBedNumber.get(classId));
            record.setDeleteMark(DeleteMark.NODELETE.getCode());
            roomBedRecordMapper.insert(record);
        }

        //查询每个寝室住入的班级数量，大于2的设置为混合寝室
        List<RoomClassCountVo> classCountVoList = roomMapper.getRoomClassCount(dto.getRoomIds());
        for (RoomClassCountVo roomClassCountVo : classCountVoList) {
            if(roomClassCountVo.getClassCount() > 1){
                Room updRoom = roomMapper.selectById(roomClassCountVo.getId());
                updRoom.setIsMax(1);
                roomMapper.updateById(updRoom);
            }
        }
        return true;
    }

    @Override
    public List<DistributeResultClassVo> getDistributeResult(DistributeRoomBedDto dto) {
        List<DistributeResultListVo> list = roomBedMapper.getDistributeResult(dto);
        List<BaseClass> classList = baseClassMapper.selectList(
            Wrappers.lambdaQuery(BaseClass.class).in(BaseClass::getId, dto.getClassIds())
            .select(BaseClass.class, x -> VoToColumnUtil.fieldsToColumns(BaseClass.class).contains(x.getProperty()))
        );
        List<DistributeResultClassVo> result =  new ArrayList<>();
        for (BaseClass baseClass : classList) {
            DistributeResultClassVo classVo = new DistributeResultClassVo();
            classVo.setClassName(baseClass.getName());
            List<DistributeResultListVo> studentList = new ArrayList<>();
            for (DistributeResultListVo listVo : list) {
                if(listVo.getClassId() == null || !listVo.getClassId().equals(baseClass.getId().toString())){
                    continue;
                }
                studentList.add(listVo);
            }
            classVo.setStudentList(studentList);
            result.add(classVo);
        }
        return result;
    }

    @Override
    public List<AdjustBedClassPageVo> getClassStudetBed(AdjustClassPageDto dto) {
        List<BaseClass> classList = baseClassMapper.selectList(
            new QueryWrapper<BaseClass>().lambda()
            .eq(BaseClass::getDeleteMark, DeleteMark.NODELETE.getCode())
            .eq(ObjectUtil.isNotNull(dto.getClassId()), BaseClass::getId, dto.getClassId())
            .eq(ObjectUtil.isNotNull(dto.getGradeId()), BaseClass::getGradeId, dto.getGradeId())
        );
        List<AdjustBedClassPageVo> result = new ArrayList<>();
        List<AdjustBedClassStudentPageVo> allStudent = roomBedMapper.getClassStudetBed(dto);
        for (BaseClass classOne : classList) {
            List<AdjustBedClassStudentPageVo> studentList = new ArrayList<>();
            for (AdjustBedClassStudentPageVo adjustBedClassStudentPageVo : allStudent) {
                if(!classOne.getId().toString().equals(adjustBedClassStudentPageVo.getClassId())){
                    continue;
                }
                studentList.add(adjustBedClassStudentPageVo);
            }
            if(studentList.isEmpty()){
                continue;
            }
            AdjustBedClassPageVo adjustBedClassPageVo = BeanUtil.toBean(classOne, AdjustBedClassPageVo.class);
            adjustBedClassPageVo.setStudentList(studentList);
            result.add(adjustBedClassPageVo);
        }
        
        return result;
    }

    @Override
    public List<AdjustBedStudentPageVo> getBedStudetInfo(AdjustBedPageDto dto) {
        return roomBedMapper.getBedStudentInfo(dto);
    }

    @Override
    public Page<NoBedStudentPageVo> getNoBedStudent(Page<AdjustBedPageDto> page, AdjustBedPageDto dto) {
        return roomBedMapper.getNoBedStudent(page, dto);
    }

    @Override
    public Boolean adjustBed(AdjustStudentBedDto dto) {
        //先清空学生原来的床位
        UpdateWrapper<RoomBed> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("student_user_id", dto.getStudentUserId());
        updateWrapper.setSql("student_user_id = null");
        updateWrapper.setSql("is_check_in = 0");

        RoomBed roomBed = roomBedMapper.selectOne(new QueryWrapper<RoomBed>().lambda().eq(RoomBed::getStudentUserId, dto.getStudentUserId()));
        roomBedMapper.update(roomBed, updateWrapper);
        //再把学生保存到新的床位
        roomBedMapper.updateById(new RoomBed(){{
            setId(dto.getBedId());
            setStudentUserId(dto.getStudentUserId());
        }});
        return true;
    }
}