package com.mes.bigstorage.service.impl;

import cn.hutool.core.lang.Assert;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.github.yulichang.toolkit.JoinWrappers;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.mes.bigstorage.entity.BigStorageCage;
import com.mes.bigstorage.entity.BigStorageCageDetails;
import com.mes.bigstorage.entity.BigStorageDTO;
import com.mes.bigstorage.entity.dto.SlotSequenceDTO;
import com.mes.bigstorage.entity.dto.TemperingLayoutDTO;
import com.mes.bigstorage.mapper.BigStorageCageDetailsMapper;
import com.mes.bigstorage.service.BigStorageCageDetailsService;
import com.mes.bigstorage.service.BigStorageCageService;
import com.mes.bigstoragetask.entity.BigStorageCageFeedTask;
import com.mes.bigstoragetask.entity.BigStorageCageOutTask;
import com.mes.bigstoragetask.entity.UpdateBigStorageCageDTO;
import com.mes.bigstoragetask.mapper.BigStorageCageFeedTaskMapper;
import com.mes.bigstoragetask.mapper.BigStorageCageOutTaskMapper;
import com.mes.common.config.Const;
import com.mes.damage.entity.Damage;
import com.mes.damage.service.DamageService;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.mapper.GlassInfoMapper;
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.mapper.TemperingGlassInfoMapper;
import com.mes.temperingglass.service.TemperingGlassInfoService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

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

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author zhoush
 * @since 2024-03-27
 */
@Service
public class BigStorageCageDetailsServiceImpl extends MPJBaseServiceImpl<BigStorageCageDetailsMapper, BigStorageCageDetails> implements BigStorageCageDetailsService {

    @Resource
    private BigStorageCageOutTaskMapper bigStorageCageOutTaskMapper;
    @Resource
    private BigStorageCageFeedTaskMapper bigStorageCageFeedTaskMapper;
    @Resource
    private TemperingGlassInfoMapper temperingGlassInfoMapper;
    @Resource
    private BigStorageCageService bigStorageCageService;
    @Resource
    private GlassInfoMapper glassInfoMapper;

    @Resource
    private GlassInfoService glassInfoService;

    @Resource
    private TemperingGlassInfoService temperingGlassInfoService;

    @Resource
    private DamageService damageService;

    @Value("${mes.minCount}")
    private int minCount;

    @Value("${mes.slotWidth}")
    private Integer slotWidth;

    @Value("${mes.glassGap}")
    private Integer glassGap;

    @Value("${mes.sequence.order}")
    private boolean sequenceOrder;

    /**
     * 查询进/出片任务
     */
    @Override
    public List<BigStorageCageDetails> selectTask(int taskType) {
        if (taskType == 1) {
            //进片任务数据
            LambdaQueryWrapper<BigStorageCageDetails> feedWrapper = new LambdaQueryWrapper<>();
            feedWrapper.eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN);
            List<BigStorageCageDetails> bigStorageCageDetailsList = baseMapper.selectList(feedWrapper);

            LambdaQueryWrapper<BigStorageCageFeedTask> feedTaskWrapper = new LambdaQueryWrapper<>();
            feedTaskWrapper
                    .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
                    .isNotNull(BigStorageCageFeedTask::getTargetSlot);
            List<BigStorageCageFeedTask> bigStorageCageFeedTaskList = bigStorageCageFeedTaskMapper.selectList(feedTaskWrapper);

            Map<String, BigStorageCageFeedTask> listMap = bigStorageCageFeedTaskList.stream()
                    .collect(Collectors.toMap(BigStorageCageFeedTask::getGlassId, task -> task));
            Iterator<BigStorageCageDetails> iterator = bigStorageCageDetailsList.iterator();
            while (iterator.hasNext()) {
                BigStorageCageDetails bigStorageCageDetails = iterator.next();
                BigStorageCageFeedTask bigStorageCageFeedTask = listMap.get(bigStorageCageDetails.getGlassId());
                bigStorageCageDetails.setBigStorageCageFeedTask(bigStorageCageFeedTask);
                if (bigStorageCageDetails.getBigStorageCageFeedTask() == null) {
                    iterator.remove();
                }
            }
            LambdaQueryWrapper<BigStorageCageFeedTask> feedTaskNoTargetWrapper = new LambdaQueryWrapper<>();
            feedTaskNoTargetWrapper
                    .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
                    .isNull(BigStorageCageFeedTask::getTargetSlot);
            List<BigStorageCageFeedTask> bigStorageCageFeedTaskNoTargetList = bigStorageCageFeedTaskMapper.selectList(feedTaskNoTargetWrapper);
            for (BigStorageCageFeedTask bigStorageCageFeedTask : bigStorageCageFeedTaskNoTargetList
            ) {
                BigStorageCageDetails bigStorageCageDetails = new BigStorageCageDetails();
                LambdaQueryWrapper<GlassInfo> glassInfoWrapper = new LambdaQueryWrapper<>();
                glassInfoWrapper.eq(GlassInfo::getGlassId, bigStorageCageFeedTask.getGlassId());
                GlassInfo glassInfo = glassInfoMapper.selectOne(glassInfoWrapper);
                BeanUtils.copyProperties(glassInfo, bigStorageCageDetails);
                bigStorageCageDetails.setBigStorageCageFeedTask(bigStorageCageFeedTask);
                bigStorageCageDetailsList.add(bigStorageCageDetails);
            }
            return bigStorageCageDetailsList;
        } else {
            //出片任务数据
            LambdaQueryWrapper<BigStorageCageDetails> outWrapper = new LambdaQueryWrapper<>();
            outWrapper.eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN);
            List<BigStorageCageDetails> bigStorageCageDetailsList = baseMapper.selectList(outWrapper);

            LambdaQueryWrapper<BigStorageCageOutTask> outTaskWrapper = new LambdaQueryWrapper<>();
            outTaskWrapper.lt(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_SUCCESS);
            List<BigStorageCageOutTask> bigStorageCageOutTaskList = bigStorageCageOutTaskMapper.selectList(outTaskWrapper);

            Map<String, BigStorageCageOutTask> listMap = bigStorageCageOutTaskList.stream()
                    .collect(Collectors.toMap(BigStorageCageOutTask::getGlassId, task -> task));
            for (BigStorageCageDetails bigStorageCageDetails : bigStorageCageDetailsList) {
                BigStorageCageOutTask bigStorageCageOutTask = listMap.get(bigStorageCageDetails.getGlassId());
                bigStorageCageDetails.setBigStorageCageOutTask(bigStorageCageOutTask);
            }
            Iterator<BigStorageCageDetails> iterator = bigStorageCageDetailsList.iterator();
            while (iterator.hasNext()) {
                BigStorageCageDetails bigStorageCageDetails = iterator.next();
                BigStorageCageOutTask bigStorageCageOutTask = listMap.get(bigStorageCageDetails.getGlassId());
                bigStorageCageDetails.setBigStorageCageOutTask(bigStorageCageOutTask);
                if (bigStorageCageDetails.getBigStorageCageOutTask() == null) {
                    iterator.remove();
                }
            }
            return bigStorageCageDetailsList;
        }
    }

    /**
     * 判断当前玻璃是否能上车
     */
    @Override
    public double selectGetBoard(String plcFeedReqLine) {
        double carWidth = 5000;
        LambdaQueryWrapper<BigStorageCageDetails> feedWrapper = new LambdaQueryWrapper<>();
        feedWrapper.eq(BigStorageCageDetails::getState, plcFeedReqLine);
        List<BigStorageCageDetails> bigStorageCageDetailsList = baseMapper.selectList(feedWrapper);

        LambdaQueryWrapper<BigStorageCageFeedTask> bigStorageCageFeedTaskWrapper = new LambdaQueryWrapper<>();
        bigStorageCageFeedTaskWrapper
                .eq(BigStorageCageFeedTask::getTaskState, plcFeedReqLine)
                .eq(BigStorageCageFeedTask::getLine, plcFeedReqLine);

        List<BigStorageCageFeedTask> bigStorageCageFeedTaskList = bigStorageCageFeedTaskMapper.selectList(bigStorageCageFeedTaskWrapper);
        Map<String, BigStorageCageFeedTask> listMap = bigStorageCageFeedTaskList.stream()
                .collect(Collectors.toMap(BigStorageCageFeedTask::getGlassId, task -> task));
        for (BigStorageCageDetails bigStorageCageDetails : bigStorageCageDetailsList) {
            BigStorageCageFeedTask bigStorageCageFeedTask = listMap.get(bigStorageCageDetails.getGlassId());
            bigStorageCageDetails.setBigStorageCageFeedTask(bigStorageCageFeedTask);
        }
        for (BigStorageCageDetails bigStorageCageDetails : bigStorageCageDetailsList
        ) {
            if (bigStorageCageDetails.getBigStorageCageFeedTask().getTaskState() == 0) {
                carWidth = carWidth - bigStorageCageDetails.getWidth() - glassGap;
            }
        }
        return carWidth;

    }


    //栓除出片任务.更新格子宽度
    @Override
    public void deleteBigStorageCageDetails(BigStorageCageDetails bigStorageCageDetails) {
        baseMapper.deleteById(bigStorageCageDetails.getId());
        bigStorageCageService.updateRemainWidth(bigStorageCageDetails.getSlot());
    }

    //理片笼详情破损
    @Override
    public void damageBigStorageCageDetails(String glassId, int status) {

        LambdaQueryWrapper<TemperingGlassInfo> temperingGlassInfoWrapper = new LambdaQueryWrapper<>();
        temperingGlassInfoWrapper.eq(TemperingGlassInfo::getGlassId, glassId);
        TemperingGlassInfo temperingGlassInfo = temperingGlassInfoMapper.selectOne(temperingGlassInfoWrapper);

        LambdaQueryWrapper<BigStorageCageDetails> bigStorageCageDetailsWrapper = new LambdaQueryWrapper<>();
        bigStorageCageDetailsWrapper.eq(BigStorageCageDetails::getGlassId, glassId);
        BigStorageCageDetails bigStorageCageDetails = baseMapper.selectOne(bigStorageCageDetailsWrapper);

        if (temperingGlassInfo != null) {
            if (status == 0) {
                temperingGlassInfo.setState(Const.TEMPERING_DAMAGE);
            } else {
                temperingGlassInfo.setState(Const.TEMPERING_TAKE);
            }
            temperingGlassInfoMapper.updateById(temperingGlassInfo);
        }
        if (status == 0) {
            bigStorageCageDetails.setState(Const.GLASS_STATE_DAMAGE);
        } else {
            bigStorageCageDetails.setState(Const.GLASS_STATE_TAKE);
        }
        baseMapper.updateById(bigStorageCageDetails);
        bigStorageCageService.updateRemainWidth(bigStorageCageDetails.getSlot());
        //todo:插入破损数据
        Damage damage = new Damage();
        damage.setGlassId(bigStorageCageDetails.getGlassId());
        damage.setWorkingProcedure("冷加工");
        damage.setRemark("大理片笼破损");
        damage.setStatus(2);
        damageService.insertDamage(damage);
    }

    //查询玻璃信息
    @Override
    public List<BigStorageCageDetails> selectBigStorageCageDetails(String glassId) {
        LambdaQueryWrapper<GlassInfo> glassInfoWrapper = new LambdaQueryWrapper<>();
        glassInfoWrapper.eq(GlassInfo::getGlassId, glassId);
        GlassInfo glassInfo = glassInfoMapper.selectOne(glassInfoWrapper);
        BigStorageCageDetails bigStorageCageDetails = new BigStorageCageDetails();
        if (glassInfo != null) {
            BeanUtils.copyProperties(glassInfo, bigStorageCageDetails);
            bigStorageCageDetails.setState(1);
            bigStorageCageDetails.setGap(glassGap);
            List<BigStorageCageDetails> bigStorageCageDetailsList = new ArrayList<>();
            bigStorageCageDetailsList.add(bigStorageCageDetails);
            return bigStorageCageDetailsList;
        } else {
            return null;
        }

    }

    //理片笼详情添加
    @Override
    public void insertBigStorageCageDetails(BigStorageCageDetails bigStorageCageDetails) {
        bigStorageCageDetails.setState(100);
        baseMapper.insert(bigStorageCageDetails);
        bigStorageCageService.updateRemainWidth(bigStorageCageDetails.getSlot());
    }

    //理片笼详情完成
    @Override
    public void finishBigStorageCageDetails(BigStorageCageDetails bigStorageCageDetails) {
//        if (bigStorageCageDetails.getBigStorageCageFeedTask() != null) {
//            bigStorageCageDetails.setState(Const.BIG_STORAGE_INSIDE);
//            baseMapper.updateById(bigStorageCageDetails);
//        } else {
//            bigStorageCageDetails.setState(Const.BIG_STORAGE_OUTSIDE);
//            baseMapper.updateById(bigStorageCageDetails);
//            bigStorageCageService.updateRemainWidth(bigStorageCageDetails.getSlot());
//        }
    }

    //手动出片
    @Override
    public void outBigStorageCageDetails(BigStorageCageDetails bigStorageCageDetails) {
        bigStorageCageDetails.setState(Const.GLASS_STATE_ARTIFICIAL);
        baseMapper.updateById(bigStorageCageDetails);
    }

    @Override
    public BigStorageDTO queryTargetSlotByTempering(GlassInfo glassInfo) {
        BigStorageDTO bigStorageDTO = null;
        MPJLambdaWrapper<BigStorageCage> wrapper = new MPJLambdaWrapper<>(BigStorageCage.class)
                .selectAll(BigStorageCage.class)
                .leftJoin(BigStorageCageDetails.class, BigStorageCageDetails::getSlot, BigStorageCage::getSlot)
                .eq(BigStorageCage::getEnableState, Const.SLOT_ON)
                .eq(BigStorageCageDetails::getTemperingLayoutId, glassInfo.getTemperingLayoutId())
                .gt(BigStorageCage::getRemainWidth, Math.max(glassInfo.getWidth(), glassInfo.getHeight()))
                .last("limit 1");
        if (glassInfo.getTemperingLayoutId() == 0) {
            wrapper.eq(BigStorageCageDetails::getWidth, glassInfo.getWidth()).eq(BigStorageCageDetails::getHeight, glassInfo.getHeight());
        } else {
            wrapper.eq(BigStorageCageDetails::getTemperingFeedSequence, glassInfo.getTemperingFeedSequence() + 1);
        }
        BigStorageCage bigStorageCage = bigStorageCageService.selectJoinOne(BigStorageCage.class, wrapper);
        if (null != bigStorageCage) {
            bigStorageDTO = new BigStorageDTO();
            bigStorageDTO.setWidth(bigStorageCage.getRemainWidth());
            bigStorageDTO.setSlot(bigStorageCage.getSlot());
            bigStorageDTO.setDeviceId(bigStorageCage.getDeviceId());
            return bigStorageDTO;
        }
        bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                .eq(BigStorageCage::getEnableState, Const.SLOT_ON)
                .eq(BigStorageCage::getRemainWidth, slotWidth)
                .notInSql(BigStorageCage::getSlot, "select distinct slot from big_storage_cage_details where state = 0")
                .inSql(BigStorageCage::getDeviceId,
                        "select distinct device_id from big_storage_cage_details where tempering_layout_id = " + glassInfo.getTemperingLayoutId())
                .last("limit 1"));
        if (null != bigStorageCage) {
            bigStorageDTO = new BigStorageDTO();
            bigStorageDTO.setWidth(bigStorageCage.getRemainWidth());
            bigStorageDTO.setSlot(bigStorageCage.getSlot());
            bigStorageDTO.setDeviceId(bigStorageCage.getDeviceId());
            return bigStorageDTO;
        }

        //获取玻璃的厚度：重新选笼子需要按照笼子可放玻璃厚度进行选择
        bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                .eq(BigStorageCage::getRemainWidth, slotWidth)
                .eq(BigStorageCage::getEnableState, Const.SLOT_ON)
                .notInSql(BigStorageCage::getSlot, "select distinct slot from big_storage_cage_details where state = 0")
                .notInSql(BigStorageCage::getDeviceId,
                        "select distinct device_id from big_storage_cage_details where state in (100,102,103)")
                .ge(BigStorageCage::getMaxThickness, glassInfo.getThickness())
                .orderByAsc(BigStorageCage::getDeviceId)
                .last("limit 1"));
        if (null != bigStorageCage) {
            bigStorageDTO = new BigStorageDTO();
            bigStorageDTO.setWidth(bigStorageCage.getRemainWidth());
            bigStorageDTO.setSlot(bigStorageCage.getSlot());
            bigStorageDTO.setDeviceId(bigStorageCage.getDeviceId());
            return bigStorageDTO;
        }
        bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                .eq(BigStorageCage::getRemainWidth, slotWidth)
                .notInSql(BigStorageCage::getSlot, "select distinct slot from big_storage_cage_details where state = 0")
                .eq(BigStorageCage::getEnableState, Const.SLOT_ON)
                .ge(BigStorageCage::getMaxThickness, glassInfo.getThickness())
                .orderByAsc(BigStorageCage::getDeviceId)
                .last("limit 1"));
        Assert.isTrue(null != bigStorageCage, "没有空余的笼子存放玻璃");
        bigStorageDTO = new BigStorageDTO();
        bigStorageDTO.setWidth(bigStorageCage.getRemainWidth());
        bigStorageDTO.setSlot(bigStorageCage.getSlot());
        bigStorageDTO.setDeviceId(bigStorageCage.getDeviceId());
        return bigStorageDTO;
    }

    @Override
    public List<TemperingLayoutDTO> temperingIsAll() {
        return baseMapper.temperingIsAll();
    }


    @Override
    public TemperingLayoutDTO queryTemperingOccupySlot() {
        return baseMapper.queryTemperingOccupySlot(minCount);
    }

    @Override
    public List<SlotSequenceDTO> queryGlassMaxAndMin(String engineerId, Integer temperingLayoutId) {
        return baseMapper.queryGlassMaxAndMin(engineerId, temperingLayoutId);
    }

    @Override
    public boolean temperingGlass(String temperingLayoutId, String engineerId) {
        LambdaQueryWrapper<TemperingGlassInfo> temperingGlassInfoLambdaQueryWrapper = new LambdaQueryWrapper<>();
        temperingGlassInfoLambdaQueryWrapper
                .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW);
        List<TemperingGlassInfo> temperingGlassInfoList = temperingGlassInfoMapper.selectList(temperingGlassInfoLambdaQueryWrapper);

        if (temperingGlassInfoList.size() == 0) {
            List<TemperingGlassInfo> temperingGlassInfos = glassInfoService.selectJoinList(TemperingGlassInfo.class, JoinWrappers.lambda(GlassInfo.class)
                    .selectAll(GlassInfo.class)
                    .select("-1 as state")
                    .selectAs(BigStorageCageDetails::getSlot, TemperingGlassInfo::getSlot)
                    .innerJoin(BigStorageCageDetails.class, BigStorageCageDetails::getGlassId, GlassInfo::getGlassId)
                    .eq(GlassInfo::getTemperingLayoutId, temperingLayoutId)
                    .eq(GlassInfo::getEngineerId, engineerId)
                    .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                    .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence));
            if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                temperingGlassInfoService.saveBatch(temperingGlassInfos);
                return true;
            }
        }
        return false;
    }


    @Override
    public List<Map<String, Object>> selectTemperingGlass() {
        QueryWrapper<BigStorageCageDetails> wrapper = new QueryWrapper<>();
        wrapper.select("engineer_id,tempering_layout_id,count(*) as count")
                .in("state", Const.GLASS_STATE_IN, Const.GLASS_STATE_ARTIFICIAL)
                .groupBy("engineer_id,tempering_layout_id");
        List<Map<String, Object>> TemperingGlass = baseMapper.selectMaps(wrapper);
        return TemperingGlass;
    }

    @Override
    public void updateBySlot(List<UpdateBigStorageCageDTO> glassList, int state) {
        baseMapper.updateBySlot(glassList, state);
    }
}