package org.jeecg.modules.mdc.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang.StringUtils;
import org.jeecg.modules.mdc.entity.MdcEquipment;
import org.jeecg.modules.mdc.entity.MdcEquipmentRepair;
import org.jeecg.modules.mdc.mapper.MdcEquipmentRepairMapper;
import org.jeecg.modules.mdc.service.IMdcEquipmentRepairService;
import org.jeecg.modules.mdc.service.IMdcEquipmentService;
import org.jeecg.modules.mdc.util.DateUtils;
import org.jeecg.modules.mdc.vo.MdcEquipmentRepairVo;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @Description: 设备维修休班
 * @Author: Sake
 * @Date: 2023-04-06 16:53
 */
@Service
public class MdcEquipmentRepairServiceImpl extends ServiceImpl<MdcEquipmentRepairMapper, MdcEquipmentRepair> implements IMdcEquipmentRepairService {

    @Resource
    private IMdcEquipmentService mdcEquipmentService;

    @Override
    public boolean addMdcRepair(MdcEquipmentRepairVo repairVo) {
        boolean result = false;
        String[] equipmentIds = repairVo.getEquipmentIds().split(",");
        List<MdcEquipmentRepair> mdcEquipmentRepairList = new ArrayList<>();
        a:
        for (String equipmentId : equipmentIds) {
            Date startTime = DateUtils.getFormatDate(repairVo.getStartTime(), DateUtils.STR_DATE_TIME_SMALL);
            Date endTime = DateUtils.getFormatDate(repairVo.getEndTime(), DateUtils.STR_DATE_TIME_SMALL);
            MdcEquipment mdcEquipment = mdcEquipmentService.findEquipmentNameByEquipmentId(equipmentId);
            //根据设备id查询此设备所有维修和休班记录
            LambdaQueryWrapper<MdcEquipmentRepair> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(MdcEquipmentRepair::getEquipmentId, equipmentId);
            queryWrapper.orderByAsc(MdcEquipmentRepair::getStartTime);
            List<MdcEquipmentRepair> mdcEquipmentRepairs = this.baseMapper.selectList(queryWrapper);
            if (mdcEquipmentRepairs != null && !mdcEquipmentRepairs.isEmpty()) {
                for (MdcEquipmentRepair mdcEquipmentRepair : mdcEquipmentRepairs) {
                    if (startTime.before(mdcEquipmentRepair.getStartTime())) {
                        //开始时间在记录开始时间之前
                        if (endTime.after(mdcEquipmentRepair.getStartTime())) {
                            //结束时间在记录开始时间之后
                            if (endTime.before(mdcEquipmentRepair.getEndTime())) {
                                //结束时间在记录结束时间之前 -> 修改结束时间为记录开始时间
                                endTime = mdcEquipmentRepair.getStartTime();
                            } else {
                                //结束时间在记录结束时间之后 -> 切割为两段时间 前一段时间一定唯一，后一段时间赋值重新比较
                                //保存第一段记录
                                MdcEquipmentRepair mdc = new MdcEquipmentRepair();
                                mdc.setStartTime(startTime);
                                mdc.setEndTime(mdcEquipmentRepair.getStartTime());
                                mdc.setMdcRepairType(repairVo.getMdcRepairType());
                                mdc.setEquipmentId(equipmentId);
                                if (mdcEquipment != null && mdcEquipment.getEquipmentName() != null) {
                                    mdc.setEquipmentName(mdcEquipment.getEquipmentName());
                                }
                                if(repairVo.getMdcRepairType().equals(1)){
                                    mdc.setMdcRepairTypeDictText("维修");
                                } else {
                                    mdc.setMdcRepairTypeDictText("休班");
                                }

                                mdcEquipmentRepairList.add(mdc);
                                //第二段时间赋值给
                                startTime = mdcEquipmentRepair.getEndTime();
                            }
                        }
                    } else {
                        //开始时间在记录开始时间之后
                        if (startTime.before(mdcEquipmentRepair.getEndTime())) {
                            //开始时间在记录结束时间之前
                            if (endTime.before(mdcEquipmentRepair.getEndTime())) {
                                //结束时间在记录结束时间之前 -> 时间重叠
                                continue a;
                            } else {
                                //结束时间在记录结束时间之后 -> 修改开始时间为记录结束时间
                                startTime = mdcEquipmentRepair.getEndTime();
                            }
                        }
                    }
                }
                MdcEquipmentRepair mdc = new MdcEquipmentRepair();
                mdc.setStartTime(startTime);
                mdc.setEndTime(endTime);
                mdc.setMdcRepairType(repairVo.getMdcRepairType());
                mdc.setEquipmentId(equipmentId);
                mdc.setEquipmentName(mdcEquipment.getEquipmentName());
                if(repairVo.getMdcRepairType().equals(1)){
                    mdc.setMdcRepairTypeDictText("维修");
                } else {
                    mdc.setMdcRepairTypeDictText("休班");
                }
                mdcEquipmentRepairList.add(mdc);
                //过滤
                mdcEquipmentRepairList = mdcEquipmentRepairList.stream().filter(mdcEquipmentRepair -> !mdcEquipmentRepair.getEndTime().equals(mdcEquipmentRepair.getStartTime())).collect(Collectors.toList());
                boolean b = super.saveBatch(mdcEquipmentRepairList);
                if (b) {
                    result = true;
                }
                mdcEquipmentRepairList.clear();
            } else {
                //表中无记录则正常添加
                MdcEquipmentRepair mdc = new MdcEquipmentRepair();
                mdc.setStartTime(startTime);
                mdc.setEndTime(endTime);
                mdc.setMdcRepairType(repairVo.getMdcRepairType());
                mdc.setEquipmentId(equipmentId);
                mdc.setEquipmentName(mdcEquipment.getEquipmentName());
                if(repairVo.getMdcRepairType().equals(1)){
                    mdc.setMdcRepairTypeDictText("维修");
                } else {
                    mdc.setMdcRepairTypeDictText("休班");
                }
                boolean b = super.save(mdc);
                if (b) {
                    result = true;
                }
            }
        }
        return result;
    }

    @Override
    public IPage<MdcEquipmentRepair> pageList(String userId, Page page, MdcEquipmentRepair repair, HttpServletRequest req) {
        List<String> equipmentIds = new ArrayList<>();
        if (StringUtils.isNotEmpty(repair.getParentId()) && StringUtils.isEmpty(repair.getEquipmentId())) {
            if ("2".equals(repair.getTypeTree())) {
                //部门层级
                equipmentIds = mdcEquipmentService.getEquipmentIdsByDepart(userId, repair.getParentId());
            } else {
                //产线层级
                equipmentIds = mdcEquipmentService.getEquipmentIdsProduction(userId, repair.getParentId());
            }
        } else if (StringUtils.isNotEmpty(repair.getEquipmentId())) {
            //单台设备信息
            repair.setMdcSectionIds(Collections.singletonList(repair.getEquipmentId()));
        } else {
            //查询用户拥有的所有设备信息
            if ("2".equals(repair.getTypeTree())) {
                //部门层级
                equipmentIds = mdcEquipmentService.getEquipmentIdsByDepart(userId, null);
            } else {
                //产线层级
                equipmentIds = mdcEquipmentService.getEquipmentIdsProduction(userId, null);
            }
        }

        if (repair.getMdcSectionIds() == null || repair.getMdcSectionIds().isEmpty()) {
            repair.setMdcSectionIds(equipmentIds);
        }

        if (repair.getMdcSectionIds() == null || repair.getMdcSectionIds().isEmpty()) {
            return null;
        }

        return this.baseMapper.pageList(page, repair);
    }

    @Override
    public boolean updateMdcRepair(MdcEquipmentRepair repair) {
        boolean result = false;
        LambdaQueryWrapper<MdcEquipmentRepair> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(MdcEquipmentRepair::getEquipmentId, repair.getEquipmentId());
        queryWrapper.orderByAsc(MdcEquipmentRepair::getStartTime);
        queryWrapper.ne(MdcEquipmentRepair::getId, repair.getId());
        List<MdcEquipmentRepair> mdcEquipmentRepairs = this.baseMapper.selectList(queryWrapper);
        List<MdcEquipmentRepair> mdcEquipmentRepairList = new ArrayList<>();
        if (mdcEquipmentRepairs != null && !mdcEquipmentRepairs.isEmpty()) {
            Date startTime = repair.getStartTime();
            Date endTime = repair.getEndTime();
            for (MdcEquipmentRepair mdcEquipmentRepair : mdcEquipmentRepairs) {
                if (startTime.before(mdcEquipmentRepair.getStartTime())) {
                    //开始时间在记录开始时间之前
                    if (endTime.after(mdcEquipmentRepair.getStartTime())) {
                        //结束时间在记录开始时间之后
                        if (endTime.before(mdcEquipmentRepair.getEndTime())) {
                            //结束时间在记录结束时间之前 -> 修改结束时间为记录开始时间
                            endTime = mdcEquipmentRepair.getStartTime();
                        } else {
                            //结束时间在记录结束时间之后 -> 切割为两段时间 前一段时间一定唯一，后一段时间赋值重新比较
                            //保存第一段记录
                            MdcEquipmentRepair mdc = new MdcEquipmentRepair();
                            mdc.setStartTime(startTime);
                            mdc.setEndTime(mdcEquipmentRepair.getStartTime());
                            mdc.setMdcRepairType(repair.getMdcRepairType());
                            mdc.setEquipmentId(repair.getEquipmentId());
                            mdc.setEquipmentName(repair.getEquipmentName());
                            mdcEquipmentRepairList.add(mdc);
                            //第二段时间赋值给
                            startTime = mdcEquipmentRepair.getEndTime();
                        }
                    }
                } else {
                    //开始时间在记录开始时间之后
                    if (startTime.before(mdcEquipmentRepair.getEndTime())) {
                        //开始时间在记录结束时间之前
                        if (endTime.before(mdcEquipmentRepair.getEndTime())) {
                            break;
                        } else {
                            //结束时间在记录结束时间之后 -> 修改开始时间为记录结束时间
                            startTime = mdcEquipmentRepair.getEndTime();
                        }
                    }
                }
            }
            if (!mdcEquipmentRepairList.isEmpty()) {
                Date finalStartTime = startTime;
                Date finalEndTime = endTime;
                mdcEquipmentRepairList = mdcEquipmentRepairList.stream().filter(mdcEquipmentRepair ->
                        !mdcEquipmentRepair.getEndTime().equals(mdcEquipmentRepair.getStartTime())
                                && (!mdcEquipmentRepair.getStartTime().equals(finalStartTime) && !mdcEquipmentRepair.getEndTime().equals(finalEndTime))).collect(Collectors.toList());
                result = super.saveBatch(mdcEquipmentRepairList);
            }
            if (!startTime.equals(endTime)) {
                repair.setStartTime(startTime);
                repair.setEndTime(endTime);
                result = super.updateById(repair);
            } else if (!mdcEquipmentRepairList.isEmpty()) {
                result = super.removeById(repair);
            } else {
                return false;
            }
        } else {
            //无其他记录， 可直接修改
            result = super.updateById(repair);
        }

        return result;
    }

    @Override
    public List<MdcEquipmentRepair> mdcRepairListDate(String equipmentid, Date startDate, Date endDate) {
        return this.baseMapper.selectByIdAndTime(equipmentid, startDate, endDate);
    }

}