package com.gkhy.exam.coalmine.service.impl;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.TypeReference;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.gkhy.exam.coalmine.entity.ExaminerManage;
import com.gkhy.exam.coalmine.entity.ExaminerManageOperateTypeBind;
import com.gkhy.exam.coalmine.entity.TeacherManage;
import com.gkhy.exam.coalmine.entity.TeacherManageOperateTypeBind;
import com.gkhy.exam.coalmine.model.dto.req.*;
import com.gkhy.exam.coalmine.model.dto.resp.GetExaminerOperateTypesRespDTO;
import com.gkhy.exam.coalmine.model.dto.resp.GetExaminerRespDTO;
import com.gkhy.exam.coalmine.model.dto.resp.GetTeacherOperateTypesRespDTO;
import com.gkhy.exam.coalmine.model.dto.resp.GetTeacherRespDTO;
import com.gkhy.exam.coalmine.service.EduResourcesManagerService;
import com.gkhy.exam.coalmine.service.baseService.ExaminerManageOperateTypeBindService;
import com.gkhy.exam.coalmine.service.baseService.ExaminerManageService;
import com.gkhy.exam.coalmine.service.baseService.TeacherManageOperateTypeBindService;
import com.gkhy.exam.coalmine.service.baseService.TeacherManageService;
import com.ruoyi.common.constant.CacheConstants;
import com.ruoyi.common.constant.ResultConstants;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.enums.coalmineEnums.DeleteStatusEnum;
import com.ruoyi.common.enums.coalmineEnums.EnableStatusEnum;
import com.ruoyi.common.exception.BusinessException;
import com.ruoyi.file.entity.AttachmentInfo;
import com.ruoyi.file.service.AttachmentInfoService;
import com.ruoyi.system.domain.bo.SysOperateTypeWholeNameBO;
import com.ruoyi.system.service.SysOperateTypeService;
import com.sun.org.apache.bcel.internal.generic.IF_ACMPEQ;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import static com.ruoyi.common.utils.PageUtils.startPage;

/**
 * @author Mr.huang
 * @decription
 * @date 2023/9/11 16:04
 */
@Service
public class EduResourcesManagerServiceImpl implements EduResourcesManagerService {

    @Resource
    private ExaminerManageService examinerManageService;

    @Resource
    private TeacherManageService teacherManageService;

    @Resource
    private AttachmentInfoService attachmentInfoService;

    @Resource
    private SysOperateTypeService operateTypeService;

    @Resource
    private RedisCache redisCache;

    @Resource
    private ExaminerManageOperateTypeBindService examinerManageOperateTypeBindService;

    @Resource
    private TeacherManageOperateTypeBindService teacherManageOperateTypeBindService;

    @Override
    @Transactional
    public AjaxResult saveExaminer(ExaminerManageAddReqDTO reqDTO) {
        ExaminerManage examinerByCode = examinerManageService.getExaminerByCode(reqDTO.getCode());
        if (examinerByCode != null)
            throw new BusinessException(this.getClass(),ResultConstants.SYSTEM_ERROR_DATABASE_FAIL,"身份证已存在");
        ExaminerManage examinerManage = new ExaminerManage();
        BeanUtils.copyProperties(reqDTO,examinerManage);
        examinerManage.setDelFlag(DeleteStatusEnum.NO.getStatus());
        examinerManage.setStatus(EnableStatusEnum.YES.getStatus());
        boolean save = examinerManageService.save(examinerManage);
        if (!save)
            throw new BusinessException(this.getClass(), ResultConstants.SYSTEM_ERROR_DATABASE_FAIL,"考评员信息保存失败");
        if (!CollectionUtils.isEmpty(reqDTO.getOperateTypes())){
            ArrayList<ExaminerManageOperateTypeBind> binds = new ArrayList<>();
            for (ExaminerManageAddOperateTypeReqDTO operateType : reqDTO.getOperateTypes()) {
                ExaminerManageOperateTypeBind examinerManageOperateTypeBind = new ExaminerManageOperateTypeBind();
                BeanUtils.copyProperties(operateType,examinerManageOperateTypeBind);
                examinerManageOperateTypeBind.setDelFlag(DeleteStatusEnum.NO.getStatus());
                examinerManageOperateTypeBind.setExaminerManageId(examinerManage.getId());
                binds.add(examinerManageOperateTypeBind);
            }
            boolean saveBatch = examinerManageOperateTypeBindService.saveBatch(binds);
            if (!saveBatch)
                throw new BusinessException(this.getClass(), ResultConstants.SYSTEM_ERROR_DATABASE_FAIL,"考评员工种数据保存失败");
        }
        return AjaxResult.success("新增成功");
    }


    @Override
    @Transactional
    public AjaxResult removeExaminerById(Long id) {
        ExaminerManage manage = examinerManageService.getExaminerById(id);
        if (manage == null)
            return AjaxResult.success("删除成功");
        manage.setDelFlag(DeleteStatusEnum.YES.getStatus());
        boolean save = examinerManageService.updateById(manage);
        if (!save)
            throw new BusinessException(this.getClass(), ResultConstants.SYSTEM_ERROR_DATABASE_FAIL,"考评员信息删除失败");
        removeOldExaminerManageOperateTypeBind(id);
        return AjaxResult.success("删除成功");
    }

    private void removeOldExaminerManageOperateTypeBind(Long id){
        List<ExaminerManageOperateTypeBind> binds = examinerManageOperateTypeBindService.listByExaminerManageId(id);
        if (!CollectionUtils.isEmpty(binds)){
            binds = binds.stream().map(bind -> {
                bind.setDelFlag(DeleteStatusEnum.YES.getStatus());
                return bind;
            }).collect(Collectors.toList());
            boolean updateBatchById = examinerManageOperateTypeBindService.updateBatchById(binds);
            if (!updateBatchById)
                throw new BusinessException(this.getClass(), ResultConstants.SYSTEM_ERROR_DATABASE_FAIL,"考评员信息修改失败");
        }
    }

    private void removeOldTeacherManageOperateTypeBind(Long id){
        List<TeacherManageOperateTypeBind> binds = teacherManageOperateTypeBindService.listByTeacherManageId(id);
        if (!CollectionUtils.isEmpty(binds)){
            binds = binds.stream().map(bind -> {
                bind.setDelFlag(DeleteStatusEnum.YES.getStatus());
                return bind;
            }).collect(Collectors.toList());
            boolean updateBatchById = teacherManageOperateTypeBindService.updateBatchById(binds);
            if (!updateBatchById)
                throw new BusinessException(this.getClass(), ResultConstants.SYSTEM_ERROR_DATABASE_FAIL,"教师信息修改失败");
        }
    }

    @Override
    @Transactional
    public AjaxResult updateExaminerById(ExaminerManageUpdateReqDTO reqDTO) {
        ExaminerManage examinerByCode = examinerManageService.getExaminerByCode(reqDTO.getCode());
        if (examinerByCode != null && examinerByCode.getId() != reqDTO.getId())
            throw new BusinessException(this.getClass(),ResultConstants.SYSTEM_ERROR_DATABASE_FAIL,"身份证已存在");
        ExaminerManage examinerManage = examinerManageService.getExaminerById(reqDTO.getId());
        BeanUtils.copyProperties(reqDTO,examinerManage,"id");
        boolean save = examinerManageService.updateById(examinerManage);
        if (!save)
            throw new BusinessException(this.getClass(), ResultConstants.SYSTEM_ERROR_DATABASE_FAIL,"考评员信息修改失败");
        removeOldExaminerManageOperateTypeBind(reqDTO.getId());
        if (!CollectionUtils.isEmpty(reqDTO.getOperateTypes())){
            ArrayList<ExaminerManageOperateTypeBind> binds = new ArrayList<>();
            for (ExaminerManageAddOperateTypeReqDTO operateType : reqDTO.getOperateTypes()) {
                ExaminerManageOperateTypeBind examinerManageOperateTypeBind = new ExaminerManageOperateTypeBind();
                BeanUtils.copyProperties(operateType,examinerManageOperateTypeBind);
                examinerManageOperateTypeBind.setDelFlag(DeleteStatusEnum.NO.getStatus());
                examinerManageOperateTypeBind.setExaminerManageId(examinerManage.getId());
                binds.add(examinerManageOperateTypeBind);
            }
            boolean saveBatch = examinerManageOperateTypeBindService.saveBatch(binds);
            if (!saveBatch)
                throw new BusinessException(this.getClass(), ResultConstants.SYSTEM_ERROR_DATABASE_FAIL,"考评员工种数据保存失败");
        }
        return AjaxResult.success("修改成功");
    }

    private AttachmentInfo getAttachmentInfoById(Long id){
        if (id != null){
            AttachmentInfo attachmentInfo = attachmentInfoService.findById(id);
            return attachmentInfo;
        }
        return null;
    }

    @Override
    public AjaxResult getExaminerById(Long id) {
        ExaminerManage manage = examinerManageService.getExaminerById(id);
        GetExaminerRespDTO dto = getExaminerRespDTO(manage);
        return AjaxResult.success(dto);
    }

    private GetExaminerRespDTO getExaminerRespDTO(ExaminerManage manage) {
        GetExaminerRespDTO dto = new GetExaminerRespDTO();
        if (manage == null)
            return null;
        BeanUtils.copyProperties(manage,dto);
        dto.setQaAttachment(getAttachmentInfoById(manage.getQaAttachment()));
        dto.setPhotoAttachment(getAttachmentInfoById(manage.getPhotoAttachment()));
        LambdaQueryWrapper<ExaminerManageOperateTypeBind> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(ExaminerManageOperateTypeBind::getExaminerManageId,manage.getId())
                .eq(ExaminerManageOperateTypeBind::getDelFlag,DeleteStatusEnum.NO.getStatus());
        List<ExaminerManageOperateTypeBind> list = examinerManageOperateTypeBindService.list(wrapper);
        if (CollectionUtils.isEmpty(list))
            return dto;
        Boolean flag = redisCache.hasKey(CacheConstants.SYS_OPERATE_TYPE_NAME_KEY);
        if (flag){
            operateTypeService.resetOperateTypeCache();
        }
        List<GetExaminerOperateTypesRespDTO> getExaminerOperateTypesRespDTOS = new ArrayList<>();
        for (ExaminerManageOperateTypeBind examinerManageOperateTypeBind : list) {
            GetExaminerOperateTypesRespDTO operateTypesRespDTO = new GetExaminerOperateTypesRespDTO();
            BeanUtils.copyProperties(examinerManageOperateTypeBind,operateTypesRespDTO);
            SysOperateTypeWholeNameBO sysOperateTypeWholeNameBO = operateTypeService.getOperateTypeWholeNameById(examinerManageOperateTypeBind.getOperateTypeId());
            if (sysOperateTypeWholeNameBO != null){
                BeanUtils.copyProperties(sysOperateTypeWholeNameBO,operateTypesRespDTO);
            }
            getExaminerOperateTypesRespDTOS.add(operateTypesRespDTO);
        }
        dto.setOperateTypes(getExaminerOperateTypesRespDTOS);
        return dto;
    }


    @Override
    public List<GetExaminerRespDTO> selectAll(Integer isCm) {
        LambdaQueryWrapper<ExaminerManage> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(ExaminerManage::getDelFlag,DeleteStatusEnum.NO.getStatus())
                .eq(ExaminerManage::getIsCm,isCm);
        List<ExaminerManage> list = examinerManageService.list(wrapper);
        if (CollectionUtils.isEmpty(list))
            return new ArrayList<>();
        List<GetExaminerRespDTO> dtos = new ArrayList<>();
        for (ExaminerManage manage : list) {
            GetExaminerRespDTO dto = getExaminerRespDTO(manage);
            dtos.add(dto);
        }
        return dtos;
    }

    @Override
    @Transactional
    public AjaxResult saveTeacher(TeacherManageAddReqDTO reqDTO) {
        TeacherManage teacherManage = teacherManageService.getTeacherByCode(reqDTO.getCode());
        if (teacherManage != null)
            throw new BusinessException(this.getClass(),ResultConstants.SYSTEM_ERROR_DATABASE_FAIL,"身份证已存在");
        teacherManage = new TeacherManage();
        BeanUtils.copyProperties(reqDTO,teacherManage);
        teacherManage.setDelFlag(DeleteStatusEnum.NO.getStatus());
        teacherManage.setStatus(EnableStatusEnum.YES.getStatus());
        boolean save = teacherManageService.save(teacherManage);
        if (!save)
            throw new BusinessException(this.getClass(), ResultConstants.SYSTEM_ERROR_DATABASE_FAIL,"教师信息保存失败");
        if (!CollectionUtils.isEmpty(reqDTO.getOperateTypes())){
            ArrayList<TeacherManageOperateTypeBind> binds = new ArrayList<>();
            for (TeacherManageAddOperateTypeReqDTO operateType : reqDTO.getOperateTypes()) {
                TeacherManageOperateTypeBind teacherManageOperateTypeBind = new TeacherManageOperateTypeBind();
                BeanUtils.copyProperties(operateType,teacherManageOperateTypeBind);
                teacherManageOperateTypeBind.setDelFlag(DeleteStatusEnum.NO.getStatus());
                teacherManageOperateTypeBind.setTeacherManageId(teacherManage.getId());
                binds.add(teacherManageOperateTypeBind);
            }
            boolean saveBatch = teacherManageOperateTypeBindService.saveBatch(binds);
            if (!saveBatch)
                throw new BusinessException(this.getClass(), ResultConstants.SYSTEM_ERROR_DATABASE_FAIL,"教师工种数据保存失败");
        }
        return AjaxResult.success("新增成功");
    }

    @Override
    @Transactional
    public AjaxResult updateTeacherById(TeacherManageUpdateReqDTO reqDTO) {
        TeacherManage teacherByCode = teacherManageService.getTeacherByCode(reqDTO.getCode());
        if (teacherByCode != null && teacherByCode.getId() != reqDTO.getId())
            throw new BusinessException(this.getClass(),ResultConstants.SYSTEM_ERROR_DATABASE_FAIL,"身份证已存在");
        TeacherManage teacherManage = teacherManageService.getTeacherById(reqDTO.getId());
        BeanUtils.copyProperties(reqDTO,teacherManage,"id");
        boolean save = teacherManageService.updateById(teacherManage);
        if (!save)
            throw new BusinessException(this.getClass(), ResultConstants.SYSTEM_ERROR_DATABASE_FAIL,"教师信息修改失败");
        removeOldTeacherManageOperateTypeBind(reqDTO.getId());
        if (!CollectionUtils.isEmpty(reqDTO.getOperateTypes())){
            ArrayList<TeacherManageOperateTypeBind> binds = new ArrayList<>();
            for (TeacherManageAddOperateTypeReqDTO operateType : reqDTO.getOperateTypes()) {
                TeacherManageOperateTypeBind examinerManageOperateTypeBind = new TeacherManageOperateTypeBind();
                BeanUtils.copyProperties(operateType,examinerManageOperateTypeBind);
                examinerManageOperateTypeBind.setDelFlag(DeleteStatusEnum.NO.getStatus());
                examinerManageOperateTypeBind.setTeacherManageId(teacherManage.getId());
                binds.add(examinerManageOperateTypeBind);
            }
            boolean saveBatch = teacherManageOperateTypeBindService.saveBatch(binds);
            if (!saveBatch)
                throw new BusinessException(this.getClass(), ResultConstants.SYSTEM_ERROR_DATABASE_FAIL,"教师工种数据保存失败");
        }
        return AjaxResult.success("修改成功");
    }

    @Override
    public AjaxResult removeTeacherById(Long id) {
        TeacherManage manage = teacherManageService.getTeacherById(id);
        if (manage == null)
            return AjaxResult.success("删除成功");
        manage.setDelFlag(DeleteStatusEnum.YES.getStatus());
        boolean save = teacherManageService.updateById(manage);
        if (!save)
            throw new BusinessException(this.getClass(), ResultConstants.SYSTEM_ERROR_DATABASE_FAIL,"教师信息删除失败");
        removeOldTeacherManageOperateTypeBind(id);
        return AjaxResult.success("删除成功");
    }

    @Override
    public AjaxResult getTeacherById(Long id) {
        TeacherManage manage = teacherManageService.getTeacherById(id);
        GetTeacherRespDTO dto = getTeacherRespDTO(manage);
        return AjaxResult.success(dto);
    }

    private GetTeacherRespDTO getTeacherRespDTO(TeacherManage manage) {
        GetTeacherRespDTO dto = new GetTeacherRespDTO();
        if (manage == null)
            return null;
        BeanUtils.copyProperties(manage,dto);
        dto.setQaAttachment(getAttachmentInfoById(manage.getQaAttachment()));
        dto.setPhotoAttachment(getAttachmentInfoById(manage.getPhotoAttachment()));
        LambdaQueryWrapper<TeacherManageOperateTypeBind> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(TeacherManageOperateTypeBind::getTeacherManageId,manage.getId())
                .eq(TeacherManageOperateTypeBind::getDelFlag,DeleteStatusEnum.NO.getStatus());
        List<TeacherManageOperateTypeBind> list = teacherManageOperateTypeBindService.list(wrapper);
        if (CollectionUtils.isEmpty(list))
            return dto;
        Boolean flag = redisCache.hasKey(CacheConstants.SYS_OPERATE_TYPE_NAME_KEY);
        if (flag){
            operateTypeService.resetOperateTypeCache();
        }
        List<GetTeacherOperateTypesRespDTO> getTeacherOperateTypesRespDTOS = new ArrayList<>();
        for (TeacherManageOperateTypeBind examinerManageOperateTypeBind : list) {
            GetTeacherOperateTypesRespDTO operateTypesRespDTO = new GetTeacherOperateTypesRespDTO();
            BeanUtils.copyProperties(examinerManageOperateTypeBind,operateTypesRespDTO);
            SysOperateTypeWholeNameBO sysOperateTypeWholeNameBO = operateTypeService.getOperateTypeWholeNameById(examinerManageOperateTypeBind.getOperateTypeId());
            if (sysOperateTypeWholeNameBO != null){
                BeanUtils.copyProperties(sysOperateTypeWholeNameBO,operateTypesRespDTO);
            }
            getTeacherOperateTypesRespDTOS.add(operateTypesRespDTO);
        }
        dto.setOperateTypes(getTeacherOperateTypesRespDTOS);
        return dto;
    }

    @Override
    public List<GetTeacherRespDTO> selectTeacherAll(Integer isCm) {
        startPage();
        LambdaQueryWrapper<TeacherManage> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(TeacherManage::getDelFlag,DeleteStatusEnum.NO.getStatus())
                .eq(TeacherManage::getIsCm,isCm);
        List<TeacherManage> list = teacherManageService.list(wrapper);
        if (CollectionUtils.isEmpty(list))
            return new ArrayList<>();
        List<GetTeacherRespDTO> dtos = new ArrayList<>();
        for (TeacherManage manage : list) {
            GetTeacherRespDTO dto = getTeacherRespDTO(manage);
            dtos.add(dto);
        }
        return dtos;
    }

    @Override
    public List<GetTeacherRespDTO> selectTeacherByCondition(int isCm, Long operateTypeId) {
        if (operateTypeId == null || operateTypeId == 0)
            return selectTeacherAll(isCm);
        LambdaQueryWrapper<TeacherManageOperateTypeBind> wrapper = new LambdaQueryWrapper<>();
        List<TeacherManageOperateTypeBind> teacherManageOperateTypeBinds =
                teacherManageOperateTypeBindService.list(wrapper.eq(TeacherManageOperateTypeBind::getOperateTypeId, operateTypeId)
                        .eq(TeacherManageOperateTypeBind::getDelFlag,DeleteStatusEnum.NO.getStatus()));
        if (CollectionUtils.isEmpty(teacherManageOperateTypeBinds)){
            return new ArrayList<>();
        }
        List<Long> teacherManageIds = teacherManageOperateTypeBinds.stream()
                .map(TeacherManageOperateTypeBind::getTeacherManageId)
                .distinct()
                .collect(Collectors.toList());
        if (CollectionUtils.isEmpty(teacherManageIds))
            return new ArrayList<>();
        startPage();
        LambdaQueryWrapper<TeacherManage> teacherManageWrapper = new LambdaQueryWrapper<>();
        teacherManageWrapper.eq(TeacherManage::getDelFlag,DeleteStatusEnum.NO.getStatus())
                .eq(TeacherManage::getIsCm,isCm)
                .in(TeacherManage::getId,teacherManageIds);
        List<TeacherManage> list = teacherManageService.list(teacherManageWrapper);
        if (CollectionUtils.isEmpty(list))
            return new ArrayList<>();
        List<GetTeacherRespDTO> dtos = new ArrayList<>();
        for (TeacherManage manage : list) {
            GetTeacherRespDTO dto = getTeacherRespDTO(manage);
            dtos.add(dto);
        }
        return dtos;
    }

    @Override
    public AjaxResult updateStatus(TeacherManageUpdateStatusReqDTO reqDTO) {
        TeacherManage manage = teacherManageService.getTeacherById(reqDTO.getId());
        if (manage == null)
            return AjaxResult.success("数据不存在");
        manage.setStatus(reqDTO.getStatus());
        boolean save = teacherManageService.updateById(manage);
        if (!save)
            throw new BusinessException(this.getClass(), ResultConstants.SYSTEM_ERROR_DATABASE_FAIL,"教师状态变更失败");
        return AjaxResult.success("教师状态变更成功");
    }

    @Override
    public AjaxResult updateExaminerStatus(ExaminerManageUpdateStatusReqDTO reqDTO) {
        ExaminerManage manage = examinerManageService.getExaminerById(reqDTO.getId());
        if (manage == null)
            return AjaxResult.success("数据不存在");
        manage.setStatus(reqDTO.getStatus());
        boolean save = examinerManageService.updateById(manage);
        if (!save)
            throw new BusinessException(this.getClass(), ResultConstants.SYSTEM_ERROR_DATABASE_FAIL,"考评员状态变更失败");
        return AjaxResult.success("教师状态变更成功");
    }

    @Override
    public AjaxResult deleteExaminerBindOperateType(Long id) {
        ExaminerManageOperateTypeBind manage = examinerManageOperateTypeBindService.getNoDeleteById(id);
        if (manage == null)
            return AjaxResult.success("数据不存在");
        manage.setDelFlag(DeleteStatusEnum.YES.getStatus());
        boolean save = examinerManageOperateTypeBindService.updateById(manage);
        if (!save)
            throw new BusinessException(this.getClass(), ResultConstants.SYSTEM_ERROR_DATABASE_FAIL,"考评员关联工种删除失败");
        return AjaxResult.success("考评员关联工种删除失败");
    }

    @Override
    public AjaxResult deleteTeacherBindOperateType(Long id) {
        TeacherManageOperateTypeBind manage = teacherManageOperateTypeBindService.getNoDeleteById(id);
        if (manage == null)
            return AjaxResult.success("数据不存在");
        manage.setDelFlag(DeleteStatusEnum.YES.getStatus());
        boolean save = teacherManageOperateTypeBindService.updateById(manage);
        if (!save)
            throw new BusinessException(this.getClass(), ResultConstants.SYSTEM_ERROR_DATABASE_FAIL,"教师关联工种删除失败");
        return AjaxResult.success("教师关联工种删除失败");
    }
}