package com.mes.bigstorage.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.mes.bigstorage.entity.BigStorageCage;
import com.mes.bigstorage.entity.BigStorageCageDetails;
import com.mes.bigstorage.mapper.BigStorageCageDetailsMapper;
import com.mes.bigstorage.mapper.BigStorageCageMapper;
import com.mes.bigstorage.service.BigStorageCageService;
import com.mes.common.config.Const;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.service.TemperingGlassInfoService;
import lombok.extern.slf4j.Slf4j;
import com.mes.glassinfo.entity.GlassInfo;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;

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


/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author zhoush
 * @since 2024-03-27
 */
@Service
@Slf4j
public class BigStorageCageServiceImpl extends MPJBaseServiceImpl<BigStorageCageMapper, BigStorageCage> implements BigStorageCageService {
    @Resource
    private BigStorageCageMapper bigStorageCageMapper;

    @Resource
    private BigStorageCageDetailsMapper bigStorageCageDetailsMapper;

    @Resource
    private TemperingGlassInfoService temperingGlassInfoService;

    @Resource
    private GlassInfoService glassInfoService;

    //进片逻辑
    @Override
    public BigStorageCageDetails feedGlass(GlassInfo glassInfo, BigStorageCageDetails bigStorageCageDetails) {
        BeanUtils.copyProperties(glassInfo, bigStorageCageDetails);
        //玻璃不钢化时
        if(glassInfo.getTemperingLayoutId()==null){

            BigStorageCage bigStorageCage=baseMapper.selectJoinOne(BigStorageCage.class, new MPJLambdaWrapper<BigStorageCage>()
                    .selectAll(BigStorageCage.class)
                    .leftJoin(BigStorageCageDetails.class, on -> on
                            .eq(BigStorageCage::getDeviceId, BigStorageCageDetails::getDeviceId)
                            .eq(BigStorageCage::getSlot, BigStorageCageDetails::getSlot))
                    .isNull(BigStorageCageDetails::getTemperingLayoutId)
                    .gt(BigStorageCage::getRemainWidth, 2000)
                    .orderByAsc(BigStorageCage::getDeviceId, BigStorageCage::getSlot)
                    .last("limit 1")
            );

            if(bigStorageCage.getSlot()!=null){
                bigStorageCageDetails.setSlot(bigStorageCage.getSlot());
                bigStorageCageDetails.setDeviceId(bigStorageCage.getDeviceId());
            }
        }else{
            //玻璃钢化时
            BigStorageCage bigStorageCage=new BigStorageCage();

            bigStorageCage=baseMapper.selectJoinOne(BigStorageCage.class, new MPJLambdaWrapper<BigStorageCage>()
                    .selectAll(BigStorageCage.class)
                    .leftJoin(BigStorageCageDetails.class, on -> on
                            .eq(BigStorageCage::getDeviceId, BigStorageCageDetails::getDeviceId)
                            .eq(BigStorageCage::getSlot, BigStorageCageDetails::getSlot))
                    .eq(BigStorageCageDetails::getTemperingLayoutId, glassInfo.getTemperingLayoutId())
                    .eq(BigStorageCageDetails::getTemperingFeedSequence, glassInfo.getTemperingFeedSequence() - 1)
                    .gt(BigStorageCage::getRemainWidth, glassInfo.getWidth())
            );
            log.info("1、查询理片笼内片序-1等于当前玻璃片序的玻璃"+bigStorageCage);

            log.info("2、查询理片笼内片序-1等于当前玻璃片序的玻璃的结果不为空时"+bigStorageCage.getSlot());
            if (bigStorageCage.getSlot() != null) {
                bigStorageCageDetails.setSlot(bigStorageCage.getSlot());
                bigStorageCageDetails.setDeviceId(bigStorageCage.getDeviceId());
            } else {
                log.info("3、查询理片笼内片序-1等于当前玻璃片序的玻璃的结果为空时获取当前玻璃版图id是否存在理片笼内");

                bigStorageCage=baseMapper.selectJoinOne(BigStorageCage.class, new MPJLambdaWrapper<BigStorageCage>()
                        .selectAll(BigStorageCage.class)
                        .leftJoin(BigStorageCageDetails.class, on -> on
                                .eq(BigStorageCage::getDeviceId, BigStorageCageDetails::getDeviceId)
                                .eq(BigStorageCage::getSlot, BigStorageCageDetails::getSlot))
                        .eq(BigStorageCageDetails::getTemperingLayoutId, glassInfo.getTemperingLayoutId())
                        .gt(BigStorageCage::getRemainWidth, glassInfo.getWidth())
                );

                if(bigStorageCage != null){
                    log.info("4、获取笼子内适合的格子");
                    BigStorageCage bigStorageCages=bigStorageCageSlot(bigStorageCage.getDeviceId());
                    bigStorageCageDetails.setSlot(bigStorageCages.getSlot());
                    bigStorageCageDetails.setDeviceId(bigStorageCages.getDeviceId());
                }else{
                    log.info("5、获取每个笼子版图id的个数");
                    QueryWrapper<BigStorageCageDetails> queryWrapper = new QueryWrapper<>();
                    queryWrapper.select("a.device_id", "COUNT(DISTINCT b.tempering_layout_id) AS layoutCount")
                            .groupBy("a.device_id")
                            .apply("LEFT JOIN (SELECT device_id, tempering_layout_id FROM big_storage_cage_details) b ON a.device_id = b.device_id AND a.slot = b.slot")
                            .orderByAsc("layoutCount")
                            .orderByAsc("a.device_id");
                    List<Map<String, Object>> bigStorageCageDetailsCount= bigStorageCageDetailsMapper.selectMaps(queryWrapper);

                    log.info("5、查询笼子内是否有合适的格子");
                    boolean found=false;
                    for (Map<String, Object> map : bigStorageCageDetailsCount) {
                        for (Map.Entry<String, Object> entry : map.entrySet()) {
                            int deviceId = Integer.parseInt(entry.getKey());
                            BigStorageCage bigStorageCages=bigStorageCageSlot(deviceId);
                            if(bigStorageCage!=null){
                                bigStorageCageDetails.setSlot(bigStorageCages.getSlot());
                                bigStorageCageDetails.setDeviceId(deviceId);
                                found=true;
                                break;
                            }
                        }
                        if(found){
                            break;
                        }
                    }
                }
            }
        }



        if (bigStorageCageDetails.getSlot() != null) {
            log.info("6、当找到合适的格子时添加玻璃到笼子表");
            bigStorageCageDetails.setState(0);
            bigStorageCageDetailsMapper.insert(bigStorageCageDetails);
            updateRemainWidth(bigStorageCageDetails.getSlot()) ;
        }
        return bigStorageCageDetails;
    }

    //获取笼子内的空格子
    private BigStorageCage bigStorageCageSlot(Integer deviceId) {
        LambdaQueryWrapper<BigStorageCage> bigStorageCageWrapper=new LambdaQueryWrapper<>();
                bigStorageCageWrapper
                        .eq(BigStorageCage::getRemainWidth,"5000")
                        .eq(BigStorageCage::getEnableState,"0")
                        .eq(BigStorageCage::getDeviceId,deviceId)
                        .orderByAsc(BigStorageCage::getSlot)
                        .last("LIMIT 1");
                return bigStorageCageMapper.selectOne(bigStorageCageWrapper);
    }

    //出片逻辑
    @Override
    public boolean outGlass() {
        LambdaQueryWrapper<TemperingGlassInfo> temperingGlassInfoWrapper=new LambdaQueryWrapper<>();
        temperingGlassInfoWrapper.eq(TemperingGlassInfo::getState,-1);
        List<TemperingGlassInfo> temperingGlassInfoList = temperingGlassInfoService.list(temperingGlassInfoWrapper);
        log.info("1、查询钢化小片任务表是否有待出玻璃"+temperingGlassInfoList.size());
        if(temperingGlassInfoList.size()>0){
            temperingGlassInfoService.addOutTask(temperingGlassInfoList);
            log.info("2、添加任务到任务表");
            return true;
        }else{
            log.info("3、没有可出的玻璃时获取是否有小片到齐的版图");

            QueryWrapper<BigStorageCageDetails> wrapper = Wrappers.query();
            wrapper.select("tempering_layout_id", "count(tempering_layout_id)")
                    .groupBy("tempering_layout_id");
            List<Map<String, Object>> temperingLayoutIdList = bigStorageCageDetailsMapper.selectMaps(wrapper);

            boolean key=false;
            for (Map<String, Object> row : temperingLayoutIdList) {
                for (Map.Entry<String, Object> entry : row.entrySet()) {
                    String temperingId = entry.getKey();
                    Object temperingNo = entry.getValue();

                        LambdaQueryWrapper<GlassInfo> glassInfoWrapper=new LambdaQueryWrapper<>();
                        glassInfoWrapper.eq(GlassInfo::getTemperingLayoutId,temperingId)
                                .orderByDesc(GlassInfo::getTemperingFeedSequence);
                        List<GlassInfo> glassInfoList= glassInfoService.list(glassInfoWrapper);
                        if(glassInfoList.size()==Integer.parseInt(temperingNo.toString())){
                            for (GlassInfo glassInfo:glassInfoList
                            ) {

                                TemperingGlassInfo temperingGlassInfo=new TemperingGlassInfo();
                                BeanUtils.copyProperties(glassInfo, temperingGlassInfo);
                                temperingGlassInfoService.save(temperingGlassInfo);

                            }
                            key=true;
                        }
                    if(key){
                        return false;
                    }
                }
            }
        }
        return false;
    }

    //计算格子剩余宽度
    @Override
    public void updateRemainWidth(int slot) {
        log.info("获取该格子内玻璃信息，计算格子剩余宽度");
        double width = 5000;
        LambdaQueryWrapper<BigStorageCageDetails> bigStorageCageDetailsWrapper=new LambdaQueryWrapper();
        bigStorageCageDetailsWrapper
                .eq(BigStorageCageDetails::getSlot,slot)
                .ne(BigStorageCageDetails::getState,Const.BIG_STORAGE_OUTSIDE);

        List<BigStorageCageDetails> bigStorageCageDetailsList = bigStorageCageDetailsMapper.selectList(bigStorageCageDetailsWrapper);
        for (BigStorageCageDetails bigStorageCageDetails : bigStorageCageDetailsList
        ) {
            double widths=bigStorageCageDetails.getWidth();
            double gap=bigStorageCageDetails.getGap();
            width -= widths+gap;
        }
        //修改格子剩余宽度
        BigStorageCage bigStorageCage = new BigStorageCage();
        bigStorageCage.setRemainWidth((int)width);
        UpdateWrapper<BigStorageCage> bigStorageCageWrapper = new UpdateWrapper<>();
        bigStorageCageWrapper.eq("slot", slot);
        bigStorageCageMapper.update(bigStorageCage, bigStorageCageWrapper);
    }

    //查询大理片信息，前端展示用
    @Override
    public List<BigStorageCage> querybigStorageCageDetail(int deviceId) {
        LambdaQueryWrapper<BigStorageCage> bigStorageCageWrapper =new LambdaQueryWrapper<>();
        LambdaQueryWrapper<BigStorageCageDetails> bigStorageCageDetailsWrapper =new LambdaQueryWrapper<>();
        if(deviceId!=0){
            bigStorageCageWrapper.eq(BigStorageCage::getDeviceId,deviceId);
            bigStorageCageDetailsWrapper.eq(BigStorageCageDetails::getDeviceId,deviceId);
        }

        List<BigStorageCage> bigStorageCages = bigStorageCageMapper.selectList(bigStorageCageWrapper);
        log.info("1、获取大理片笼信息完成，获取到的数据{}", bigStorageCages.size());

        List<BigStorageCageDetails> bigStorageCageDetailsList = bigStorageCageDetailsMapper.selectList(bigStorageCageDetailsWrapper);

        Map<Integer, List<BigStorageCageDetails>> listMap = bigStorageCageDetailsList.stream().collect(Collectors.groupingBy(BigStorageCageDetails::getSlot));
        for (BigStorageCage bigStorageCage : bigStorageCages) {
            List<BigStorageCageDetails> bigStorageCageDetails = listMap.get(bigStorageCage.getSlot());
            bigStorageCage.setBigStorageCageDetails(bigStorageCageDetails);
        }
        return bigStorageCages;
    }

    //笼子使用情况，界面展示用
    @Override
    public List<Map<String, Object>> selectBigStorageCageUsage() {
        QueryWrapper<BigStorageCage> wrapper = new QueryWrapper<>();
        wrapper.select("device_id,ROUND(1 - SUM(CASE WHEN remain_width = 5000 THEN 1 ELSE 0 END) / COUNT(device_id), 2) AS percentage,COUNT(device_id) - SUM(CASE WHEN remain_width = 5000 THEN 1 ELSE 0 END) AS count")

                .groupBy("device_id");
        List<Map<String, Object>> bigStorageCageUsages=baseMapper.selectMaps(wrapper);

        return bigStorageCageUsages;
    }

    //笼子的启用/禁用
    @Override
    public void updateStorageCageDisabled(int slot,int enableState){
        BigStorageCage bigStorageCage=new BigStorageCage();
        bigStorageCage.setEnableState(enableState);
        LambdaQueryWrapper<BigStorageCage> bigStorageCageWrapper = new LambdaQueryWrapper<>();
        bigStorageCageWrapper.eq(BigStorageCage::getSlot,slot);
        baseMapper.update(bigStorageCage,bigStorageCageWrapper);
    }
}