package com.mes.downstorage.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.github.yulichang.query.MPJLambdaQueryWrapper;
import com.github.yulichang.query.MPJQueryWrapper;


import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

import com.github.yulichang.toolkit.JoinWrappers;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.mes.common.config.Const;
import com.mes.downstorage.entity.DownStorageCage;
import com.mes.downstorage.entity.DownStorageCageDetails;
import com.mes.downstorage.mapper.DownStorageCageDetailsMapper;

import com.mes.downstorage.mapper.DownStorageCageMapper;
import com.mes.downstorage.service.DownStorageCageDetailsService;
import com.mes.downworkstation.entity.DownWorkstation;
import com.mes.downworkstation.mapper.DownWorkstationMapper;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.mapper.GlassInfoMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Slf4j
@Service
public class DownStorageCageDetailsServiceImpl extends ServiceImpl<DownStorageCageDetailsMapper, DownStorageCageDetails> implements DownStorageCageDetailsService {

    @Autowired(required = false)
    private DownStorageCageMapper downStorageCageMapper;
    @Autowired
    private DownStorageCageDetailsMapper downStorageCageDetailsMapper;
    @Autowired
    private GlassInfoMapper glassInfoMapper;
    @Autowired
    private DownWorkstationMapper downWorkstationMapper;

    @Override
    public void addDownStorageCageDetails(DownStorageCageDetails details) {
        this.save(details);
    }


    @Override
    //修改理片笼内信息 功能：对笼内栅格玻璃 【添加/删除/更换】
    public boolean updatedownStorageCageDetails(DownStorageCageDetails details) {
        baseMapper.updateById(details);
        return true;
    }


//    @Override
//    public List<DownStorageCageDetails> CacheOut(int start, int end) {
//        log.info("单片情况根据传入的工位查询符合按照大小出片,并且优先出满架的小片");
//        return downStorageCageDetailsMapper.selectJoinList(
//                DownStorageCageDetails.class, new MPJQueryWrapper<DownStorageCageDetails>()
//                        .select("t.*")
//                        .leftJoin("(SELECT t1.* FROM down_storage_cage_details t1 "
//                                + "JOIN (SELECT flow_card_id, MAX(width*height) AS max_width FROM glass_info GROUP BY flow_card_id) t "
//                                + "ON t1.flow_card_id = t.flow_card_id WHERE t1.width*t1.height = t.max_width) t3"
//                                + " ON t.glass_id = t3.glass_id")
//                        .leftJoin("down_workstation t4 ON t3.flow_card_id = t4.flow_card_id")
//                        .isNull(Boolean.parseBoolean("t.glass_id"), "SELECT glass_id FROM down_glass_info")
//                        .between("t4.workstation_id", start, end)
//                        // 根据 racks_number 排序
//                        .orderByDesc("t4.racks_number")
//
//        );
//    }


//    @Override
//    public List<DownStorageCageDetails> getCacheOut(int start, int end) {
//        log.info("根据传入的工位查询符合按照顺序和大小出片的小片");
//        return  downStorageCageMapper.selectJoinList(
//                DownStorageCageDetails.class, new MPJQueryWrapper<DownStorageCage>()
//                        .select("escd.*")
//                        .leftJoin("down_storage_cage_details escd on t.slot = escd.slot")
//                        .leftJoin("down_workstation dw on escd.flow_card_id = dw.flow_card_id")
//                        .leftJoin("glass_info gi on dw.flow_card_id = gi.flowcard_id  and gi.flowcard_id=escd.flow_card_id ")
//                        .isNotNull("escd.slot")
//                        .between("dw.workstation_id", start, end)
//                        .orderByDesc("escd.width")
//                        .orderByDesc("escd.height")
//        );
//    }


//    @Override
//    public List<DownStorageCageDetails> selectCacheEmpty2(){
//        return  downStorageCageMapper.selectJoinList(
//                DownStorageCageDetails.class, new MPJQueryWrapper<DownStorageCage>()
//                        .select("escd.glass_id","escd.flow_card_id","escd.width","escd.height")
//                        .leftJoin("down_storage_cage_details escd on t.device_id=escd.device_id and t.slot=escd.slot")
//                        .isNull("escd.slot")
//        );
//    }


    @Override
    public List<Map<String, Object>> getCacheInfo() {
        log.info("查询笼子内信息");
        return downStorageCageDetailsMapper.selectJoinMaps(JoinWrappers.lambda(DownStorageCageDetails.class) // 使用 JoinWrappers.lambda 创建联合查询
                .selectAll(DownStorageCageDetails.class) // 选择所有字段
                .eq(DownStorageCage::getSlot, DownStorageCageDetails::getSlot) // 设置关联条件
                .eq(DownStorageCageDetails::getState, Const.GLASS_STATE_IN)
                .orderByAsc(DownStorageCage::getSlot) // 按 slot 字段升序排序
        );
    }

//
//    @Override
//    public List<Map> getCacheInfo() {
//        log.info(" 查询笼子内信息");
//        return downStorageCageMapper.selectJoinList(
//                Map.class, new MPJQueryWrapper<DownStorageCage>()
//                        .select("escd.*")
//                        .leftJoin("down_storage_cage_details escd on t.slot = escd.slot")
//                        .orderByAsc("t.slot")
//        );
//
//    }

//    @Override
//    public List<DownStorageCageDetails> getCacheLeisure() {
//        log.info(" 查询笼子内空闲");
//        List<DownStorageCageDetails> list = downStorageCageMapper.selectJoinList(
//                DownStorageCageDetails.class, new MPJQueryWrapper<DownStorageCage>()
//                        .select("escd.*")
//                        .leftJoin("down_storage_cage_details escd on t.slot = escd.slot")
//                        .isNull("escd.slot")
//
//                        .orderByAsc("escd.slot")
//        );
//        return list;
//    }


//    @Override
//    public List<DownStorageCageDetails> getIsExistIntoCacheByflowcardid(String flowcardid, double width) {
//        log.info("  查询可进此片玻璃的栅格号  找到空格");
//
//        return downStorageCageMapper.selectJoinList(
//                DownStorageCageDetails.class, new MPJQueryWrapper<DownStorageCage>()
//                        .select("escd.*")
//                        .leftJoin("down_storage_cage_details escd on t.slot = escd.slot")
//                        .isNull("escd.slot")
//                        .apply("t.remain_width - " + width + " > 0")
//                        .orderByAsc("escd.sequence")
//        );
//
//
//
//
//    }

  //  @Override
//    public List<GlassInfo>  DirectConnection(){
//        LambdaQueryWrapper<GlassInfo> queryWrapper2 = Wrappers.lambdaQuery();
//        queryWrapper2.select(GlassInfo::getFlowCardId,
//                GlassInfo::getGlassId,
//                GlassInfo::getTemperingLayoutId,
//                GlassInfo::getTemperingFeedSequence)
//                .notInSql(GlassInfo::getGlassId, "SELECT glass_id FROM down_glass_info")
//                .orderByAsc(GlassInfo::getTemperingLayoutId)
//                .orderByDesc(GlassInfo::getTemperingFeedSequence)
//                .last("LIMIT 1");
//
//        // 查询 GlassInfo 表
//        log.info("直通查询");
//        return glassInfoMapper.selectList(queryWrapper2);
//
//    };

    @Override
    public boolean DirectConnection(GlassInfo glassInfo) {
        LambdaQueryWrapper<GlassInfo> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(GlassInfo::getGlassId, glassInfo.getGlassId())
                .notInSql(GlassInfo::getGlassId, "SELECT glass_id FROM down_glass_info")
                .orderByDesc(GlassInfo::getGlassType)
                .groupBy(GlassInfo::getFlowCardId)
                .last("LIMIT 1");

        // 查询符合条件的 GlassInfo 记录数量
        int count = glassInfoMapper.selectCount(queryWrapper);

        return count > 0;
    }

    @Override
    public DownStorageCageDetails getGlassInfoMaxCount() {
        return baseMapper.getGlassInfoMaxCount();
    }


    @Override
    public List<DownStorageCageDetails> CacheOut1(int start, int end) {


        // 创建一个 LambdaQueryWrapper 实例
        LambdaQueryWrapper<DownStorageCageDetails> lambdaQueryWrapper = new LambdaQueryWrapper<>();
// 条件 state=100
        lambdaQueryWrapper.eq(DownStorageCageDetails::getState, Const.GLASS_STATE_IN);
        List<DownStorageCageDetails> cageDetails = downStorageCageDetailsMapper.selectList(lambdaQueryWrapper);
        // Step 5: 判断 down_storage_cage_details 结果数量是否为9，如果是，则执行另外一个查询
        if (cageDetails.size() == 9) {
            log.info("1、笼子满了的时候，按照笼内版图id 版图片序出");
            List<DownWorkstation> workstationList = downWorkstationMapper.selectList(new QueryWrapper<DownWorkstation>().between("workstation_id", start, end));

            List<String> flowCardIds = new ArrayList<>();
            for (DownWorkstation workstation : workstationList) {
                flowCardIds.add(workstation.getFlowCardId());
            }

            if (flowCardIds.isEmpty()) {
                log.error("未找到对应的 flow_card_id");
                return Collections.emptyList(); // 返回空列表或者抛出异常，视情况而定
            }
            LambdaQueryWrapper<DownStorageCageDetails> anotherQueryWrapper = Wrappers.lambdaQuery();

            anotherQueryWrapper.orderByAsc(DownStorageCageDetails::getTemperingLayoutId);
            anotherQueryWrapper.orderByDesc(DownStorageCageDetails::getTemperingFeedSequence);
            anotherQueryWrapper.in(DownStorageCageDetails::getFlowCardId, flowCardIds);
            anotherQueryWrapper.eq(DownStorageCageDetails::getState, Const.GLASS_STATE_IN);
            anotherQueryWrapper.last("LIMIT 1");
            return downStorageCageDetailsMapper.selectList(anotherQueryWrapper);
        } else {

            // Step 1: 查询 DownWorkstation 表获取对应 workstation_id 的 flow_card_id
            List<DownWorkstation> workstationList = downWorkstationMapper.selectList(new QueryWrapper<DownWorkstation>().between("workstation_id", start, end));

            List<String> flowCardIds = new ArrayList<>();
            for (DownWorkstation workstation : workstationList) {
                flowCardIds.add(workstation.getFlowCardId());
            }
            if (flowCardIds.isEmpty()) {
                log.error("2、未找到对应的 flow_card_id");
                return Collections.emptyList(); // 返回空列表或者抛出异常，视情况而定
            }
            log.info("流程卡:{}", flowCardIds);
            LambdaQueryWrapper<GlassInfo> queryWrapper2 = Wrappers.lambdaQuery();
            queryWrapper2.select(GlassInfo::getFlowCardId,
                    GlassInfo::getGlassId,
                    GlassInfo::getTemperingLayoutId,
                    GlassInfo::getTemperingFeedSequence)
                    .notInSql(GlassInfo::getGlassId, "SELECT glass_id FROM down_glass_info")
                    .orderByAsc(GlassInfo::getTemperingLayoutId)
                    .orderByDesc(GlassInfo::getTemperingFeedSequence)
                    .last("LIMIT 1");

            // 查询 GlassInfo 表
            List<GlassInfo> glassInfos = glassInfoMapper.selectList(queryWrapper2);
            if (glassInfos.isEmpty()) {
                log.error("未找到对应的玻璃信息");
                return Collections.emptyList(); // 返回空列表或者抛出异常，视情况而定
            }
            // Step 3: 构造查询 down_storage_cage_details 表的条件
            List<String> glassIds = glassInfos.stream().map(GlassInfo::getGlassId).collect(Collectors.toList());
            LambdaQueryWrapper<DownStorageCageDetails> cageDetailsQueryWrapper = Wrappers.lambdaQuery();
            cageDetailsQueryWrapper.in(DownStorageCageDetails::getGlassId, glassIds);
            cageDetailsQueryWrapper.in(DownStorageCageDetails::getFlowCardId, flowCardIds);
            cageDetailsQueryWrapper.eq(DownStorageCageDetails::getState, Const.GLASS_STATE_IN);
            log.info("按照流程卡的版图id 版图片序出");
            // Step 4: 查询 down_storage_cage_details 表并返回结果
            return downStorageCageDetailsMapper.selectList(cageDetailsQueryWrapper);
        }


    }




        @Override
        public List<DownStorageCageDetails> CacheOut2(int start, int end) {


            // 创建一个 LambdaQueryWrapper 实例
            LambdaQueryWrapper<DownStorageCageDetails> lambdaQueryWrapper = new LambdaQueryWrapper<>();
// 条件 state=100
            lambdaQueryWrapper.eq(DownStorageCageDetails::getState, Const.GLASS_STATE_IN);
            List<DownStorageCageDetails> cageDetails = downStorageCageDetailsMapper.selectList(lambdaQueryWrapper);
            // Step 5: 判断 down_storage_cage_details 结果数量是否为9，如果是，则执行另外一个查询
            if (cageDetails.size() == 9) {
                log.info("1、笼子满了的时候，按照笼内流程卡顺序出 GlassType目前是流程卡中的顺序");
                List<DownWorkstation> workstationList = downWorkstationMapper.selectList(new QueryWrapper<DownWorkstation>().between("workstation_id", start, end));

                List<String> flowCardIds = new ArrayList<>();
                for (DownWorkstation workstation : workstationList) {
                    flowCardIds.add(workstation.getFlowCardId());
                }

                if (flowCardIds.isEmpty()) {
                    log.error("未找到对应的 flow_card_id");
                    return Collections.emptyList(); // 返回空列表或者抛出异常，视情况而定
                }
                LambdaQueryWrapper<DownStorageCageDetails> anotherQueryWrapper = Wrappers.lambdaQuery();

                anotherQueryWrapper.orderByAsc(DownStorageCageDetails::getGlassType);
                anotherQueryWrapper.in(DownStorageCageDetails::getFlowCardId, flowCardIds);
                anotherQueryWrapper.eq(DownStorageCageDetails::getState, Const.GLASS_STATE_IN);
                anotherQueryWrapper.last("LIMIT 1");
                return downStorageCageDetailsMapper.selectList(anotherQueryWrapper);
            } else {

                // Step 1: 查询 DownWorkstation 表获取对应 workstation_id 的 flow_card_id
                List<DownWorkstation> workstationList = downWorkstationMapper.selectList(new QueryWrapper<DownWorkstation>().between("workstation_id", start, end));

                List<String> flowCardIds = new ArrayList<>();
                for (DownWorkstation workstation : workstationList) {
                    flowCardIds.add(workstation.getFlowCardId());
                }
                if (flowCardIds.isEmpty()) {
                    log.error("2、未找到对应的 flow_card_id");
                    return Collections.emptyList(); // 返回空列表或者抛出异常，视情况而定
                }
                log.info("流程卡:{}", flowCardIds);
                LambdaQueryWrapper<GlassInfo> queryWrapper2 = Wrappers.lambdaQuery();
                queryWrapper2.select(GlassInfo::getFlowCardId,
                        GlassInfo::getGlassId)
                        .notInSql(GlassInfo::getGlassId, "SELECT glass_id FROM down_glass_info")
                        .orderByAsc(GlassInfo::getGlassType)
                        .last("LIMIT 1");

                // 查询 GlassInfo 表
                List<GlassInfo> glassInfos = glassInfoMapper.selectList(queryWrapper2);
                if (glassInfos.isEmpty()) {
                    log.error("未找到对应的玻璃信息");
                    return Collections.emptyList(); // 返回空列表或者抛出异常，视情况而定
                }
                // Step 3: 构造查询 down_storage_cage_details 表的条件
                List<String> glassIds = glassInfos.stream().map(GlassInfo::getGlassId).collect(Collectors.toList());
                LambdaQueryWrapper<DownStorageCageDetails> cageDetailsQueryWrapper = Wrappers.lambdaQuery();
                cageDetailsQueryWrapper.in(DownStorageCageDetails::getGlassId, glassIds);
                cageDetailsQueryWrapper.in(DownStorageCageDetails::getFlowCardId, flowCardIds);
                cageDetailsQueryWrapper.eq(DownStorageCageDetails::getState, Const.GLASS_STATE_IN);
                log.info("按照流程卡的顺序出");
                // Step 4: 查询 down_storage_cage_details 表并返回结果
                return downStorageCageDetailsMapper.selectList(cageDetailsQueryWrapper);
            }


    }




    @Override
    public boolean identWorn(String glassId, int ControlsId) {
        List<DownStorageCageDetails> edgStorageCageDetails = baseMapper.selectList(new MPJLambdaQueryWrapper<DownStorageCageDetails>().selectAll(DownStorageCageDetails.class).eq(DownStorageCageDetails::getGlassId, glassId));
        if (edgStorageCageDetails.size() == 1) {
            DownStorageCageDetails item = edgStorageCageDetails.get(0);
            item.setState(ControlsId);
            baseMapper.update(item, new MPJLambdaWrapper<DownStorageCageDetails>().selectAll(DownStorageCageDetails.class).eq(DownStorageCageDetails::getGlassId, glassId));
            return true;
        }

        return false;
    }






}