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

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.stream.Collectors;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.qianwen.core.coderule.constant.enums.ElementTypeEnum;
import com.qianwen.core.log.exception.ServiceException;
import com.qianwen.core.mp.base.BaseServiceImpl;
import com.qianwen.core.mp.support.Query;
import com.qianwen.core.tool.node.ForestNodeMerger;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.smartman.common.constant.DncConstant;
import com.qianwen.smartman.common.utils.Lambda;
import com.qianwen.smartman.common.utils.MessageUtils;
import com.qianwen.smartman.modules.system.dto.BasCoderuleDTO;
import com.qianwen.smartman.modules.system.entity.BasCodeRule;
import com.qianwen.smartman.modules.system.entity.BasCodeRuleEntry;
import com.qianwen.smartman.modules.system.entity.Dict;
import com.qianwen.smartman.modules.system.entity.MetaObjectType;
import com.qianwen.smartman.modules.system.service.IBasCoderuleService;
import com.qianwen.smartman.modules.system.service.IDictService;
import com.qianwen.smartman.modules.system.service.IMetaObjectTypeService;
import com.qianwen.smartman.modules.system.vo.DictVO;
import com.qianwen.smartman.modules.tool.constant.ToolConstant;
import com.qianwen.smartman.modules.tool.convert.ToolCategoryConvert;
import com.qianwen.smartman.modules.tool.entity.Tool;
import com.qianwen.smartman.modules.tool.entity.ToolCategory;
import com.qianwen.smartman.modules.tool.entity.ToolModel;
import com.qianwen.smartman.modules.tool.mapper.ToolCategoryMapper;
import com.qianwen.smartman.modules.tool.service.IToolCategoryService;
import com.qianwen.smartman.modules.tool.service.IToolManageService;
import com.qianwen.smartman.modules.tool.service.IToolModelService;
import com.qianwen.smartman.modules.tool.vo.ToolCategoryTreeVO;
import com.qianwen.smartman.modules.tool.vo.ToolCategoryVO;

@Service
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/tool/service/impl/ToolCategoryServiceImpl.class */
public class ToolCategoryServiceImpl extends BaseServiceImpl<ToolCategoryMapper, ToolCategory> implements IToolCategoryService {
    @Autowired
    private IDictService dictService;
    @Autowired
    private IMetaObjectTypeService metaObjectTypeService;
    @Autowired
    private IBasCoderuleService basCoderuleService;
    @Autowired
    @Lazy
    private IToolManageService toolManageService;
    @Autowired
    private IToolModelService toolModelService;
    private final Integer MIN_SORT = 1;


    @Override // org.springblade.modules.tool.service.IToolCategoryService
    public List<ToolCategoryTreeVO> tree() {
        List<ToolCategoryTreeVO> toolCategoryList = ((ToolCategoryMapper) this.baseMapper).listCategoryList();
        List<ToolCategoryTreeVO> tree = ForestNodeMerger.merge(toolCategoryList);
        calculateModelNum(tree);
        return tree;
    }

    private Integer calculateModelNum(List<ToolCategoryTreeVO> toolCategoryList) {
        Integer allItemNum = 0;
        for (ToolCategoryTreeVO toolCategoryTreeVO : toolCategoryList) {
            List<ToolCategoryTreeVO> children = toolCategoryTreeVO.getChildren();
            Integer childrenItemNum = calculateModelNum(children);
            toolCategoryTreeVO.setItemNum(Integer.valueOf(childrenItemNum.intValue() + toolCategoryTreeVO.getItemNum().intValue()));
            allItemNum = Integer.valueOf(allItemNum.intValue() + toolCategoryTreeVO.getItemNum().intValue());
        }
        return allItemNum;
    }

    @Override // org.springblade.modules.tool.service.IToolCategoryService
    @Transactional(rollbackFor = {Exception.class})
    public ToolCategoryVO save(ToolCategoryVO toolCategoryVO) {
        checkName(null, toolCategoryVO.getName());
        int nextSort = getNextSort(toolCategoryVO.getParentId());
        toolCategoryVO.setSort(Integer.valueOf(nextSort));
        ToolCategory toolCategory = ToolCategoryConvert.INSTANCE.convert(toolCategoryVO);
        save(toolCategory);
        Dict dict = createDict(toolCategory);
        createCodeRule(toolCategoryVO, dict);
        return ToolCategoryConvert.INSTANCE.convert(toolCategory);
    }

    private Dict createDict(ToolCategory toolCategory) {
        Long dictParentId;
        HashMap<String, Object> dictQueryMap = new HashMap<>();
        dictQueryMap.put("code", ToolConstant.TOOL_CATEGORY_DICT_KEY);
        Query query = new Query().setSize(15).setCurrent(1);
        IPage<DictVO> dictVOIPage = this.dictService.parentList(dictQueryMap, query);
        if (Func.isEmpty(dictVOIPage.getRecords())) {
            Dict parentDict = new Dict();
            parentDict.setIsSealed(0);
            parentDict.setCode(ToolConstant.TOOL_CATEGORY_DICT_KEY);
            parentDict.setDictKey(DncConstant.DNC_DEFAULT_PARENT_ID);
            parentDict.setDictValue("刀具类型");
            parentDict.setSort(1);
            this.dictService.submit(parentDict);
            dictParentId = parentDict.getId();
        } else {
            dictParentId = ((DictVO) dictVOIPage.getRecords().get(0)).getId();
        }
        Dict dict = new Dict();
        dict.setId(toolCategory.getId());
        dict.setCode(ToolConstant.TOOL_CATEGORY_DICT_KEY);
        dict.setDictKey(String.valueOf(toolCategory.getId()));
        dict.setDictValue(toolCategory.getName());
        dict.setIsSealed(0);
        dict.setSort(Integer.valueOf(getNextDictSort(dictParentId)));
        dict.setParentId(dictParentId);
        dict.setIsDeleted(0);
        this.dictService.save(dict);
        return dict;
    }

    private void createCodeRule(ToolCategoryVO toolCategoryVO, Dict dict) {
        if (Func.isEmpty(toolCategoryVO.getCodeLength())) {
            if (Func.isNotEmpty(toolCategoryVO.getToolPrefixCode())) {
                throw new ServiceException(MessageUtils.message("tool.code.generate.code.length.can.bot.be.empty", new Object[0]));
            }
            if (Func.isEmpty(toolCategoryVO.getToolPrefixCode())) {
                return;
            }
        }
        MetaObjectType metaObjectType = (MetaObjectType) this.metaObjectTypeService.getOne(Lambda.eq((v0) -> {
            return v0.getFId();
        }, ToolConstant.TOOL_MANAGE));
        if (Func.isEmpty(metaObjectType.getRuleDictCode())) {
            this.metaObjectTypeService.saveRuleFiled(ToolConstant.TOOL_MANAGE, "tool_category", ToolConstant.TOOL_CATEGORY_DICT_KEY);
        }
        BasCoderuleDTO basCoderuleDTO = new BasCoderuleDTO();
        basCoderuleDTO.setAutoBillno(false);
        basCoderuleDTO.setBillFormId(ToolConstant.TOOL_MANAGE);
        basCoderuleDTO.setSystemDefault(true);
        basCoderuleDTO.setName(toolCategoryVO.getToolPrefixCode() + toolCategoryVO.getCodeLength());
        basCoderuleDTO.setPreview(toolCategoryVO.getToolPrefixCode() + toolCategoryVO.getCodeLength());
        basCoderuleDTO.setRemark(toolCategoryVO.getToolPrefixCode() + toolCategoryVO.getCodeLength());
        basCoderuleDTO.setRepairBillno(false);
        basCoderuleDTO.setRuleFieldDictKey(dict.getDictKey());
        List<BasCodeRuleEntry> basCodeRuleEntryList = new ArrayList<>();
        if (Func.isNotEmpty(toolCategoryVO.getToolPrefixCode())) {
            BasCodeRuleEntry basCodeRuleEntry = new BasCodeRuleEntry();
            basCodeRuleEntry.setAddChar("");
            basCodeRuleEntry.setAddStyle(false);
            basCodeRuleEntry.setCodeElement(true);
            basCodeRuleEntry.setCutStyle(true);
            basCodeRuleEntry.setElementSource("");
            basCodeRuleEntry.setElementType(ElementTypeEnum.CONSTANT.getType());
            basCodeRuleEntry.setElementValue(toolCategoryVO.getToolPrefixCode());
            basCodeRuleEntry.setIncrementStep(1);
            basCodeRuleEntry.setLength(Integer.valueOf(toolCategoryVO.getToolPrefixCode().length()));
            basCodeRuleEntry.setReChar("");
            basCodeRuleEntry.setSeed(0);
            basCodeRuleEntry.setCodeOnlyBy(false);
            basCodeRuleEntry.setFormat("");
            basCodeRuleEntry.setSeparatorChar("");
            basCodeRuleEntry.setSeq(1);
            basCodeRuleEntryList.add(basCodeRuleEntry);
        }
        BasCodeRuleEntry basCodeRuleEntry1 = new BasCodeRuleEntry();
        basCodeRuleEntry1.setAddChar("0");
        basCodeRuleEntry1.setAddStyle(false);
        basCodeRuleEntry1.setCodeElement(true);
        basCodeRuleEntry1.setCodeOnlyBy(false);
        basCodeRuleEntry1.setCutStyle(true);
        basCodeRuleEntry1.setElementSource("");
        basCodeRuleEntry1.setElementType(ElementTypeEnum.SEQUENCE.getType());
        basCodeRuleEntry1.setElementValue("");
        basCodeRuleEntry1.setIncrementStep(1);
        basCodeRuleEntry1.setLength(Integer.valueOf(toolCategoryVO.getCodeLength().length()));
        basCodeRuleEntry1.setReChar("");
        basCodeRuleEntry1.setSeed(1);
        basCodeRuleEntry1.setCodeOnlyBy(false);
        basCodeRuleEntry1.setFormat("");
        basCodeRuleEntry1.setSeparatorChar("");
        basCodeRuleEntry1.setSeq(2);
        basCodeRuleEntryList.add(basCodeRuleEntry1);
        basCoderuleDTO.setEntryList(basCodeRuleEntryList);
        this.basCoderuleService.submitCoderule(basCoderuleDTO);
    }

    @Override // org.springblade.modules.tool.service.IToolCategoryService
    @Transactional(rollbackFor = {Exception.class})
    public Boolean updateName(Long id, String newName) {
        checkName(id, newName);
        ToolCategory toolCategory = (ToolCategory) getById(id);
        toolCategory.setName(newName);
        updateById(toolCategory);
        Dict dict = (Dict) this.dictService.getById(toolCategory.getId());
        dict.setDictValue(newName);
        this.dictService.updateById(dict);
        return null;
    }

    @Override // org.springblade.modules.tool.service.IToolCategoryService
    @Transactional(rollbackFor = {Exception.class})
    public Boolean remove(List<Long> ids) {
        List<Long> categoryIds = getChildrenIds(ids, ids);
        long count = this.toolManageService.count(Wrappers.<Tool>lambdaQuery().in(Tool::getToolCategoryId, categoryIds));
        /*
        long count = this.toolManageService.count((Wrapper) Wrappers.lambdaQuery().in((v0) -> {
            return v0.getToolCategoryId();
        }, categoryIds));*/
        if (count > 0) {
            throw new ServiceException(MessageUtils.message("tool.have.tool.can.not.delete", new Object[0]));
        }
        this.toolModelService.remove(Wrappers.<ToolModel>lambdaQuery().in(ToolModel::getToolCategoryId, categoryIds));
        List<String> idStrList = categoryIds.stream().map((v0) -> {
            return String.valueOf(v0);
        }).collect(Collectors.toList());
        
        this.basCoderuleService.remove(Wrappers.<BasCodeRule>lambdaQuery().in(BasCodeRule::getRuleFieldDictKey, idStrList));
        /*
        this.basCoderuleService.remove((Wrapper) Wrappers.lambdaQuery().in((v0) -> {
            return v0.getRuleFieldDictKey();
        }, idStrList));*/
        String idList = categoryIds.stream().map((v0) -> {
            return String.valueOf(v0);
        }).reduce((a, b) -> {
            return a + "," + b;
        }).get();
        this.dictService.removeDict(idList);
        return Boolean.valueOf(removeBatchByIds(categoryIds));
    }

    private int getNextDictSort(Long parentId) {
        List<DictVO> dictVOS = this.dictService.childList(new HashMap<>(), parentId);
        return ((Integer) dictVOS.stream().map((v0) -> {
            return v0.getSort();
        }).max((v0, v1) -> {
            return v0.compareTo(v1);
        }).orElse(-1)).intValue() + 1;
    }

    private int getNextSort(Long parentId) {
    	List<ToolCategory> toolCategoryList = list(Wrappers.<ToolCategory>lambdaQuery().eq(ToolCategory::getParentId, parentId).orderByDesc(ToolCategory::getSort));
    	/*
        List<ToolCategory> toolCategoryList = list((Wrapper) ((LambdaQueryWrapper) Wrappers.lambdaQuery().eq((v0) -> {
            return v0.getParentId();
        }, parentId)).orderByDesc((v0) -> {
            return v0.getSort();
        }));*/
        if (Func.isEmpty(toolCategoryList)) {
            return this.MIN_SORT.intValue();
        }
        return toolCategoryList.get(0).getSort().intValue() + 1;
    }

    private void checkName(Long id, String name) {
    	long count = count(Wrappers.<ToolCategory>lambdaQuery().ne(Func.isNotEmpty(id), ToolCategory::getId, id).eq(ToolCategory::getName, name));
    	/*
        long count = count((Wrapper) Wrappers.lambdaQuery().ne(Func.isNotEmpty(id), (v0) -> {
            return v0.getId();
        }, id).eq((v0) -> {
            return v0.getName();
        }, name));*/
        if (count > 0) {
            throw new ServiceException(MessageUtils.message("tool.category.already.exists", new Object[0]));
        }
    }

    @Override // org.springblade.modules.tool.service.IToolCategoryService
    public List<Long> getChildrenIds(List<Long> queryIdList, List<Long> ids) {
        List<Long> categoryIdList = list(Lambda.in((v0) -> {
            return v0.getParentId();
        }, queryIdList)).stream().map((v0) -> {
            return v0.getId();
        }).collect(Collectors.toList());
        if (Func.isEmpty(categoryIdList)) {
            return ids;
        }
        ids.addAll(categoryIdList);
        return getChildrenIds(categoryIdList, ids);
    }
}