package com.qianwen.smartman.modules.smis.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.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import java.lang.invoke.SerializedLambda;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import javax.servlet.http.HttpServletResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.qianwen.smartman.common.cache.DictCache;
import com.qianwen.smartman.common.cache.RegionCache;
import com.qianwen.smartman.common.constant.CommonConstant;
import com.qianwen.smartman.common.constant.ExcelConstant;
import com.qianwen.smartman.common.enums.DictEnum;
import com.qianwen.smartman.common.enums.StatusType;
import com.qianwen.smartman.common.utils.MessageUtils;
import com.qianwen.smartman.common.utils.ValidatorUtils;
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.secure.utils.AuthUtil;
import com.qianwen.core.tool.utils.DateUtil;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.smartman.modules.smis.convert.MaterialConvert;
import com.qianwen.smartman.modules.smis.entity.Material;
import com.qianwen.smartman.modules.smis.entity.MaterialType;
import com.qianwen.smartman.modules.smis.enums.MaterialPropertyEnum;
import com.qianwen.smartman.modules.smis.excel.MaterialExcel;
import com.qianwen.smartman.modules.smis.excel.MaterialImport;
import com.qianwen.smartman.modules.smis.mapper.MaterialMapper;
import com.qianwen.smartman.modules.smis.service.IMaterialService;
import com.qianwen.smartman.modules.smis.service.IMaterialTypeService;
import com.qianwen.smartman.modules.smis.vo.MaterialAddVO;
import com.qianwen.smartman.modules.smis.vo.MaterialIdListVO;
import com.qianwen.smartman.modules.smis.vo.MaterialQueryVO;
import com.qianwen.smartman.modules.smis.vo.MaterialUpdateVO;
import com.qianwen.smartman.modules.smis.vo.MaterialVO;
import com.qianwen.smartman.modules.smis.vo.ProductVO;
import com.qianwen.smartman.modules.smis.vo.SynchronizedProductMaterialVO;
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 org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

@Service
public class MaterialServiceImpl extends BaseServiceImpl<MaterialMapper, Material> implements IMaterialService {
    private static final Logger log = LoggerFactory.getLogger(MaterialServiceImpl.class);
    private final IMaterialTypeService materialTypeService;
    private final OssBuilder ossBuilder;
    private final ICodeGeneratorService codeGeneratorService;


    public MaterialServiceImpl(final IMaterialTypeService materialTypeService, final OssBuilder ossBuilder, final ICodeGeneratorService codeGeneratorService) {
        this.materialTypeService = materialTypeService;
        this.ossBuilder = ossBuilder;
        this.codeGeneratorService = codeGeneratorService;
    }

    
    public List<MaterialVO> listByProperty(Integer property) {
        List<MaterialType> materialTypeList = this.materialTypeService.list();
        Map<Long, MaterialType> typeIdToValue = materialTypeList.stream().collect(Collectors.toMap((v0) -> {
            return v0.getId();
        }, v -> {
            return v;
        }));
        List<Material> materialList = list(Wrappers.<Material>lambdaQuery()
                .eq(Material::getProperty, property)
                .eq(Material::getStatus, CommonConstant.ENABLE));
        /*
        List<Material> materialList = list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getProperty();
        }, property)).eq((v0) -> {
            return v0.getStatus();
        }, CommonConstant.ENABLE));*/
        List<MaterialVO> materialVoList = MaterialConvert.INSTANCE.convertList(materialList);
        materialVoList.forEach(materialVo -> {
            MaterialType materialType = (MaterialType) typeIdToValue.get(materialVo.getTypeId());
            if (Func.isNotEmpty(materialType)) {
                materialVo.setTypeName(materialType.getName());
                materialVo.setTypeCode(materialType.getCode());
            }
        });
        return materialVoList;
    }

    
    public IPage<MaterialVO> getPageMaterial(MaterialQueryVO vo, Query query) {
        Integer status = Func.isNull(vo.getStatus()) ? CommonConstant.ENABLE : vo.getStatus();
        
        QueryWrapper<MaterialQueryVO> wrapper = Wrappers.<MaterialQueryVO>query().eq("bm.status", status)
        		.eq(!Func.isNull(vo.getProperty()), "property", vo.getProperty())
        		.eq(!Func.isNull(vo.getTypeId()), "bm.type_id", vo.getTypeId())
        		.and(Func.isNotBlank(vo.getKeyWord()), i -> i.likeRight("bm.name", vo.getKeyWord()).or().likeRight("bm.code", vo.getKeyWord()))
        		.orderByDesc("bm.create_time", new String[] { "bm.id" });
        
        /*
        Wrapper<MaterialQueryVO> wrapper = (QueryWrapper) ((QueryWrapper) Wrappers.query().eq("bm.status", status)).eq(!Func.isNull(vo.getProperty()), "property", vo.getProperty()).eq(!Func.isNull(vo.getTypeId()), "bm.type_id", vo.getTypeId()).and(Func.isNotBlank(vo.getKeyWord()), i -> {
            QueryWrapper queryWrapper = (QueryWrapper) ((QueryWrapper) ((QueryWrapper) i.likeRight("bm.name", vo.getKeyWord())).or()).likeRight("bm.code", vo.getKeyWord());
        }).orderByDesc("bm.create_time", new String[]{"bm.id"});
        */
        return this.baseMapper.getPageMaterial(Condition.getPage(query), Func.isNotBlank(wrapper.getSqlSegment()) ? wrapper : null);
    }

    
    public boolean checkMaterialIsExist(List<Long> idList) {
    	List<Material> materialList = list(Wrappers.<Material>query().lambda()
    	        .eq(Func.isNotEmpty(AuthUtil.getTenantId()), Material::getTenantId, AuthUtil.getTenantId())
    	        .in(Material::getTypeId, idList)
    	        .eq(Material::getIsDeleted, 0));
    	/*
        List<Material> materialList = list((Wrapper) ((LambdaQueryWrapper) Wrappers.query().lambda().eq(Func.isNotEmpty(AuthUtil.getTenantId()), (v0) -> {
            return v0.getTenantId();
        }, AuthUtil.getTenantId()).in((v0) -> {
            return v0.getTypeId();
        }, idList)).eq((v0) -> {
            return v0.getIsDeleted();
        }, 0));*/
        return Func.isNotEmpty(materialList);
    }

    
    public MaterialVO createMaterial(MaterialAddVO materialAddVO) {
        MaterialType materialType = (MaterialType) this.materialTypeService.getById(materialAddVO.getTypeId());
        if (Func.isEmpty(materialType)) {
            throw new ServiceException(MessageUtils.message("cps.material.type.is.incorrect", new Object[0]) + materialAddVO.getTypeId());
        }
        materialAddVO.setTypeName(materialType.getName());
        if (Func.isBlank(materialAddVO.getCode())) {
            String code = this.codeGeneratorService.getGeneratorCode(materialAddVO, MetaTypeEnum.MATERIAL.getCode());
            log.info("物料编码规则生成的code:{}", code + " ," + code.length());
            materialAddVO.setCode(code);
        }
        checkCodeIsExist(materialAddVO.getCode());
        Material material = MaterialConvert.INSTANCE.convert(materialAddVO);
        save(material);
        return MaterialConvert.INSTANCE.convert(material);
    }

    private void checkCodeIsExist(String code) {
    	Material material = getOne(Wrappers.<Material>query().lambda()
    	        .eq(Material::getStatus, CommonConstant.ENABLE)
    	        .eq(Func.isNotEmpty(AuthUtil.getTenantId()), Material::getTenantId, AuthUtil.getTenantId())
    	        .eq(Material::getCode, code));
    	/*
        Material material = (Material) getOne((Wrapper) ((LambdaQueryWrapper) Wrappers.query().lambda().eq((v0) -> {
            return v0.getStatus();
        }, CommonConstant.ENABLE)).eq(Func.isNotEmpty(AuthUtil.getTenantId()), (v0) -> {
            return v0.getTenantId();
        }, AuthUtil.getTenantId()).eq((v0) -> {
            return v0.getCode();
        }, code));*/
        if (!Func.isNull(material)) {
            throw new ServiceException(MessageUtils.message("cps.material.code.already.exists", new Object[0]));
        }
        Material material2 =  getOne(Wrappers.<Material>query().lambda()
                .eq(Material::getStatus, CommonConstant.DEACTIVATE)
                .eq(Func.isNotEmpty(AuthUtil.getTenantId()), Material::getTenantId, AuthUtil.getTenantId())
                .eq(Material::getCode, code));
        
        if (!Func.isNull(material2)) {
            throw new ServiceException(MessageUtils.message("cps.material.code.unable.already.exists", new Object[0]));
        }
    }

    
    public MaterialVO updateMaterial(MaterialUpdateVO materialUpdateVO) {
        MaterialType materialType = (MaterialType) this.materialTypeService.getById(materialUpdateVO.getTypeId());
        if (Func.isEmpty(materialType)) {
            throw new ServiceException(MessageUtils.message("cps.material.type.is.incorrect", new Object[0]) + materialUpdateVO.getTypeId());
        }
        materialUpdateVO.setTypeName(materialType.getName());
        Material material = MaterialConvert.INSTANCE.convert(materialUpdateVO);
        updateById(material);
        return MaterialConvert.INSTANCE.convert(material);
    }

    
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteMaterial(List<String> ids, Integer type) {
        List<Long> idList = ids.stream().map(Long::valueOf).collect(Collectors.toList());
        if (StatusType.REMOVE.getType().equals(type)) {
            return removeByIds(idList);
        }
        return changeStatus(idList, CommonConstant.DEACTIVATE);
    }

    
    public BladeFile importMaterial(List<MaterialImport> data) {
        if (Func.isEmpty(data)) {
            throw new ServiceException(MessageUtils.message("excel.import.data.can.not.be.null", new Object[0]));
        }
        Map<String, MaterialType> materialTypeCodeEnable = this.materialTypeService.list().stream().filter(c -> {
            return CommonConstant.ENABLE.equals(c.getStatus());
        }).collect(Collectors.toMap((v0) -> {
            return v0.getCode();
        }, v -> {
            return v;
        }));
        Map<String, MaterialType> materialTypeCodeDisable = this.materialTypeService.list().stream().filter(c2 -> {
            return CommonConstant.DEACTIVATE.equals(c2.getStatus());
        }).collect(Collectors.toMap((v0) -> {
            return v0.getCode();
        }, v2 -> {
            return v2;
        }));
        List<Material> materialList = list();
        Map<String, String> dictValueToKey = DictCache.getList(DictEnum.MATERIAL_PROPERTY.getName()).stream().collect(Collectors.toMap((v0) -> {
            return v0.getDictValue();
        }, (v0) -> {
            return v0.getDictKey();
        }));
        boolean flag = Boolean.TRUE.booleanValue();
        for (MaterialImport materialImport : data) {
            checkMaterialImport(materialImport, materialTypeCodeEnable, materialTypeCodeDisable, materialList, dictValueToKey);
            if (Func.isNotEmpty(materialImport.getFailReason())) {
                flag = Boolean.FALSE.booleanValue();
            }
            if (!flag) {
                MultipartFile multipartFile = ExcelUtil.exportFillTemplateToMultipartFile(ExcelConstant.DIRECTORY + "materialFailTemplate" + ExcelConstant.SUFFIX, MessageUtils.message("excel.import.failed.report.name", new Object[0]) + ExcelConstant.SUFFIX, "物料信息表", data.stream().filter(x -> {
                    return Func.isNotEmpty(x.getFailReason());
                }).collect(Collectors.toList()), (Object) null, (AbstractMergeStrategy) null);
                return this.ossBuilder.tempTemplate().putFile(multipartFile.getOriginalFilename(), multipartFile);
            }
        }
        data.forEach(materialImport2 -> {
            MaterialAddVO convert = MaterialConvert.INSTANCE.convert(materialImport2);
            createMaterial(convert);
        });
        return null;
    }

    
    public BladeFile exportMaterial(MaterialQueryVO materialQueryVO, HttpServletResponse response) {
        Integer status = materialQueryVO.getStatus();
        if (Func.isNull(status)) {
            materialQueryVO.setStatus(CommonConstant.ENABLE);
        }
        List<MaterialVO> materialList = getPageMaterial(materialQueryVO, new Query().setSize(-1)).getRecords();
        List<MaterialExcel> materialExcelList = MaterialConvert.INSTANCE.convertExcel(materialList);
        materialExcelList.forEach(materialExcel -> {
            materialExcel.setIsMustCheckName(1 == materialExcel.getIsMustCheck().intValue() ? "是" : "否");
            materialExcel.setPropertyName(DictCache.getValue(DictEnum.MATERIAL_PROPERTY, materialExcel.getProperty()));
        });
        String fileName = String.format("%s-%s.xlsx", "物料信息", DateUtil.time());
        MultipartFile multipartFile = ExcelUtil.exportToMultipartFile(fileName, "物料信息表", materialExcelList, MaterialExcel.class);
        return this.ossBuilder.tempTemplate().putFile(multipartFile.getOriginalFilename(), multipartFile);
    }

    
    public List<MaterialVO> getMaterialListByIds(MaterialIdListVO materialIdListVO) {
        List<Material> materialList = listByIds(materialIdListVO.getIds());
        List<Long> typeIdList = materialList.stream().map((v0) -> {
            return v0.getTypeId();
        }).distinct().collect(Collectors.toList());
        LinkedHashMap<Long, MaterialType> typeMap = new LinkedHashMap<>();
        if (typeIdList.size() > 0) {
            List<MaterialType> typeList = this.materialTypeService.listByIds(typeIdList);
            for (MaterialType bean : typeList) {
                typeMap.put(bean.getId(), bean);
            }
        }
        List<MaterialVO> result = (List) MaterialConvert.INSTANCE.convertList(materialList).stream().map(i -> {
            if (!Func.isNull(typeMap.get(i.getTypeId()))) {
                i.setTypeName(((MaterialType) typeMap.get(i.getTypeId())).getName());
            }
            return i;
        }).collect(Collectors.toList());
        return result;
    }

    
    @Transactional(rollbackFor = {Exception.class})
    public Boolean synchronizedMaterial(SynchronizedProductMaterialVO synchronizedProductMaterialVO) {
        List<String> nameList = synchronizedProductMaterialVO.getProductList().stream().map(i -> {
            return i.getName();
        }).collect(Collectors.toList());
        List<String> codeList = synchronizedProductMaterialVO.getProductList().stream().map(i2 -> {
            return i2.getCode();
        }).collect(Collectors.toList());
        
        List<Material> list = list(Wrappers.<Material>query().lambda()
        		.and(i -> i.in(Material::getName, nameList))
                .or(i -> i.in(Material::getCode, codeList)));
        /*
        List<Material> list = list((Wrapper) ((LambdaQueryWrapper) Wrappers.query().lambda().and(i3 -> {
            LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) i3.in((v0) -> {
                return v0.getName();
            }, nameList);
        })).or(i4 -> {
            LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) i4.in((v0) -> {
                return v0.getCode();
            }, codeList);
        }));*/
        List<ProductVO> needAddList = new ArrayList<>();
        List<Long> deleteIdList = new ArrayList<>();
        list.forEach(m -> {
            for (ProductVO p : synchronizedProductMaterialVO.getProductList()) {
                if (m.getCode().equals(p.getCode()) || m.getName().equals(p.getName())) {
                    deleteIdList.add(m.getId());
                } else {
                    needAddList.add(p);
                }
            }
        });
        if (Func.isEmpty(deleteIdList)) {
            return insertProductMaterial(synchronizedProductMaterialVO);
        }
        if (synchronizedProductMaterialVO.getIsDeleted().intValue() == 1) {
            removeByIds(deleteIdList);
            return insertProductMaterial(synchronizedProductMaterialVO);
        }
        return Boolean.FALSE;
    }

    private Boolean insertProductMaterial(SynchronizedProductMaterialVO synchronizedProductMaterialVO) {
        List<Material> insertList = synchronizedProductMaterialVO.getProductList().stream().map(i -> {
            Material bean = new Material();
            bean.setName(i.getName());
            bean.setCode(i.getCode());
            bean.setTypeId(synchronizedProductMaterialVO.getMaterialTypeId());
            bean.setProperty(Integer.valueOf(MaterialPropertyEnum.T3.getType()));
            bean.setIsMustCheck(Integer.valueOf("0"));
            return bean;
        }).collect(Collectors.toList());
        saveBatch(insertList);
        return Boolean.TRUE;
    }

    private void checkMaterialImport(MaterialImport materialImport, Map<String, MaterialType> materialTypeCodeToValue, Map<String, MaterialType> materialTypeCodeDisable, List<Material> materialList, Map<String, String> dictValueToKey) {
        if (Func.isEmpty(materialImport.getCode())) {
            materialImport.setFailReason(MessageUtils.message("cps.material.code.can.not.be.null", new Object[0]));
        } else if (Func.isEmpty(materialImport.getName())) {
            materialImport.setFailReason(MessageUtils.message("cps.material.name.can.not.be.null", new Object[0]));
        } else if (Func.isEmpty(materialImport.getTypeCode())) {
            materialImport.setFailReason(MessageUtils.message("cps.material.type.code.can.not.be.null", new Object[0]));
        } else if (Func.isEmpty(materialImport.getTypeName())) {
            materialImport.setFailReason(MessageUtils.message("cps.material.type.name.can.not.be.null", new Object[0]));
        } else if (Func.isEmpty(materialImport.getPropertyName())) {
            materialImport.setFailReason(MessageUtils.message("cps.material.property.can.not.be.null", new Object[0]));
        } else if (ValidatorUtils.stringFilter(materialImport.getCode())) {
            materialImport.setFailReason(MessageUtils.message("cps.material.code.exist.special.symbols.error", new Object[0]));
        } else if (ValidatorUtils.stringFilter(materialImport.getName())) {
            materialImport.setFailReason(MessageUtils.message("cps.material.name.exist.special.symbols.error", new Object[0]));
        } else if (Func.isNotEmpty(materialImport.getUnit()) && ValidatorUtils.stringFilter(materialImport.getUnit())) {
            materialImport.setFailReason(MessageUtils.message("cps.material.unit.exist.special.symbols.error", new Object[0]));
        } else if (Func.isNotEmpty(materialImport.getStuff()) && ValidatorUtils.stringFilter(materialImport.getStuff())) {
            materialImport.setFailReason(MessageUtils.message("cps.material.stuff.exist.special.symbols.error", new Object[0]));
        } else if (Func.isNotEmpty(materialImport.getIsMustCheckName()) && !"是".equals(materialImport.getIsMustCheckName()) && !"否".equals(materialImport.getIsMustCheckName())) {
            materialImport.setFailReason(MessageUtils.message("cps.material.must.check.name.can.only.be.yes.or.no", new Object[0]));
        } else {
            if ("是".equals(materialImport.getIsMustCheckName())) {
                materialImport.setIsMustCheck(1);
            } else {
                materialImport.setIsMustCheck(0);
            }
            if (materialTypeCodeDisable.containsKey(materialImport.getTypeCode())) {
                materialImport.setFailReason(MessageUtils.message("cps.material.type.disable.not.exists", new Object[0]));
            } else if (!materialTypeCodeToValue.containsKey(materialImport.getTypeCode())) {
                materialImport.setFailReason(MessageUtils.message("cps.material.type.not.exists", new Object[0]));
            } else if (!materialImport.getTypeName().equals(materialTypeCodeToValue.get(materialImport.getTypeCode()).getName())) {
                materialImport.setFailReason(MessageUtils.message("cps.material.type.code.not.match.name", new Object[0]));
            } else {
                materialImport.setTypeId(materialTypeCodeToValue.get(materialImport.getTypeCode()).getId());
                List<String> materialCodeEnableList = (List) materialList.stream().filter(c -> {
                    return CommonConstant.ENABLE.equals(c.getStatus());
                }).map((v0) -> {
                    return v0.getCode();
                }).collect(Collectors.toList());
                List<String> materialCodeDisableList = (List) materialList.stream().filter(c2 -> {
                    return CommonConstant.DEACTIVATE.equals(c2.getStatus());
                }).map((v0) -> {
                    return v0.getCode();
                }).collect(Collectors.toList());
                if (materialCodeEnableList.contains(materialImport.getCode())) {
                    materialImport.setFailReason(MessageUtils.message("cps.material.code.already.exists", new Object[0]));
                } else if (materialCodeDisableList.contains(materialImport.getCode())) {
                    materialImport.setFailReason(MessageUtils.message("cps.material.code.unable.already.exists", new Object[0]));
                } else if (!dictValueToKey.containsKey(materialImport.getPropertyName())) {
                    materialImport.setFailReason(MessageUtils.message("cps.material.property.not.exists", new Object[0]));
                } else {
                    materialImport.setProperty(Integer.valueOf(dictValueToKey.get(materialImport.getPropertyName())));
                }
            }
        }
    }
}