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

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import java.lang.invoke.SerializedLambda;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import com.qianwen.smartman.common.utils.MessageUtils;
import com.qianwen.core.log.exception.ServiceException;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.smartman.modules.cps.convert.ProcessAssociationConvert;
import com.qianwen.smartman.modules.cps.entity.ProcessAssociation;
import com.qianwen.smartman.modules.cps.entity.Supplier;
import com.qianwen.smartman.modules.cps.entity.WarehouseArea;
import com.qianwen.smartman.modules.cps.entity.Workstation;
import com.qianwen.smartman.modules.cps.mapper.ProcessAssociationMapper;
import com.qianwen.smartman.modules.cps.service.IProcessAssociationService;
import com.qianwen.smartman.modules.cps.service.ISupplierService;
import com.qianwen.smartman.modules.cps.service.IWarehouseAreaService;
import com.qianwen.smartman.modules.cps.service.IWorkstationService;
import com.qianwen.smartman.modules.cps.vo.ProcessAssociationDetailVO;
import com.qianwen.smartman.modules.cps.vo.ProcessAssociationSaveVO;
import com.qianwen.smartman.modules.cps.vo.ProcessAssociationVO;
import com.qianwen.smartman.modules.cps.vo.ProcessSupplierTypeVO;
import com.qianwen.smartman.modules.cps.vo.ProcessWarehouseAreaTypeVO;
import com.qianwen.smartman.modules.cps.vo.ProcessWorkstationTypeVO;
import org.springframework.stereotype.Service;

@Service
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/cps/service/impl/ProcessAssociationServiceImpl.class */
public class ProcessAssociationServiceImpl extends ServiceImpl<ProcessAssociationMapper, ProcessAssociation> implements IProcessAssociationService {
    private final IWorkstationService workstationService;
    private final ISupplierService supplierService;
    private final IWarehouseAreaService warehouseAreaService;


    public ProcessAssociationServiceImpl(final IWorkstationService workstationService, final ISupplierService supplierService, final IWarehouseAreaService warehouseAreaService) {
        this.workstationService = workstationService;
        this.supplierService = supplierService;
        this.warehouseAreaService = warehouseAreaService;
    }

    @Override // org.springblade.modules.cps.service.IProcessAssociationService
    public ProcessAssociationVO listAssociation(Long processId) {
        ProcessAssociationVO processAssociationVO = new ProcessAssociationVO();
        List<ProcessAssociation> processAssociationList = list(Wrappers.<ProcessAssociation>query()
                .lambda()
                .eq(ProcessAssociation::getProcessId, processId));
        /*
        List<ProcessAssociation> processAssociationList = list((Wrapper) Wrappers.query().lambda().eq((v0) -> {
            return v0.getProcessId();
        }, processId));*/
        if (Func.isNotEmpty(processAssociationList)) {
            Map<Integer, List<ProcessAssociation>> map = processAssociationList.stream().filter(type -> {
                return type.getType() != null;
            }).collect(Collectors.groupingBy((v0) -> {
                return v0.getType();
            }));
            map.forEach((type2, value) -> {
                switch (type2.intValue()) {
                    case 1:
                        List<Long> list = value.stream().map((v0) -> {
                            return v0.getBizId();
                        }).collect(Collectors.toList());
                        List<Workstation> workstationList = this.workstationService.list(Wrappers.<Workstation>query().lambda().in(Workstation::getId, list));
                        List<ProcessWorkstationTypeVO> processWorkstationTypeVOList = new ArrayList<>();
                        workstationList.forEach(record -> {
                            ProcessWorkstationTypeVO processWorkstationTypeVO = ProcessWorkstationTypeVO.builder().id(record.getId()).workstationCode(record.getCode()).workstationName(record.getName()).build();
                            processWorkstationTypeVOList.add(processWorkstationTypeVO);
                        });
                        processAssociationVO.setWorkstationList(processWorkstationTypeVOList);
                        return;
                    case 2:
                        List<Long> list2 = value.stream().map(ProcessAssociation::getBizId).collect(Collectors.toList());
                        List<WarehouseArea> warehouseAreaList = this.warehouseAreaService.list(Wrappers.<WarehouseArea>query().lambda().in(WarehouseArea::getId, list2));
                        List<ProcessWarehouseAreaTypeVO> areaTypeVOList = new ArrayList<>();
                        warehouseAreaList.forEach(record2 -> {
                            ProcessWarehouseAreaTypeVO processWarehouseAreaTypeVO = ProcessWarehouseAreaTypeVO.builder().id(record2.getId()).warehouseAreaCode(record2.getCode()).warehouseAreaName(record2.getName()).build();
                            areaTypeVOList.add(processWarehouseAreaTypeVO);
                        });
                        processAssociationVO.setWarehouseAreaList(areaTypeVOList);
                        return;
                    case 3:
                        List<Long> list3 = value.stream().map(ProcessAssociation::getBizId).collect(Collectors.toList());
                        List<Supplier> supplierList = this.supplierService.list(Wrappers.<Supplier>query().lambda().in(Supplier::getId, list3));
                        List<ProcessSupplierTypeVO> processSupplierTypeVOList = new ArrayList<>();
                        supplierList.forEach(record3 -> {
                            ProcessSupplierTypeVO processSupplierTypeVO = ProcessSupplierTypeVO.builder().id(record3.getId()).supplierCode(record3.getCode()).supplierName(record3.getName()).build();
                            processSupplierTypeVOList.add(processSupplierTypeVO);
                        });
                        processAssociationVO.setSupplierList(processSupplierTypeVOList);
                        return;
                    default:
                        return;
                }
            });
        }
        return processAssociationVO;
    }

    @Override // org.springblade.modules.cps.service.IProcessAssociationService
    public ProcessAssociationDetailVO insert(ProcessAssociationSaveVO processAssociationSaveVO) {
        checkProcessAssociation(processAssociationSaveVO);
        ProcessAssociation processAssociation = ProcessAssociationConvert.INSTANCE.convert(processAssociationSaveVO);
        save(processAssociation);
        return ProcessAssociationConvert.INSTANCE.convert(processAssociation);
    }

    @Override // org.springblade.modules.cps.service.IProcessAssociationService
    public Boolean delete(Long bizId, Long processId) {
    	return Boolean.valueOf(remove(Wrappers.<ProcessAssociation>query().lambda()
    	          .eq(Func.isNotEmpty(bizId), ProcessAssociation::getBizId, bizId)
    	          .eq(Func.isNotEmpty(processId), ProcessAssociation::getProcessId, processId)));
    	
    	/*
        return Boolean.valueOf(remove(Wrappers.query().lambda().eq(Func.isNotEmpty(bizId), (v0) -> {
            return v0.getBizId();
        }, bizId).eq(Func.isNotEmpty(processId), (v0) -> {
            return v0.getProcessId();
        }, processId)));
        */
    }

    private void checkProcessAssociation(ProcessAssociationSaveVO processAssociationSaveVO) {
        Long count = Long.valueOf(count(Wrappers.<ProcessAssociation>query().lambda()
        		.eq(Func.isNotEmpty(processAssociationSaveVO.getProcessId()), ProcessAssociation::getProcessId, processAssociationSaveVO.getProcessId())
        		.eq(Func.isNotEmpty(processAssociationSaveVO.getBizId()), ProcessAssociation::getBizId, processAssociationSaveVO.getBizId())));
        if (count.longValue() > 0) {
            throw new ServiceException(MessageUtils.message("cps.process.association.type.already.exists", new Object[0]));
        }
    }
}