package com.qianwen.smartman.modules.cps.service.impl;

import com.alibaba.excel.write.merge.AbstractMergeStrategy;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.google.common.collect.Lists;
import java.lang.invoke.SerializedLambda;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import com.qianwen.smartman.common.constant.CommonConstant;
import com.qianwen.smartman.common.constant.ExcelConstant;
import com.qianwen.smartman.common.utils.MessageUtils;
import com.qianwen.core.excel.util.ExcelUtil;
import com.qianwen.core.mp.service.impl.BladeServiceImpl;
import com.qianwen.core.mp.support.Condition;
import com.qianwen.core.mp.support.Query;
import com.qianwen.core.oss.model.BladeFile;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.smartman.modules.cps.convert.MaterialStorageConvert;
import com.qianwen.smartman.modules.cps.entity.Material;
import com.qianwen.smartman.modules.cps.entity.MaterialStorage;
import com.qianwen.smartman.modules.cps.entity.WarehouseStation;
import com.qianwen.smartman.modules.cps.excel.MaterialStorageImport;
import com.qianwen.smartman.modules.cps.mapper.MaterialStorageMapper;
import com.qianwen.smartman.modules.cps.service.IMaterialService;
import com.qianwen.smartman.modules.cps.service.IMaterialStorageService;
import com.qianwen.smartman.modules.cps.service.IWarehouseStationService;
import com.qianwen.smartman.modules.cps.utils.StringUtils;
import com.qianwen.smartman.modules.cps.utils.ThrowFun;
import com.qianwen.smartman.modules.cps.vo.MaterialStorageAddVO;
import com.qianwen.smartman.modules.cps.vo.MaterialStorageVO;
import com.qianwen.smartman.modules.cps.vo.MaterialVO;
import com.qianwen.smartman.modules.cps.vo.WareMaterialStorageVO;
import com.qianwen.smartman.modules.resource.builder.oss.OssBuilder;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

@Service
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/cps/service/impl/MaterialStorageServiceImpl.class */
public class MaterialStorageServiceImpl extends BladeServiceImpl<MaterialStorageMapper, MaterialStorage> implements IMaterialStorageService {
    private final IWarehouseStationService warehouseStationService;
    private final IMaterialService materialService;
    private final OssBuilder ossBuilder;

    private static /* synthetic */ Object $deserializeLambda$(SerializedLambda lambda) {
        String implMethodName = lambda.getImplMethodName();
        boolean z = true;
        switch (implMethodName.hashCode()) {
            case -75622813:
                if (implMethodName.equals("getCode")) {
                    z = true;
                    break;
                }
                break;
            case 1929248666:
                if (implMethodName.equals("getWarehouseCode")) {
                    z = false;
                    break;
                }
                break;
        }
        switch (z) {
            case false:
                if (lambda.getImplMethodKind() == 5 && lambda.getFunctionalInterfaceClass().equals("com/baomidou/mybatisplus/core/toolkit/support/SFunction") && lambda.getFunctionalInterfaceMethodName().equals("apply") && lambda.getFunctionalInterfaceMethodSignature().equals("(Ljava/lang/Object;)Ljava/lang/Object;") && lambda.getImplClass().equals("org/springblade/modules/cps/entity/WarehouseStation") && lambda.getImplMethodSignature().equals("()Ljava/lang/String;")) {
                    return (v0) -> {
                        return v0.getWarehouseCode();
                    };
                }
                break;
            case true:
                if (lambda.getImplMethodKind() == 5 && lambda.getFunctionalInterfaceClass().equals("com/baomidou/mybatisplus/core/toolkit/support/SFunction") && lambda.getFunctionalInterfaceMethodName().equals("apply") && lambda.getFunctionalInterfaceMethodSignature().equals("(Ljava/lang/Object;)Ljava/lang/Object;") && lambda.getImplClass().equals("org/springblade/modules/cps/entity/Material") && lambda.getImplMethodSignature().equals("()Ljava/lang/String;")) {
                    return (v0) -> {
                        return v0.getCode();
                    };
                }
                break;
        }
        throw new IllegalArgumentException("Invalid lambda deserialization");
    }

    public MaterialStorageServiceImpl(final IWarehouseStationService warehouseStationService, final IMaterialService materialService, final OssBuilder ossBuilder) {
        this.warehouseStationService = warehouseStationService;
        this.materialService = materialService;
        this.ossBuilder = ossBuilder;
    }

    @Override // org.springblade.modules.cps.service.IMaterialStorageService
    public List<WareMaterialStorageVO> listMaterial(Long wareId, String keyword) {
        return this.baseMapper.listMaterial(wareId, keyword);
    }

    @Override // org.springblade.modules.cps.service.IMaterialStorageService
    public List<MaterialStorageVO> addMaterialStorage(MaterialStorageAddVO vo) {
        List<Long> materialIds = vo.getMaterialIds();
        Long warehouseStationId = vo.getWarehouseStationId();
        if (Func.isNotEmpty(materialIds)) {
            List<MaterialStorage> storages = (List) materialIds.stream().map(c -> {
                return convert(c, warehouseStationId);
            }).collect(Collectors.toList());
            saveBatch(storages);
            return MaterialStorageConvert.INSTANCE.convert(storages);
        }
        return Lists.newArrayList();
    }

    @Override // org.springblade.modules.cps.service.IMaterialStorageService
    public List<MaterialVO> materialNotBind() {
        return this.baseMapper.materialNotBind();
    }

    @Override // org.springblade.modules.cps.service.IMaterialStorageService
    public BladeFile importMaterialStorage(MultipartFile file) {
        List<MaterialStorageImport> rawData = ExcelUtil.read(file, 0, 2, MaterialStorageImport.class);
        ThrowFun.isTrue(Func.isEmpty(rawData)).throwMessage(MessageUtils.message("excel.import.data.can.not.be.null", new Object[0]));
        ThrowFun.isTrue(rawData.size() > 200).throwMessage(MessageUtils.message("excel.import.size.failed", new Object[0]));
        Map<String, WarehouseStation> warehouseStationMap = new HashMap<>(rawData.size());
        Map<String, Material> materialMap = new HashMap<>(rawData.size());
        getMaterialStorage(rawData, warehouseStationMap, materialMap);
        List<MaterialStorage> materialStorageList = list();
        Set<Long> materialIds = (Set) materialStorageList.stream().map((v0) -> {
            return v0.getMaterialId();
        }).collect(Collectors.toSet());
        List<MaterialStorageImport> failExcel = Lists.newArrayList();
        for (MaterialStorageImport data : rawData) {
            boolean validImport = validImport(data, warehouseStationMap, materialMap, materialIds, failExcel);
            if (validImport) {
                break;
            }
        }
        if (Func.isNotEmpty(failExcel)) {
            return exportFailFile(failExcel);
        }
        saveMaterialStorage(rawData, warehouseStationMap, materialMap, materialStorageList);
        return null;
    }

    @Override // org.springblade.modules.cps.service.IMaterialStorageService
    public IPage<WareMaterialStorageVO> pageMaterial(Query query, Long wareId, String keyword) {
        return this.baseMapper.pageMaterial(Condition.getPage(query), wareId, keyword);
    }

    private void saveMaterialStorage(List<MaterialStorageImport> rawData, Map<String, WarehouseStation> warehouseStationMap, Map<String, Material> materialMap, List<MaterialStorage> materialStorageList) {
        List<MaterialStorage> materialStorages = Lists.newArrayList();
        rawData.forEach(data -> {
            WarehouseStation warehouseStation = (WarehouseStation) warehouseStationMap.get(data.getLocationCode());
            Material material = (Material) materialMap.get(data.getMaterialCode());
            MaterialStorage materialStorage = buildMaterialStorage(warehouseStation, material);
            materialStorages.add(materialStorage);
        });
        Map<String, MaterialStorage> storageMap = (Map) materialStorageList.stream().collect(Collectors.toMap(k -> {
            return StringUtils.getKey(k.getMaterialId(), k.getWarehouseStationId());
        }, v -> {
            return v;
        }));
        List<MaterialStorage> collect = (List) materialStorages.stream().filter(k2 -> {
            return !storageMap.containsKey(StringUtils.getKey(k2.getMaterialId(), k2.getWarehouseStationId()));
        }).distinct().collect(Collectors.toList());
        if (Func.isNotEmpty(collect)) {
            saveBatch(collect);
        }
    }

    private MaterialStorage buildMaterialStorage(WarehouseStation warehouseStation, Material material) {
        return new MaterialStorage().setMaterialId(material.getId()).setWarehouseStationId(warehouseStation.getId());
    }

    private BladeFile exportFailFile(List<MaterialStorageImport> failExcel) {
        MultipartFile multipartFile = ExcelUtil.exportFillTemplateToMultipartFile(ExcelConstant.DIRECTORY + "materialStorageFailTemplate" + ExcelConstant.SUFFIX, MessageUtils.message("excel.import.failed.report.name", new Object[0]) + ExcelConstant.SUFFIX, ExcelConstant.SHEET, failExcel, (Object) null, (AbstractMergeStrategy) null);
        return this.ossBuilder.tempTemplate().putFile(multipartFile.getOriginalFilename(), multipartFile);
    }

    private boolean validImport(MaterialStorageImport data, Map<String, WarehouseStation> warehouseStationMap, Map<String, Material> materialMap, Set<Long> materialIds, List<MaterialStorageImport> failExcel) {
        boolean validLocation = validLocation(data, warehouseStationMap, failExcel);
        if (validLocation) {
            return true;
        }
        return validMaterial(data, materialMap, materialIds, failExcel);
    }

    private boolean validMaterial(MaterialStorageImport data, Map<String, Material> materialMap, Set<Long> materialIds, List<MaterialStorageImport> failExcel) {
        String materialCode = data.getMaterialCode();
        if (Func.isBlank(materialCode)) {
            data.setFailReason(MessageUtils.message("excel.export.material.code.not.be.null", new Object[0]));
            failExcel.add(data);
            return true;
        }
        Material material = materialMap.get(materialCode);
        if (Func.isEmpty(material)) {
            data.setFailReason(MessageUtils.message("excel.export.material.code.system.not.exists", new Object[0]));
            failExcel.add(data);
            return true;
        } else if (CommonConstant.DEACTIVATE.equals(material.getStatus())) {
            data.setFailReason(MessageUtils.message("excel.export.material.code.system.not.exists", new Object[0]));
            failExcel.add(data);
            return true;
        } else if (materialIds.contains(material.getId())) {
            data.setFailReason(MessageUtils.message("excel.export.material.code.bind", new Object[0]));
            failExcel.add(data);
            return true;
        } else {
            return false;
        }
    }

    private boolean validLocation(MaterialStorageImport data, Map<String, WarehouseStation> warehouseStationMap, List<MaterialStorageImport> failExcel) {
        String locationCode = data.getLocationCode();
        if (Func.isBlank(locationCode)) {
            data.setFailReason(MessageUtils.message("excel.export.station.code.not.be.null", new Object[0]));
            failExcel.add(data);
            return true;
        }
        WarehouseStation warehouseStation = warehouseStationMap.get(locationCode);
        if (Func.isEmpty(warehouseStation)) {
            data.setFailReason(MessageUtils.message("excel.export.station.code.system.exists", new Object[0]));
            failExcel.add(data);
            return true;
        } else if (CommonConstant.DEACTIVATE.equals(warehouseStation.getStatus())) {
            data.setFailReason(MessageUtils.message("excel.export.material.code.disable.system.not.exists", new Object[0]));
            failExcel.add(data);
            return true;
        } else {
            return false;
        }
    }

    private void getMaterialStorage(List<MaterialStorageImport> rawData, Map<String, WarehouseStation> warehouseStationMap, Map<String, Material> materialMap) {
        Wrapper lambdaQuery = Wrappers.lambdaQuery();
        boolean flag1 = false;
        boolean flag2 = false;
        Wrapper lambdaQuery2 = Wrappers.lambdaQuery();
        for (MaterialStorageImport data : rawData) {
            if (requiredLocation(data)) {
                if (flag1) {
                    lambdaQuery.or();
                }
                flag1 = true;
                lambdaQuery.nested(i -> {
                    LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) i.eq((v0) -> {
                        return v0.getWarehouseCode();
                    }, data.getLocationCode());
                });
            }
            if (requiredMaterial(data)) {
                if (flag2) {
                    lambdaQuery2.or();
                }
                flag2 = true;
                lambdaQuery2.nested(i2 -> {
                    LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) i2.eq((v0) -> {
                        return v0.getCode();
                    }, data.getMaterialCode());
                });
            }
        }
        String sqlSegment1 = lambdaQuery.getSqlSegment();
        if (Func.isNotBlank(sqlSegment1)) {
            List<WarehouseStation> warehouseStations = this.warehouseStationService.list(lambdaQuery);
            if (Func.isNotEmpty(warehouseStations)) {
                Map<String, WarehouseStation> map1 = (Map) warehouseStations.stream().collect(Collectors.toMap((v0) -> {
                    return v0.getWarehouseCode();
                }, v -> {
                    return v;
                }));
                warehouseStationMap.putAll(map1);
            }
        }
        String sqlSegment2 = lambdaQuery2.getSqlSegment();
        if (Func.isNotBlank(sqlSegment2)) {
            List<Material> materials = this.materialService.list(lambdaQuery2);
            if (Func.isNotEmpty(materials)) {
                Map<String, Material> map2 = (Map) materials.stream().collect(Collectors.toMap((v0) -> {
                    return v0.getCode();
                }, v2 -> {
                    return v2;
                }));
                materialMap.putAll(map2);
            }
        }
    }

    private boolean requiredLocation(MaterialStorageImport data) {
        return Func.isNotBlank(data.getLocationCode());
    }

    private boolean requiredMaterial(MaterialStorageImport data) {
        return Func.isNotBlank(data.getMaterialCode());
    }

    private MaterialStorage convert(Long material, Long warehouseStationId) {
        return new MaterialStorage().setMaterialId(material).setWarehouseStationId(warehouseStationId);
    }
}