package com.glxp.api.service.collect;

import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.pagehelper.PageHelper;
import com.glxp.api.dao.basic.BasicProductsDao;
import com.glxp.api.dao.collect.IoCollectOrderBizMapper;
import com.glxp.api.entity.basic.BasicProductsEntity;
import com.glxp.api.entity.basic.UdiProductEntity;
import com.glxp.api.entity.collect.IoCollectCodeBackup;
import com.glxp.api.entity.collect.IoCollectOrder;
import com.glxp.api.entity.collect.IoCollectOrderBiz;
import com.glxp.api.entity.collect.IoCollectOrderCodeMan;
import com.glxp.api.req.collect.CollectOrderBizRequest;
import com.glxp.api.res.collect.CollectOrderBizResponse;
import com.glxp.api.service.basic.UdiProductService;
import com.glxp.api.util.IntUtil;
import com.ibm.icu.text.UFormat;
import org.aspectj.weaver.ast.Var;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

@Service
public class IoCollectOrderBizService extends ServiceImpl<IoCollectOrderBizMapper, IoCollectOrderBiz> {

    @Resource
    IoCollectOrderBizMapper collectOrderBizMapper;

    @Resource
    private BasicProductsDao basicProductsDao;

    @Resource
    IoCollectCodeBackService ioCollectCodeBackService;


    public List<CollectOrderBizResponse> filterList(CollectOrderBizRequest collectOrderRequest) {
        if (collectOrderRequest == null) {
            return Collections.emptyList();
        }
        if (collectOrderRequest.getPage() != null) {
            int offset = (collectOrderRequest.getPage() - 1) * collectOrderRequest.getLimit();
            PageHelper.offsetPage(offset, collectOrderRequest.getLimit());
        }
        List<CollectOrderBizResponse> data = collectOrderBizMapper.filterList(collectOrderRequest);
        if (collectOrderRequest.getIsOrderCheck() == null) {
            for (CollectOrderBizResponse collectOrderBizResponse : data) {
                collectOrderBizResponse.setProductLocation(setProductName(collectOrderBizResponse));
            }
        }
        //设置 应该扫码数量 shouldCount
        if (data.size() > 0) {
            for (CollectOrderBizResponse collectOrderBizResponse : data) {
                List<Integer> integers = setShouldCount(collectOrderBizResponse);
                collectOrderBizResponse.setShouldCount(integers.get(0));
                collectOrderBizResponse.setSplitCount(integers.get(1));
                if (collectOrderBizResponse.getScanCount() == null) {
                    collectOrderBizResponse.setScanCount(0);
                }
                if (collectOrderBizResponse.getScanActCount() == null) {
                    collectOrderBizResponse.setScanActCount(0);
                }
                if (collectOrderBizResponse.getTempWorkPlaceCount() == null) {
                    collectOrderBizResponse.setTempWorkPlaceCount(0);
                }
            }
        }
        return data;
    }

    public String setProductName(CollectOrderBizResponse collectOrderBizResponse) {
        if (StrUtil.isEmpty(collectOrderBizResponse.getWorkplaceQueueCode())) {
            //todo 暂时解决办法
            return "";
        }
        String[] parts = collectOrderBizResponse.getWorkplaceQueueCode().split("-");
        String shelf = "";
        String layer = "";
        // 检查分割后的数组长度是否符合预期
        if (parts.length == 3) {
            // 分别赋值给对应的变量
            shelf = parts[0];  // 货架
            layer = parts[1];  // 层
        }
        StringBuilder sb = new StringBuilder();
        if (collectOrderBizResponse.getRegionName() != null && !collectOrderBizResponse.getRegionName().isEmpty()) {
            sb.append(collectOrderBizResponse.getRegionName());
        }
        if (collectOrderBizResponse.getFreightName() != null && !collectOrderBizResponse.getFreightName().isEmpty()) {
            if (sb.length() > 0) {
                sb.append("-");
            }
            sb.append(collectOrderBizResponse.getFreightName());
        }
        if (layer != null && !layer.isEmpty()) {
            if (sb.length() > 0) {
                sb.append("-");
            }
            sb.append(layer + "层");
        }
        return sb.toString();
    }


    public List<IoCollectOrderBiz> listByBillNo(String billNo) {
        List<IoCollectOrderBiz> list = super.list(Wrappers.lambdaQuery(IoCollectOrderBiz.class)
                .eq(IoCollectOrderBiz::getOrderIdFk, billNo)
        );
        return list;
    }


    public Boolean removeByBillNo(String billNo) {
        return remove(new LambdaQueryWrapper<IoCollectOrderBiz>().eq(IoCollectOrderBiz::getOrderIdFk, billNo));
    }

    public Boolean insertOrUpdate(IoCollectOrderBiz collectOrderBiz) {
        return collectOrderBizMapper.insertOrUpdate(collectOrderBiz);
    }


    @Resource
    IoCollectOrderCodeManService collectOrderCodeManService;

    public List<CollectOrderBizResponse> filterReturnOrderList(CollectOrderBizRequest collectOrderRequest, IoCollectOrder collectOrder) {
        if (collectOrderRequest == null) {
            return Collections.emptyList();
        }
        if (collectOrderRequest.getPage() != null) {
            int offset = (collectOrderRequest.getPage() - 1) * collectOrderRequest.getLimit();
            PageHelper.offsetPage(offset, collectOrderRequest.getLimit());
        }
        List<CollectOrderBizResponse> data = collectOrderBizMapper.filterList(collectOrderRequest);
        if (collectOrderRequest.getIsOrderCheck() == null) {
            for (CollectOrderBizResponse collectOrderBizResponse : data) {
                collectOrderBizResponse.setProductLocation(setProductName(collectOrderBizResponse));
            }
        }

        //设置 应该扫码数量 shouldCount
        if (data.size() > 0) {
            for (CollectOrderBizResponse collectOrderBizResponse : data) {
                List<IoCollectOrderCodeMan> collectOrderCodeManList = collectOrderCodeManService.list(
                        new LambdaQueryWrapper<IoCollectOrderCodeMan>()
                                .eq(IoCollectOrderCodeMan::getOrderIdFk, collectOrderRequest.getOrderIdFk())
                                .eq(IoCollectOrderCodeMan::getRelId,collectOrderBizResponse.getRelId()));
                List<IoCollectCodeBackup> list = ioCollectCodeBackService.list(new LambdaQueryWrapper<IoCollectCodeBackup>()
                        .eq(IoCollectCodeBackup::getBillNo, collectOrder.getRemark())
                        .eq(IoCollectCodeBackup::getRelId, collectOrderBizResponse.getRelId()));
                //获取整取
                List<IoCollectCodeBackup> fullList = list.stream()
                        .filter(item ->   item.getReCount() == null || item.getReCount() == 0)
                        .collect(Collectors.toList());

                //拆零
                List<IoCollectCodeBackup> spiltList = list.stream()
                        .filter(item -> {
                            Integer reCount = item.getReCount() == null ? 0 : item.getReCount();
                            return reCount > 0;
                        })
                        .collect(Collectors.toList());
                if (spiltList.size() > 0) {
                    if (collectOrderCodeManList.size() > 0){
                        // 提前将collectOrderCodeManList的udiCode提取到Set中，提升查找效率
                        Set<String> udiCodeSet = collectOrderCodeManList.stream()
                                .map(IoCollectOrderCodeMan::getUdiCode)
                                .collect(Collectors.toSet());

                        // 检查spiltList中的所有code是否都在udiCodeSet中
                        boolean allCodesPresent = spiltList.stream()
                                .allMatch(item -> udiCodeSet.contains(item.getCode()));
                        if (allCodesPresent) {
                            collectOrderBizResponse.setIsSplit(0);
                        }else {
                            collectOrderBizResponse.setIsSplit(1);
                        }
                    }else {
                        collectOrderBizResponse.setIsSplit(1);
                    }

                }
                List<BasicProductsEntity> productList = basicProductsDao.selectList(
                        new LambdaQueryWrapper<BasicProductsEntity>()
                                .eq(BasicProductsEntity::getYbbm, collectOrderBizResponse.getYbbm())
                                .eq(BasicProductsEntity::getPackLevel, "1"));
                BasicProductsEntity product = productList.get(0);
                Integer myBhxjsl = product.getBhxjsl();
                Integer shouldCount = 0;
                double quotient = (double) collectOrderBizResponse.getCount() / myBhxjsl;
                int integerPart = (int) quotient;
                if (quotient == integerPart) {
                    if (integerPart == 0) {
                        if (collectOrderBizResponse.getAutoTagStatus() != 2) {
                            shouldCount = 1;
                        }
                    } else {
                        shouldCount = integerPart;
                    }
                } else {
                    if (IntUtil.value(collectOrderBizResponse.getAutoTagStatus()) == 2) {
                        shouldCount = 0;
                    } else {
                        shouldCount = integerPart + 1;
                    }
                }
                collectOrderBizResponse.setShouldCount(shouldCount);
                if (collectOrderBizResponse.getScanCount() == null) {
                    collectOrderBizResponse.setScanCount(0);
                }
                if (collectOrderBizResponse.getScanActCount() == null) {
                    collectOrderBizResponse.setScanActCount(0);
                }
            }
        }
        return data;
    }

    public List<Integer> setShouldCount(CollectOrderBizResponse collectOrderBizResponse){
        ArrayList<Integer> integers = new ArrayList<>();
        List<BasicProductsEntity> productList = basicProductsDao.selectList(
                new LambdaQueryWrapper<BasicProductsEntity>()
                        .eq(BasicProductsEntity::getYbbm, collectOrderBizResponse.getYbbm())
                        .eq(BasicProductsEntity::getPackLevel, "1"));
        BasicProductsEntity product = productList.get(0);
        Integer myBhxjsl = product.getBhxjsl();
        Integer shouldCount = 0;
        int remainder = collectOrderBizResponse.getCount() % myBhxjsl;
        double quotient = (double) collectOrderBizResponse.getCount() / myBhxjsl;
        int integerPart = (int) quotient;
        if (quotient == integerPart) {
            if (integerPart == 0) {
            } else {
                shouldCount = integerPart;
            }
        } else {
            if (IntUtil.value(collectOrderBizResponse.getAutoTagStatus()) == 2) {
                shouldCount = 0;
            } else {
                shouldCount = integerPart;
            }
        }
        integers.add(shouldCount);
        integers.add(remainder);
        return integers;
    }
}