package com.gkhy.safePlatform.emergency.service.impl;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.gkhy.safePlatform.commons.enums.ResultCodes;
import com.gkhy.safePlatform.commons.query.PageQuery;
import com.gkhy.safePlatform.commons.utils.BeanCopyUtils;
import com.gkhy.safePlatform.commons.vo.ResultVO;
import com.gkhy.safePlatform.commons.vo.SearchResultVO;
import com.gkhy.safePlatform.emergency.entity.*;
import com.gkhy.safePlatform.emergency.enums.EmergencyResultCodes;
import com.gkhy.safePlatform.emergency.excepiton.EmergencyException;
import com.gkhy.safePlatform.emergency.model.dto.req.*;
import com.gkhy.safePlatform.emergency.model.dto.resp.*;
import com.gkhy.safePlatform.emergency.query.EmergencyDrillPlanQuery;
import com.gkhy.safePlatform.emergency.query.db.EmergencyDrillPlanDBQuery;
import com.gkhy.safePlatform.emergency.service.EmergencyDrillPlanService;
import com.gkhy.safePlatform.emergency.service.baseService.*;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

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

@Service("emergencyDrillPlanService")
public class EmergencyDrillPlanServiceImpl implements EmergencyDrillPlanService {

    @Autowired
    private EmergencyDrillPlanInfoService emergencyDrillPlanInfoService;

    @Autowired
    private EmergencyDrillPlanFileInfoService emergencyDrillPlanFileInfoService;

    @Autowired
    private EmergencyDrillPlanUserInfoService emergencyDrillPlanUserInfoService;

    @Autowired
    private EmergencyPlanInfoService emergencyPlanInfoService;


    @Override
    public SearchResultVO<List<EmergencyDrillPlanPageRespDTO>> selectEmergencyDrillPlanList(PageQuery<EmergencyDrillPlanQuery> query) {
        Long pageIndex = query.getPageIndex();
        Long pageSize = query.getPageSize();
        Page<EmergencyDrillPlanInfoPageDO> page = new Page<>(pageIndex, pageSize);

        EmergencyDrillPlanDBQuery emergencyDrillPlanDBQuery = new EmergencyDrillPlanDBQuery();
        if (query.getSearchParams() != null) {
            BeanUtils.copyProperties(query.getSearchParams(), emergencyDrillPlanDBQuery);
        }
        List<EmergencyDrillPlanInfoPageDO> emergencyDrillPlanListDoInfoList = emergencyDrillPlanInfoService.selectEmergencyDrillPlanList(page, emergencyDrillPlanDBQuery);
        List<EmergencyDrillPlanPageRespDTO> respList = BeanCopyUtils.copyBeanList(emergencyDrillPlanListDoInfoList, EmergencyDrillPlanPageRespDTO.class);

        return new SearchResultVO<>(
                true,
                pageIndex,
                pageSize,page.getPages(),
                page.getTotal(),
                respList,
                ResultCodes.OK
        );
    }

    @Override
    public ResultVO addEmergencyDrillPlan(Long uid, EmergencyDrillPlanReqDTO emergencyDrillPlanReqDTO) {
        // 判断请求中是否存在应急预案id
        if (emergencyDrillPlanReqDTO.getPlanId() == null) {
            throw new EmergencyException(EmergencyResultCodes.PLAN_NULL);
        } else {
            EmergencyPlanInfoDetailDO emergencyPlanInfoDetailDO = emergencyPlanInfoService.selectEmergencyPlanById(emergencyDrillPlanReqDTO.getPlanId());
            // 判断是否存在该应急预案
            if (emergencyPlanInfoDetailDO == null) {
                throw new EmergencyException(EmergencyResultCodes.PLAN_NOT_EXIST);
            } else {
                Date nowDate = new Date();
                // 新增应急演练计划
                EmergencyDrillPlanInfo emergencyDrillPlanInfo = new EmergencyDrillPlanInfo();
                BeanUtils.copyProperties(emergencyDrillPlanReqDTO, emergencyDrillPlanInfo);
                emergencyDrillPlanInfo.setDelFlag(false);
                emergencyDrillPlanInfo.setCreateUid(uid);
                emergencyDrillPlanInfo.setGmtCreate(nowDate);
                emergencyDrillPlanInfoService.addEmergencyDrillPlan(emergencyDrillPlanInfo);
                // 新增急演练计划附件表
                if (!CollectionUtils.isEmpty(emergencyDrillPlanReqDTO.getFileList())) {
                    addEmergencyDrillPlanFile(uid, emergencyDrillPlanInfo.getId(), nowDate, emergencyDrillPlanReqDTO.getFileList());
                }
                // 新增急演练计划应急人员表
                if (!CollectionUtils.isEmpty(emergencyDrillPlanReqDTO.getUserList())) {
                    addEmergencyDrillPlanUser(uid, emergencyDrillPlanInfo.getId(), nowDate, emergencyDrillPlanReqDTO.getUserList());

                }
                return new ResultVO<>(ResultCodes.OK);
            }
        }
    }

    private void addEmergencyDrillPlanFile(Long uid, Long DrillPlanId, Date nowDate, List<EmergencyDrillPlanFileReqDTO> emergencyDrillPlanFileReqDTOList) {
        List<EmergencyDrillPlanFileInfo> emergencyDrillPlanFileInfoList = BeanCopyUtils.copyBeanList(emergencyDrillPlanFileReqDTOList, EmergencyDrillPlanFileInfo.class);
        emergencyDrillPlanFileInfoList.forEach(EmergencyDrillPlanFileInfo -> {
            EmergencyDrillPlanFileInfo.setDelFlag(false);
            EmergencyDrillPlanFileInfo.setCreateUid(uid);
            EmergencyDrillPlanFileInfo.setGmtCreate(nowDate);
            EmergencyDrillPlanFileInfo.setDrillPlanId(DrillPlanId);
        });
        for (EmergencyDrillPlanFileInfo emergencyDrillPlanFileInfo : emergencyDrillPlanFileInfoList) {
            emergencyDrillPlanFileInfoService.addEmergencyDrillPlanFile(emergencyDrillPlanFileInfo);
        }
    }

    private void addEmergencyDrillPlanUser(Long uid, Long DrillPlanId, Date nowDate, List<EmergencyDrillPlanUserReqDTO> emergencyDrillPlanUserReqDTOList) {
        List<EmergencyDrillPlanUserInfo> emergencyDrillPlanUserInfoList = BeanCopyUtils.copyBeanList(emergencyDrillPlanUserReqDTOList, EmergencyDrillPlanUserInfo.class);
        emergencyDrillPlanUserInfoList.forEach(EmergencyDrillPlanUserInfo -> {
            EmergencyDrillPlanUserInfo.setDelFlag(false);
            EmergencyDrillPlanUserInfo.setCreateUid(uid);
            EmergencyDrillPlanUserInfo.setGmtCreate(nowDate);
            EmergencyDrillPlanUserInfo.setDrillPlanId(DrillPlanId);
        });
        for (EmergencyDrillPlanUserInfo emergencyDrillPlanUserInfo : emergencyDrillPlanUserInfoList) {
            emergencyDrillPlanUserInfoService.addEmergencyDrillPlanUser(emergencyDrillPlanUserInfo);
        }
    }

    @Override
    public ResultVO<EmergencyDrillPlanDetailRespDTO> getEmergencyDrillPlanById(Long id) {
        EmergencyDrillPlanDetailRespDTO emergencyDrillPlanDetailRespDTO = new EmergencyDrillPlanDetailRespDTO();
        // 查询是否存在
        EmergencyDrillPlanInfoDetailDO emergencyDrillPlanInfoDetailDO = emergencyDrillPlanInfoService.selectEmergencyDrillPlanById(id);
        if (emergencyDrillPlanInfoDetailDO == null) {
            throw new EmergencyException(EmergencyResultCodes.DRILL_PLAN_NOT_EXIST);
        } else {
            BeanUtils.copyProperties(emergencyDrillPlanInfoDetailDO, emergencyDrillPlanDetailRespDTO);

            // 查找对应的人员
            List<EmergencyDrillPlanUserInfoDO> emergencyDrillPlanUserInfoDOList = emergencyDrillPlanUserInfoService.selectEmergencyDrillPlanUserByDrillPlanId(id);
            if (!CollectionUtils.isEmpty(emergencyDrillPlanUserInfoDOList)) {
                List<EmergencyDrillPlanUserRespDTO> emergencyUserUserRespDTOList = BeanCopyUtils.copyBeanList(emergencyDrillPlanUserInfoDOList, EmergencyDrillPlanUserRespDTO.class);

                List<EmergencyDrillPlanUserRespDTO> userList = emergencyUserUserRespDTOList.stream().filter(user -> user.getType()==1).collect(Collectors.toList());
                List<EmergencyDrillPlanUserRespDTO> chargeUserList = emergencyUserUserRespDTOList.stream().filter(user -> user.getType()==2).collect(Collectors.toList());

                emergencyDrillPlanDetailRespDTO.setUserList(userList);
                emergencyDrillPlanDetailRespDTO.setChargeUserList(chargeUserList);
            }
            // 查找对应的附件
            List<EmergencyDrillPlanFileInfoDO> emergencyDrillPlanFileInfoDOList = emergencyDrillPlanFileInfoService.selectEmergencyDrillPlanFileByDrillPlanId(id);
            if (!CollectionUtils.isEmpty(emergencyDrillPlanFileInfoDOList)) {
                List<EmergencyDrillPlanFileRespDTO> emergencyUserFileRespDTOList = BeanCopyUtils.copyBeanList(emergencyDrillPlanFileInfoDOList, EmergencyDrillPlanFileRespDTO.class);
                emergencyDrillPlanDetailRespDTO.setFileList(emergencyUserFileRespDTOList);
            }
            return new ResultVO<>(ResultCodes.OK, emergencyDrillPlanDetailRespDTO);
        }
    }

    @Override
    public ResultVO updateEmergencyDrillPlan(Long uid, EmergencyDrillPlanReqDTO emergencyDrillPlanReqDTO) {
        Date nowDate = new Date();
        // 查询是否存在
        EmergencyDrillPlanInfoDetailDO emergencyDrillPlanInfoDetailDO = emergencyDrillPlanInfoService.selectEmergencyDrillPlanById(emergencyDrillPlanReqDTO.getId());
        if (emergencyDrillPlanInfoDetailDO == null) {
            throw new EmergencyException(EmergencyResultCodes.DRILL_PLAN_NOT_EXIST);
        } else {
            EmergencyDrillPlanInfo emergencyDrillPlanInfo = new EmergencyDrillPlanInfo();
            BeanUtils.copyProperties(emergencyDrillPlanReqDTO, emergencyDrillPlanInfo);
            emergencyDrillPlanInfo.setUpdateUid(uid);
            emergencyDrillPlanInfo.setGmtModitify(nowDate);
            emergencyDrillPlanInfoService.updateEmergencyDrillPlan(emergencyDrillPlanInfo);

            // 更新急演练计划附件表
            if (!CollectionUtils.isEmpty(emergencyDrillPlanReqDTO.getFileList())) {
                updateEmergencyDrillPlanFile(uid, emergencyDrillPlanInfo.getId(), nowDate, emergencyDrillPlanReqDTO.getFileList());
            }
            // 更新急演练计划应急人员表
            if (!CollectionUtils.isEmpty(emergencyDrillPlanReqDTO.getUserList())) {
                updateEmergencyDrillPlanUser(uid, emergencyDrillPlanInfo.getId(), nowDate, emergencyDrillPlanReqDTO.getUserList());
            }

            return new ResultVO<>(ResultCodes.OK);
        }
    }

    private void updateEmergencyDrillPlanFile(Long uid, Long DrillPlanId, Date
            nowDate, List<EmergencyDrillPlanFileReqDTO> fileReqDTOList) {
        List<EmergencyDrillPlanFileInfoDO> emergencyDrillPlanFileInfoDOList = emergencyDrillPlanFileInfoService.selectEmergencyDrillPlanFileByDrillPlanId(DrillPlanId);
        List<Long> oldIdsList = emergencyDrillPlanFileInfoDOList.stream().map(EmergencyDrillPlanFileInfoDO::getId).collect(Collectors.toList());
        List<Long> newIdsList = new ArrayList<>();

        //新增的区域集合
        List<EmergencyDrillPlanFileInfo> addList = new ArrayList<>();
        //删除的区域集合(id)
        List<Long> deleteList = new ArrayList<>();
        for (EmergencyDrillPlanFileReqDTO emergencyDrillPlanFileReqDTO : fileReqDTOList) {
            //如果不存在id则表示页面新增的附件
            if (emergencyDrillPlanFileReqDTO.getId() == null) {
                EmergencyDrillPlanFileInfo emergencyDrillPlanFileInfo = new EmergencyDrillPlanFileInfo();
                BeanUtils.copyProperties(emergencyDrillPlanFileReqDTO, emergencyDrillPlanFileInfo);
                emergencyDrillPlanFileInfo.setDelFlag(false);
                emergencyDrillPlanFileInfo.setGmtCreate(nowDate);
                emergencyDrillPlanFileInfo.setCreateUid(uid);
                emergencyDrillPlanFileInfo.setDrillPlanId(DrillPlanId);
                addList.add(emergencyDrillPlanFileInfo);
            }
            //如果存在id则判断页面是否删除
            else {
                newIdsList.add(emergencyDrillPlanFileReqDTO.getId());
            }
        }
        for (Long oldId : oldIdsList) {
            if (!newIdsList.contains(oldId)) {
                deleteList.add(oldId);
            }
        }
        if (!CollectionUtils.isEmpty(addList)) {
            for (EmergencyDrillPlanFileInfo emergencyDrillPlanFileInfo : addList) {
                emergencyDrillPlanFileInfoService.addEmergencyDrillPlanFile(emergencyDrillPlanFileInfo);
            }
        }
        if (!CollectionUtils.isEmpty(deleteList)) {
            emergencyDrillPlanFileInfoService.deleteEmergencyDrillPlanFileByIds(deleteList);
        }
    }

    private void updateEmergencyDrillPlanUser(Long uid, Long DrillPlanId, Date
            nowDate, List<EmergencyDrillPlanUserReqDTO> UserReqDTOList) {
        List<EmergencyDrillPlanUserInfoDO> emergencyDrillPlanUserInfoDOList = emergencyDrillPlanUserInfoService.selectEmergencyDrillPlanUserByDrillPlanId(DrillPlanId);
        List<Long> oldIdsList = emergencyDrillPlanUserInfoDOList.stream().map(EmergencyDrillPlanUserInfoDO::getId).collect(Collectors.toList());
        List<Long> newIdsList = new ArrayList<>();

        //新增的区域集合
        List<EmergencyDrillPlanUserInfo> addList = new ArrayList<>();
        //删除的区域集合(id)
        List<Long> deleteList = new ArrayList<>();
        for (EmergencyDrillPlanUserReqDTO emergencyDrillPlanUserReqDTO : UserReqDTOList) {
            //如果不存在id则表示页面新增的附件
            if (emergencyDrillPlanUserReqDTO.getId() == null) {
                EmergencyDrillPlanUserInfo emergencyDrillPlanUserInfo = new EmergencyDrillPlanUserInfo();
                BeanUtils.copyProperties(emergencyDrillPlanUserReqDTO, emergencyDrillPlanUserInfo);
                emergencyDrillPlanUserInfo.setDelFlag(false);
                emergencyDrillPlanUserInfo.setGmtCreate(nowDate);
                emergencyDrillPlanUserInfo.setCreateUid(uid);
                emergencyDrillPlanUserInfo.setDrillPlanId(DrillPlanId);
                addList.add(emergencyDrillPlanUserInfo);
            }
            //如果存在id则判断页面是否删除
            else {
                newIdsList.add(emergencyDrillPlanUserReqDTO.getId());
            }
        }
        for (Long oldId : oldIdsList) {
            if (!newIdsList.contains(oldId)) {
                deleteList.add(oldId);
            }
        }
        if (!CollectionUtils.isEmpty(addList)) {
            for (EmergencyDrillPlanUserInfo emergencyDrillPlanUserInfo : addList) {
                emergencyDrillPlanUserInfoService.addEmergencyDrillPlanUser(emergencyDrillPlanUserInfo);
            }
        }
        if (!CollectionUtils.isEmpty(deleteList)) {
            emergencyDrillPlanUserInfoService.deleteEmergencyDrillPlanUserByIds(deleteList);
        }
    }

    @Override
    public ResultVO batchDeleteEmergencyDrillPlan(Long[] ids) {

        if (ids == null ||  ids.length==0){
            throw new EmergencyException(EmergencyResultCodes.DRILL_PLAN_NULL);
        }else{
            for (Long id : ids){
                deleteEmergencyDrillPlan(id);
            }
            return new ResultVO(ResultCodes.OK);
        }
    }

    private void deleteEmergencyDrillPlan(Long id) {
        //查询是否存在
        EmergencyDrillPlanInfoDetailDO emergencyDrillPlanInfoDetailDO = emergencyDrillPlanInfoService.selectEmergencyDrillPlanById(id);
        if (emergencyDrillPlanInfoDetailDO == null) {
            throw new EmergencyException(EmergencyResultCodes.DRILL_PLAN_NOT_EXIST);
        } else {
            Long DrillPlanId = emergencyDrillPlanInfoDetailDO.getId();
            emergencyDrillPlanInfoService.deleteEmergencyDrillPlan(DrillPlanId);
            //删除附件
            emergencyDrillPlanFileInfoService.deleteEmergencyDrillPlanFileByDrillPlanId(DrillPlanId);
            //删除人员
            emergencyDrillPlanUserInfoService.deleteEmergencyDrillPlanUserByDrillPlanId(DrillPlanId);
        }
    }
}