package com.mes.bigstorage.service.impl;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.lang.Assert;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mes.bigstorage.entity.BigStorageCage;
import com.mes.bigstorage.entity.BigStorageCageDetails;
import com.mes.bigstorage.entity.BigStorageGlassInfo;
import com.mes.bigstorage.entity.BigStorageGlassRelationInfo;
import com.mes.bigstorage.entity.dto.BigStorageDTO;
import com.mes.bigstorage.mapper.BigStorageGlassInfoMapper;
import com.mes.bigstorage.service.BigStorageCageDetailsService;
import com.mes.bigstorage.service.BigStorageCageService;
import com.mes.bigstorage.service.BigStorageGlassInfoService;
import com.mes.bigstorage.service.BigStorageGlassRelationInfoService;
import com.mes.common.config.Const;
import com.mes.common.config.ConstSysConfig;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.sysconfig.service.SysConfigService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;

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

/**
 * (BigStorageGlassInfo)表服务实现类
 *
 * @author makejava
 * @since 2024-11-24 10:15:35
 */
@Service
@Slf4j
public class BigStorageGlassInfoServiceImpl extends ServiceImpl<BigStorageGlassInfoMapper, BigStorageGlassInfo> implements BigStorageGlassInfoService {
    @Resource
    GlassInfoService glassInfoService;
    @Resource
    BigStorageCageService bigStorageCageService;
    @Resource
    BigStorageCageDetailsService bigStorageCageDetailsService;
    @Resource
    BigStorageGlassRelationInfoService bigStorageGlassRelationInfoService;
    @Resource
    SysConfigService sysConfigService;
//    @Value("${mes.slotWidth}")
//    private Integer slotWidth;
//    @Value("${mes.glassGap}")
//    private Integer glassGap;
//    @Value("${mes.outCarMaxSize}")
//    private Integer outCarMaxSize;

    @Override
    public BigStorageDTO queryBigStorageTargetSlot(String engineerId, Integer temperingLayoutId, Integer temperingFeedSequence) {
        //按照玻璃信息获取关系表是否有对应的关系
        BigStorageGlassRelationInfo relationInfoOne = bigStorageGlassRelationInfoService.getOne(new LambdaQueryWrapper<BigStorageGlassRelationInfo>()
                .eq(BigStorageGlassRelationInfo::getEngineerId, engineerId)
                .eq(BigStorageGlassRelationInfo::getTemperingLayoutId, temperingLayoutId)
                .eq(BigStorageGlassRelationInfo::getTemperingFeedSequence, temperingFeedSequence)
        );
        if (relationInfoOne == null) {
            //理片笼关系表中没有对应的数据，查看理片笼虚拟位置表是否有本工程下的所有玻璃虚拟信息
            BigStorageGlassInfo bigStorageGlassInfo = this.getOne(new LambdaQueryWrapper<BigStorageGlassInfo>()
                    .eq(BigStorageGlassInfo::getEngineerId, engineerId)
                    .eq(BigStorageGlassInfo::getTemperingLayoutId, temperingLayoutId)
                    .eq(BigStorageGlassInfo::getTemperingFeedSequence, temperingFeedSequence));
            if (null == bigStorageGlassInfo) {
                //虚拟位置表没有本工程下的所有玻璃虚拟信息，按照玻璃id生成本工程下所有玻璃的虚拟信息
                generateBigStorageGlassInfo(engineerId, temperingLayoutId);
                bigStorageGlassInfo = this.getOne(new LambdaQueryWrapper<BigStorageGlassInfo>()
                        .eq(BigStorageGlassInfo::getEngineerId, engineerId)
                        .eq(BigStorageGlassInfo::getTemperingLayoutId, temperingLayoutId)
                        .eq(BigStorageGlassInfo::getTemperingFeedSequence, temperingFeedSequence));
            }
            //按照虚拟位置和大理片笼现有可用格子生成关系表
            bigStorageSlotPair(bigStorageGlassInfo);
            //关系表获取实际位置
            relationInfoOne = bigStorageGlassRelationInfoService.getOne(new LambdaQueryWrapper<BigStorageGlassRelationInfo>()
                    .eq(BigStorageGlassRelationInfo::getEngineerId, engineerId)
                    .eq(BigStorageGlassRelationInfo::getTemperingLayoutId, temperingLayoutId)
                    .eq(BigStorageGlassRelationInfo::getTemperingFeedSequence, temperingFeedSequence));
        }
        Integer slotWidth = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_SLOT_WIDTH);
        BigStorageCageDetails bigStorageCageDetails = bigStorageCageDetailsService.getOne(new LambdaQueryWrapper<BigStorageCageDetails>()
                .eq(BigStorageCageDetails::getSlot, relationInfoOne.getSlot()).in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL_ZERO)
                .orderByDesc(BigStorageCageDetails::getSequence).last("limit 1"));
        if (null == bigStorageCageDetails) {
            BigStorageDTO storageDTO = new BigStorageDTO();
            storageDTO.setDeviceId(relationInfoOne.getDeviceId());
            storageDTO.setSlot(relationInfoOne.getSlot());
            storageDTO.setSlotSequence(relationInfoOne.getSlotSequence());
            storageDTO.setWidth(slotWidth);
            return storageDTO;
        }
        BigStorageGlassRelationInfo relationInfoBefore = bigStorageGlassRelationInfoService.getOne(new LambdaQueryWrapper<BigStorageGlassRelationInfo>()
                .eq(BigStorageGlassRelationInfo::getEngineerId, relationInfoOne.getEngineerId())
                .eq(BigStorageGlassRelationInfo::getTemperingLayoutId, relationInfoOne.getTemperingLayoutId())
                .eq(BigStorageGlassRelationInfo::getVirtualSlot, relationInfoOne.getVirtualSlot())
                .eq(BigStorageGlassRelationInfo::getSlotSequence, relationInfoOne.getSlotSequence() - 1));
        BigStorageDTO storageCageDTO = null;
        if (null == relationInfoBefore) {
            //表示序号没有或者  序号为1又不是第一块来的 新开一格
            storageCageDTO = bigStorageCageDetailsService.queryTargetSlot(engineerId, bigStorageCageDetails.getGlassId(), (int) bigStorageCageDetails.getThickness());
        } else {
            BigStorageCageDetails beforeGlass = bigStorageCageDetailsService.getOne(new LambdaQueryWrapper<BigStorageCageDetails>()
                    .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL_ZERO)
                    .eq(BigStorageCageDetails::getEngineerId, relationInfoBefore.getEngineerId())
                    .eq(BigStorageCageDetails::getTemperingLayoutId, relationInfoBefore.getTemperingLayoutId())
                    .eq(BigStorageCageDetails::getTemperingFeedSequence, relationInfoBefore.getTemperingFeedSequence())
            );
            if (null == beforeGlass) {
                storageCageDTO = bigStorageCageDetailsService.queryTargetSlot(engineerId, bigStorageCageDetails.getGlassId(), (int) bigStorageCageDetails.getThickness());
            } else {
                BigStorageCage bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                        .eq(BigStorageCage::getEnableState, Const.SLOT_ON).eq(BigStorageCage::getSlot, beforeGlass.getSlot()));
                Assert.isTrue(null != bigStorageCage, "没有空余的笼子存放玻璃");
                storageCageDTO = new BigStorageDTO();
                storageCageDTO.setWidth(bigStorageCage.getRemainWidth());
                storageCageDTO.setSlot(bigStorageCage.getSlot());
                storageCageDTO.setDeviceId(bigStorageCage.getDeviceId());
            }
        }
        return storageCageDTO;
    }

    @Override
    public void generateBigStorageGlassInfo(String engineerId, int temperingLayoutId) {
        List<BigStorageGlassInfo> list = this.list(new LambdaQueryWrapper<BigStorageGlassInfo>()
                .eq(BigStorageGlassInfo::getEngineerId, engineerId).eq(BigStorageGlassInfo::getTemperingLayoutId, temperingLayoutId));
        if (CollectionUtil.isNotEmpty(list)) {
            return;
        }
        Integer slotWidth = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_SLOT_WIDTH);
//        Integer glassGap = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_GLASS_GAP);
        Integer outCarMaxSize = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_OUT_CAR_SIZE);
//        Engineering engineering = engineeringMapper.selectOne(new LambdaQueryWrapper<Engineering>()
//                .eq(Engineering::getEngineerId, glassInfo.getEngineerId()));
        //获取玻璃的工程id，按照工程id获取工程下的所有玻璃信息
        List<GlassInfo> glassInfoList = glassInfoService.list(new LambdaQueryWrapper<GlassInfo>()
                .eq(GlassInfo::getEngineerId, engineerId)
                .orderByAsc(GlassInfo::getTemperingLayoutId).orderByAsc(GlassInfo::getTemperingFeedSequence));
        Integer glassGap = getGlassGapByThickness(glassInfoList.get(0).getThickness());
        Map<Integer, List<GlassInfo>> trmperingIdMap = glassInfoList.stream().collect(Collectors.groupingBy(GlassInfo::getTemperingLayoutId));
        List<BigStorageGlassInfo> bigStorageGlassInfoList = new ArrayList<>();
        //方式一：将玻璃按版图、版序 依次生成虚拟格子信息，格子一直往后累加
        trmperingIdMap.forEach((e, v) -> {
            int remainWidth = slotWidth;
            int slotNumber = 1;
            int slotSequence = 1;
            for (GlassInfo item : v) {
                int maxLength = (int) Math.max(item.getWidth(), item.getHeight());
                if (remainWidth > maxLength && slotSequence <= outCarMaxSize) {
                    remainWidth = remainWidth - maxLength - glassGap;
                } else {
                    slotNumber = slotNumber + 1;
                    slotSequence = 1;
                    remainWidth = slotWidth - maxLength - glassGap;
                }
                BigStorageGlassInfo bigStorage = new BigStorageGlassInfo();
                BeanUtils.copyProperties(item, bigStorage);
                bigStorage.setVirtualSlot(slotNumber);
                bigStorage.setSlotSequence(slotSequence++);
                bigStorage.setId(null);
                bigStorageGlassInfoList.add(bigStorage);
            }
        });
        this.saveBatch(bigStorageGlassInfoList);
        log.info("分配完毕");

    }

    @Override
    public int bigStorageSlotPair(BigStorageGlassInfo bigStorageGlassInfo) {
        //获取所有空闲可用的格子号
        BigStorageDTO bigStorageDTO = bigStorageCageDetailsService.queryTargetSlot(bigStorageGlassInfo.getEngineerId(),
                bigStorageGlassInfo.getGlassId(), bigStorageGlassInfo.getThickness().intValue());
        Assert.isTrue(null != bigStorageDTO, "没有空余的笼子存放玻璃");
        Integer slot = bigStorageDTO.getSlot();
        //获取该工程同一流程卡同一车的玻璃信息
        List<BigStorageGlassInfo> bigStorageGlassInfoList = this.list(new LambdaQueryWrapper<BigStorageGlassInfo>()
                .eq(BigStorageGlassInfo::getEngineerId, bigStorageGlassInfo.getEngineerId())
                .eq(BigStorageGlassInfo::getTemperingLayoutId, bigStorageGlassInfo.getTemperingLayoutId())
                .eq(BigStorageGlassInfo::getVirtualSlot, bigStorageGlassInfo.getVirtualSlot()));
        //设置关系表的实际格子号
        List<BigStorageGlassRelationInfo> relationInfoList = bigStorageGlassInfoList.stream().map(e -> {
            BigStorageGlassRelationInfo info = new BigStorageGlassRelationInfo();
            BeanUtils.copyProperties(e, info);
            info.setSlot(slot);
            info.setDeviceId(bigStorageDTO.getDeviceId());
            return info;
        }).collect(Collectors.toList());
        //保存关系表
        bigStorageGlassRelationInfoService.saveBatch(relationInfoList);
        //返回格子信息
        return slot;
    }


    private Integer getGlassGapByThickness(Double thickness) {
        int sysKey = 0;
        if (thickness >= 12) {
            sysKey = ConstSysConfig.VERTICAL_GLASS_GAP_12;
        } else if (thickness == 8) {
            sysKey = ConstSysConfig.VERTICAL_GLASS_GAP_8;
        } else if (thickness == 10) {
            sysKey = ConstSysConfig.VERTICAL_GLASS_GAP_10;
        } else {
            sysKey = ConstSysConfig.VERTICAL_GLASS_GAP;
        }
        return sysConfigService.queryConfigValue(sysKey);
    }
}