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

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;

import javax.servlet.http.HttpServletResponse;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import com.alibaba.excel.write.merge.AbstractMergeStrategy;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.qianwen.core.excel.util.ExcelUtil;
import com.qianwen.core.log.exception.ServiceException;
import com.qianwen.core.mp.base.BaseServiceImpl;
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.DateUtil;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.core.tool.utils.StringUtil;
import com.qianwen.smartman.common.constant.CommonConstant;
import com.qianwen.smartman.common.constant.CommonGroupConstant;
import com.qianwen.smartman.common.constant.ExcelConstant;
import com.qianwen.smartman.common.utils.MessageUtils;
import com.qianwen.smartman.modules.cps.convert.WarehouseStationConvert;
import com.qianwen.smartman.modules.cps.entity.MaterialStorage;
import com.qianwen.smartman.modules.cps.entity.TrayStorage;
import com.qianwen.smartman.modules.cps.entity.WarehouseArea;
import com.qianwen.smartman.modules.cps.entity.WarehouseGrid;
import com.qianwen.smartman.modules.cps.entity.WarehouseStation;
import com.qianwen.smartman.modules.cps.excel.WarehouseStationExcel;
import com.qianwen.smartman.modules.cps.excel.WarehouseStationImport;
import com.qianwen.smartman.modules.cps.mapper.MaterialStorageMapper;
import com.qianwen.smartman.modules.cps.mapper.WarehouseAreaMapper;
import com.qianwen.smartman.modules.cps.mapper.WarehouseGridMapper;
import com.qianwen.smartman.modules.cps.mapper.WarehouseStationMapper;
import com.qianwen.smartman.modules.cps.service.ITrayStorageService;
import com.qianwen.smartman.modules.cps.service.IWarehouseStationService;
import com.qianwen.smartman.modules.cps.vo.WarehouseExportVO;
import com.qianwen.smartman.modules.cps.vo.WarehouseStationVO;
import com.qianwen.smartman.modules.resource.builder.oss.OssBuilder;
import com.qianwen.smartman.modules.system.service.ICodeGeneratorService;
import com.qianwen.smartman.modules.tpm.enums.MetaTypeEnum;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.StrUtil;

@Service
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/cps/service/impl/WarehouseStationServiceImpl.class */
public class WarehouseStationServiceImpl extends BaseServiceImpl<WarehouseStationMapper, WarehouseStation> implements IWarehouseStationService {
    private final WarehouseGridMapper warehouseGridMapper;
    private final WarehouseAreaMapper warehouseAreaMapper;
    private final OssBuilder ossBuilder;
    private final WarehouseStationMapper warehouseStationMapper;
    private final MaterialStorageMapper storageMapper;
    private final ITrayStorageService trayStorageService;
    private final ICodeGeneratorService codeGeneratorService;
    private static final Logger log = LoggerFactory.getLogger(WarehouseStationServiceImpl.class);
    private static final Map<String, WarehouseArea> AREAS_CACHE = new HashMap();
    public static final Integer TYPE_CODE = 1;
    public static final Integer TYPE_NAME = 2;


    public WarehouseStationServiceImpl(final WarehouseGridMapper warehouseGridMapper, final WarehouseAreaMapper warehouseAreaMapper, final OssBuilder ossBuilder, final WarehouseStationMapper warehouseStationMapper, final MaterialStorageMapper storageMapper, final ITrayStorageService trayStorageService, final ICodeGeneratorService codeGeneratorService) {
        this.warehouseGridMapper = warehouseGridMapper;
        this.warehouseAreaMapper = warehouseAreaMapper;
        this.ossBuilder = ossBuilder;
        this.warehouseStationMapper = warehouseStationMapper;
        this.storageMapper = storageMapper;
        this.trayStorageService = trayStorageService;
        this.codeGeneratorService = codeGeneratorService;
    }

    @Override // org.springblade.modules.cps.service.IWarehouseStationService
    @Transactional(rollbackFor = {Exception.class})
    public Boolean deleteByIds(List<Long> ids) {
    	 
    	 
    	Long gridCont = this.warehouseGridMapper.selectCount(new QueryWrapper<WarehouseGrid>().lambda().in(WarehouseGrid::getStationId, ids));
        Long materialCount = this.storageMapper.selectCount(Wrappers.lambdaQuery(MaterialStorage.class).in(MaterialStorage::getWarehouseStationId, ids));
        long trayStorageCount = this.trayStorageService.count(Wrappers.lambdaQuery(TrayStorage.class).in(TrayStorage::getWarehouseStationId, ids));
        
    	/*
        Long gridCont = this.warehouseGridMapper.selectCount((Wrapper) new QueryWrapper().lambda().in((v0) -> {
            return v0.getStationId();
        }, ids));
        Long materialCount = this.storageMapper.selectCount((Wrapper) Wrappers.lambdaQuery(MaterialStorage.class).in((v0) -> {
            return v0.getWarehouseStationId();
        }, ids));
        long trayStorageCount = this.trayStorageService.count((Wrapper) Wrappers.lambdaQuery(TrayStorage.class).in((v0) -> {
            return v0.getWarehouseStationId();
        }, ids));
        */
        if (gridCont.longValue() > 0) {
            throw new ServiceException(MessageUtils.message("cps.warehouse.station.not.delete", new Object[0]));
        }
        if (materialCount.longValue() > 0) {
            throw new ServiceException(MessageUtils.message("cps.warehouse.station.not.delete.to.material", new Object[0]));
        }
        if (trayStorageCount > 0) {
            throw new ServiceException(MessageUtils.message("cps.warehouse.station.not.delete.to.tray.storage", new Object[0]));
        }
        return Boolean.valueOf(removeByIds(ids));
    }

    @Override // org.springblade.modules.cps.service.IWarehouseStationService
    @Transactional(rollbackFor = {Exception.class})
    public BladeFile importStation(MultipartFile multipartFile) {
        if (Objects.isNull(multipartFile)) {
            throw new ServiceException(MessageUtils.message("excel.import.file.is.null", new Object[0]));
        }
        List<WarehouseStationImport> warehouseStationImports = ExcelUtil.read(multipartFile, 0, 2, WarehouseStationImport.class);
        if (CollectionUtil.isEmpty(warehouseStationImports)) {
            throw new ServiceException(MessageUtils.message("excel.import.data.can.not.be.null", new Object[0]));
        }
        if (warehouseStationImports.size() > 200) {
            throw new ServiceException(MessageUtils.message("excel.import.size.failed", new Object[0]));
        }
        checkImportData(warehouseStationImports);
        List<WarehouseStationImport> fails = warehouseStationImports.stream().filter(w -> {
            return StrUtil.isNotEmpty(w.getFailReason());
        }).collect(Collectors.toList());
        if (fails.size() > CommonConstant.ZERO.intValue()) {
            MultipartFile template = ExcelUtil.exportFillTemplateToMultipartFile(ExcelConstant.DIRECTORY + "workhouseStationFailTemplate" + ExcelConstant.SUFFIX, MessageUtils.message("excel.import.failed.report.name", new Object[0]) + ExcelConstant.SUFFIX, "库位信息表", fails, (Object) null, (AbstractMergeStrategy) null);
            return this.ossBuilder.tempTemplate().putFile(template.getOriginalFilename(), template);
        }
        saveWarehouseStation(warehouseStationImports);
        return null;
    }

    @Override // org.springblade.modules.cps.service.IWarehouseStationService
    public BladeFile exportStation(WarehouseExportVO warehouseExportVo, HttpServletResponse response) {
        if (CommonGroupConstant.WARE_ROOT.equals(warehouseExportVo.getAreaId())) {
            warehouseExportVo.setAreaId(null);
        }
        List<WarehouseStation> list = this.warehouseStationMapper.listPage(null, warehouseExportVo.getKeyword(), warehouseExportVo.getAreaId());
        List<WarehouseStationExcel> result = WarehouseStationConvert.INSTANCE.convertToExcel(list);
        String fileName = String.format("%s-%s.xlsx", "库位信息表", DateUtil.time());
        MultipartFile multipartFile = ExcelUtil.exportToMultipartFile(fileName, "库位信息表", result, WarehouseStationExcel.class);
        return this.ossBuilder.tempTemplate().putFile(multipartFile.getOriginalFilename(), multipartFile);
    }

    private void saveWarehouseStation(List<WarehouseStationImport> success) {
        List<WarehouseStation> stationList = success.parallelStream().map(station -> {
            WarehouseArea area = AREAS_CACHE.get(station.getWarehouseAreaCode());
            WarehouseStation warehouseStation = WarehouseStationConvert.INSTANCE.convert(station);
            warehouseStation.setAreaId(area.getId());
            return warehouseStation;
        }).collect(Collectors.toList());
        saveBatch(stationList);
        AREAS_CACHE.clear();
    }

    private void checkImportData(List<WarehouseStationImport> imports) {
        List<String> includeAreaCodes = imports.parallelStream().map((v0) -> {
            return v0.getWarehouseAreaCode();
        }).collect(Collectors.toList());
        List<WarehouseArea> warehouseAreas = this.warehouseAreaMapper.selectList(Wrappers.lambdaQuery(WarehouseArea.class)
        		.in(WarehouseArea::getCode, includeAreaCodes)
        		.select(WarehouseArea::getId, WarehouseArea::getCode ));
        
        
        Map<String, WarehouseArea> areaMap = warehouseAreas.parallelStream().collect(Collectors.toMap((v0) -> {
            return v0.getCode();
        }, warehouseArea -> {
            return warehouseArea;
        }, (oldVal, currVal) -> {
            return currVal;
        }));
        Map<Long, WarehouseArea> areaIdMap = warehouseAreas.parallelStream().collect(Collectors.toMap((v0) -> {
            return v0.getId();
        }, warehouseArea2 -> {
            return warehouseArea2;
        }, (oldVal2, currVal2) -> {
            return currVal2;
        }));
        AREAS_CACHE.putAll(areaMap);
        List<String> importCodes = imports.parallelStream().map((v0) -> {
            return v0.getWarehouseCode();
        }).collect(Collectors.toList());
        List<String> importNames = imports.parallelStream().map((v0) -> {
            return v0.getWarehouseName();
        }).collect(Collectors.toList());
        List<WarehouseStation> warehouseStations = list(Wrappers.lambdaQuery(WarehouseStation.class)
        		.in(WarehouseStation::getWarehouseCode, importCodes)
        		.or().in(WarehouseStation::getWarehouseName, importNames))
        		.parallelStream().peek(w -> {
	            w.setWarehouseAreaCode(((WarehouseArea) areaIdMap.get(w.getAreaId())).getCode());
	        }).collect(Collectors.toList());
        
        Map<String, Object> stationCodeMap = getVerifyList(Boolean.TRUE, warehouseStations);
        Map<String, Object> stationNameMap = getVerifyList(Boolean.FALSE, warehouseStations);
        imports.parallelStream().forEachOrdered(stationImport -> {
            if (StringUtil.isEmpty(stationImport.getWarehouseCode())) {
                stationImport.setWarehouseCode(warehouseStationCodeGenerator(WarehouseStationConvert.INSTANCE.convertImportToVo(stationImport)));
            }
            if (StringUtil.isEmpty(stationImport.getWarehouseAreaCode())) {
                stationImport.setFailReason(MessageUtils.message("cps.warehouse.area.code.can.not.be.empty", new Object[0]));
            } else if (!exitsArea(stationImport.getWarehouseAreaCode(), warehouseAreas).booleanValue()) {
                stationImport.setFailReason(MessageUtils.message("cps.warehouse.area.not.exists", new Object[0]));
            } else if (checkIsEveryGroup(stationImport.getWarehouseAreaCode(), warehouseAreas).booleanValue()) {
                stationImport.setFailReason(MessageUtils.message("cps.warehouse.station.import.area.not.be.every", new Object[0]));
            } else if (checkStation(stationImport, stationCodeMap, TYPE_CODE.intValue()).booleanValue()) {
                stationImport.setFailReason(MessageUtils.message("cps.warehouse.station.code.is.not.only", new Object[0]));
            } else if (StringUtil.isEmpty(stationImport)) {
                stationImport.setFailReason(MessageUtils.message("cps.warehouse.location.name.can.not.be.null", new Object[0]));
            } else if (checkStation(stationImport, stationNameMap, TYPE_NAME.intValue()).booleanValue()) {
                stationImport.setFailReason(MessageUtils.message("cps.warehouse.station.name.is.not.only", new Object[0]));
            }
        });
    }

    private HashMap<String, Object> getVerifyList(Boolean isCode, List<WarehouseStation> warehouseStations) {
        Function<WarehouseStation, String> function = x -> {
            return isCode.booleanValue() ? x.getWarehouseAreaCode() + "-" + x.getWarehouseCode() : x.getWarehouseAreaCode() + "-" + x.getWarehouseName();
        };
        
        return warehouseStations.parallelStream().collect(HashMap::new, (map, item) -> map.put(function.apply(item), null), HashMap::putAll);
        /*
        return (HashMap) warehouseStations.parallelStream().collect(HashMap::new, map, item -> {
            map.put(function.apply(item), null);
        }, (v0, v1) -> {
            v0.putAll(v1);
        });*/
    }

    private Boolean exitsArea(String areaCode, List<WarehouseArea> warehouseAreas) {
        return Boolean.valueOf(warehouseAreas.parallelStream().anyMatch(w -> {
            return w.getCode().equals(areaCode);
        }));
    }

    private Boolean checkIsEveryGroup(String areaCode, List<WarehouseArea> warehouseAreas) {
        return Boolean.valueOf(warehouseAreas.parallelStream().anyMatch(area -> {
            return area.getCode().equals(areaCode) && area.getId().equals(1L);
        }));
    }

    private Boolean checkStation(WarehouseStationImport warehouseStationImport, Map<String, Object> stationMap, int type) {
        String key = type == TYPE_CODE.intValue() ? warehouseStationImport.getWarehouseAreaCode() + "-" + warehouseStationImport.getWarehouseCode() : warehouseStationImport.getWarehouseAreaCode() + "-" + warehouseStationImport.getWarehouseName();
        if (stationMap.containsKey(key)) {
            return Boolean.TRUE;
        }
        stationMap.put(key, null);
        return Boolean.FALSE;
    }

    @Override // org.springblade.modules.cps.service.IWarehouseStationService
    public IPage<WarehouseStation> listPage(Query query, String keyWord, Long areaId) {
        IPage<WarehouseStation> page = Condition.getPage(query);
        if (CommonGroupConstant.WARE_ROOT.equals(areaId)) {
            areaId = null;
        }
        return page.setRecords(this.warehouseStationMapper.listPage(page, keyWord, areaId));
    }

    @Override // org.springblade.modules.cps.service.IWarehouseStationService
    public WarehouseStation insert(WarehouseStationVO warehouseStationVO) {
        warehouseStationVO.setWarehouseCode(StrUtil.isEmpty(warehouseStationVO.getWarehouseCode()) ? warehouseStationCodeGenerator(warehouseStationVO) : warehouseStationVO.getWarehouseCode());
        verifyCodeAndName(warehouseStationVO);
        WarehouseStation warehouseStation = WarehouseStationConvert.INSTANCE.convert(warehouseStationVO);
        save(warehouseStation);
        return warehouseStation;
    }

    @Override // org.springblade.modules.cps.service.IWarehouseStationService
    public WarehouseStation modifyById(WarehouseStationVO warehouseStationVO) {
        verifyCodeAndName(warehouseStationVO);
        WarehouseStation warehouseStation = WarehouseStationConvert.INSTANCE.convert(warehouseStationVO);
        updateById(warehouseStation);
        return warehouseStation;
    }

    @Override // org.springblade.modules.cps.service.IWarehouseStationService
    public List<WarehouseStationVO> getWarehouseStationList(Set<Long> ids) {
        return ((WarehouseStationMapper) this.baseMapper).getWarehouseStationList(ids);
    }

    public void verifyCodeAndName(WarehouseStationVO warehouseStation) {
    	LambdaQueryWrapper<WarehouseStation> codeWrapper = Wrappers.lambdaQuery(WarehouseStation.class).eq(WarehouseStation::getAreaId, warehouseStation.getAreaId()).ne(Func.isNotEmpty(warehouseStation.getId()), WarehouseStation::getId, warehouseStation.getId()).eq(WarehouseStation::getWarehouseCode, warehouseStation.getWarehouseCode());
        LambdaQueryWrapper<WarehouseStation> nameWrapper = Wrappers.lambdaQuery(WarehouseStation.class).eq(WarehouseStation::getAreaId, warehouseStation.getAreaId()).ne(Func.isNotEmpty(warehouseStation.getId()), WarehouseStation::getId, warehouseStation.getId()).eq(WarehouseStation::getWarehouseName, warehouseStation.getWarehouseName());
        /*
        LambdaQueryWrapper<WarehouseStation> codeWrapper = (LambdaQueryWrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery(WarehouseStation.class).eq((v0) -> {
            return v0.getAreaId();
        }, warehouseStation.getAreaId())).ne(Func.isNotEmpty(warehouseStation.getId()), (v0) -> {
            return v0.getId();
        }, warehouseStation.getId()).eq((v0) -> {
            return v0.getWarehouseCode();
        }, warehouseStation.getWarehouseCode());
        LambdaQueryWrapper<WarehouseStation> nameWrapper = (LambdaQueryWrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery(WarehouseStation.class).eq((v0) -> {
            return v0.getAreaId();
        }, warehouseStation.getAreaId())).ne(Func.isNotEmpty(warehouseStation.getId()), (v0) -> {
            return v0.getId();
        }, warehouseStation.getId()).eq((v0) -> {
            return v0.getWarehouseName();
        }, warehouseStation.getWarehouseName());*/
        long codeCount = count(codeWrapper);
        if (codeCount > 0) {
            throw new ServiceException(MessageUtils.message("cps.warehouse.station.code.is.not.only", new Object[0]));
        }
        long nameCount = count(nameWrapper);
        if (nameCount > 0) {
            throw new ServiceException(MessageUtils.message("cps.warehouse.station.name.is.not.only", new Object[0]));
        }
    }

    private String warehouseStationCodeGenerator(WarehouseStationVO warehouseStationVO, String typeId) {
        String code = this.codeGeneratorService.getGeneratorCode(warehouseStationVO, typeId);
        if (StrUtil.isEmpty(code)) {
            throw new ServiceException(MessageUtils.message("cps.tpm.maintain.coding.rules", new Object[0]));
        }
        return code;
    }

    private String warehouseStationCodeGenerator(WarehouseStationVO warehouseStationVO) {
        return warehouseStationCodeGenerator(warehouseStationVO, MetaTypeEnum.WAREHOUSE_STATION.getCode());
    }
}