package org.jeecg.modules.lims.testing.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.apache.commons.lang.StringUtils;
import org.jeecg.common.system.vo.DictModel;
import org.jeecg.modules.lims.testing.entity.LimsItemTarget;
import org.jeecg.modules.lims.testing.entity.LimsTestingCategory;
import org.jeecg.modules.lims.testing.entity.LimsTestingItem;
import org.jeecg.modules.lims.testing.entity.LimsTestingType;
import org.jeecg.modules.lims.testing.mapper.LimsItemTargetMapper;
import org.jeecg.modules.lims.testing.mapper.LimsTestingCategoryMapper;
import org.jeecg.modules.lims.testing.mapper.LimsTestingItemMapper;
import org.jeecg.modules.lims.testing.mapper.LimsTestingTypeMapper;
import org.jeecg.modules.lims.testing.service.ILimsItemTargetService;
import org.jeecg.modules.lims.testing.vo.OutlineTreeVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

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

/**
 * @Description: lims_item_target
 * @Author: jeecg-boot
 * @Date: 2023-04-24
 * @Version: V1.0
 */
@Service
public class LimsItemTargetServiceImpl extends ServiceImpl<LimsItemTargetMapper, LimsItemTarget> implements ILimsItemTargetService {

    @Autowired
    private LimsItemTargetMapper targetMapper;

    @Autowired
    private LimsTestingCategoryMapper categoryMapper;
    @Autowired
    private LimsTestingTypeMapper typeMapper;
    @Autowired
    private LimsTestingItemMapper itemMapper;

    //三张表
    public enum TABLE {
        CAT,
        TYP,
        ITM
    }

    @Override
    public List<OutlineTreeVo> queryTreeByStandId(LimsItemTarget limsItemTarget) {
        //0查询各层级数据ID
        QueryWrapper<LimsItemTarget> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(LimsItemTarget::getStandardId, limsItemTarget.getStandardId());
        queryWrapper.lambda().eq(LimsItemTarget::getIsTech, 0);
        Integer enabled = limsItemTarget.getEnabled();
        //查询已选择数据时才需要过滤
        if(enabled!=null && enabled ==1 ){
            queryWrapper.lambda().eq(LimsItemTarget::getEnabled, 1);
        }
        List<LimsItemTarget> targetList = targetMapper.selectList(queryWrapper);
        //鉴定项目换成真实id
        Map<String, String> realIdMap = targetList.stream().collect(Collectors.toMap(LimsItemTarget::getItemId, LimsItemTarget::getId));


        List<String> catIds = targetList.stream().map(item -> item.getCategoryId()).collect(Collectors.toList());
        List<String> typIds = targetList.stream().map(item -> item.getTypeId()).collect(Collectors.toList());
        List<String> itmIds = targetList.stream().map(item -> item.getItemId()).collect(Collectors.toList());

        //1.鉴定类别
        List<LimsTestingCategory> catList = new ArrayList<>();
        List<OutlineTreeVo> catVoList = new ArrayList<>();
        queryCatList(catList, catIds, catVoList);

        //2.鉴定类型
        Map<String, List<OutlineTreeVo>> catChild = new HashMap<>();
        List<LimsTestingType> typList = new ArrayList<>();
        List<OutlineTreeVo> typVoList = new ArrayList<>();
        queryTypList(typList, typIds, typVoList, catChild);

        //3.鉴定项目
        Map<String, List<OutlineTreeVo>> typChild = new HashMap<>();
        List<LimsTestingItem> itmList = new ArrayList<>();
        List<OutlineTreeVo> itmVoList = new ArrayList<>();
        queryItmList(itmIds, itmList, itmVoList, typChild,realIdMap);


        //鉴定类型填充children
        fitData(typVoList, typChild);
        //鉴定类别填充children
        fitData(catVoList, catChild);
        //根据排序添加序号
        createDataNo(catVoList, new OutlineTreeVo());

        return catVoList;
    }


    /**
     * 查询鉴定类别数据
     *
     * @param catList   鉴定类别数据
     * @param catIds    鉴定类别所有id
     * @param catVoList 鉴定类别数据转tree数据
     */
    private void queryCatList(List<LimsTestingCategory> catList, List<String> catIds, List<OutlineTreeVo> catVoList) {
        QueryWrapper<LimsTestingCategory> categoryQueryWrapper = new QueryWrapper<>();
        if (catIds.size() < 1) return;
        categoryQueryWrapper.lambda().in(LimsTestingCategory::getId, catIds).orderByAsc(LimsTestingCategory::getSort);
        catList.addAll(categoryMapper.selectList(categoryQueryWrapper));
        List<OutlineTreeVo> voList = catList.stream().map(item -> {
            OutlineTreeVo vo = new OutlineTreeVo();
            vo.setId(item.getId());
            vo.setKey(item.getId());
            vo.setValue(item.getId());
            vo.setTitle(item.getName());
            vo.setType(TABLE.CAT.name());
            return vo;
        }).collect(Collectors.toList());
        catVoList.addAll(voList);
    }

    /**
     * 查询鉴定类型数据
     *
     * @param typList   鉴定类型数据
     * @param typIds    鉴定类型所有id
     * @param typVoList 鉴定类型数据转tree数据
     * @param catChild  鉴定类别的 children
     */
    private void queryTypList(List<LimsTestingType> typList, List<String> typIds, List<OutlineTreeVo> typVoList, Map<String, List<OutlineTreeVo>> catChild) {
        QueryWrapper<LimsTestingType> typQueryWrapper = new QueryWrapper<>();
        if (typIds.size() < 1) return;
        typQueryWrapper.lambda().in(LimsTestingType::getId, typIds).orderByAsc(LimsTestingType::getSort);
        typList.addAll(typeMapper.selectList(typQueryWrapper));
        List<OutlineTreeVo> voList = typList.stream().map(item -> {
            OutlineTreeVo vo = new OutlineTreeVo();
            vo.setId(item.getId());
            vo.setKey(item.getId());
            vo.setValue(item.getId());
            vo.setTitle(item.getName());
            vo.setType(TABLE.TYP.name());

            if (catChild.containsKey(item.getCategoryId())) {
                catChild.get(item.getCategoryId()).add(vo);
            } else {
                List<OutlineTreeVo> res = new ArrayList<>();
                res.add(vo);
                catChild.put(item.getCategoryId(), res);
            }
            return vo;
        }).collect(Collectors.toList());
        typVoList.addAll(voList);
    }

    /**
     * 查询鉴定类型数据
     *
     * @param itmList    鉴定项目数据
     * @param itemVoList 鉴定项目数据转tree数据
     * @param typChild   鉴定类型的 children
     */
    private void queryItmList(List<String> itmIds, List<LimsTestingItem> itmList, List<OutlineTreeVo> itemVoList, Map<String, List<OutlineTreeVo>> typChild, Map<String, String> realIdMap ) {
        QueryWrapper<LimsTestingItem> itemQueryWrapper = new QueryWrapper<>();
        if (itmIds.size() < 1) return;
        itemQueryWrapper.lambda().in(LimsTestingItem::getId, itmIds).orderByAsc(LimsTestingItem::getSort);
        itmList.addAll(itemMapper.selectList(itemQueryWrapper));
        List<OutlineTreeVo> voList = itmList.stream().map(item -> {
            OutlineTreeVo vo = new OutlineTreeVo();
            vo.setId(realIdMap.get(item.getId()));
            vo.setKey(realIdMap.get(item.getId()));
            vo.setValue(item.getId());
            vo.setTitle(item.getName());
            vo.setType(TABLE.ITM.name());

            if (typChild.containsKey(item.getTypeId())) {
                typChild.get(item.getTypeId()).add(vo);
            } else {
                List<OutlineTreeVo> res = new ArrayList<>();
                res.add(vo);
                typChild.put(item.getTypeId(), res);
            }
            return vo;
        }).collect(Collectors.toList());
        itemVoList.addAll(voList);
    }

    /**
     * 填充children数据
     *
     * @param voList   需要填充的数据
     * @param childMap key -> voList的id   value -> voList的children
     */
    private void fitData(List<OutlineTreeVo> voList, Map<String, List<OutlineTreeVo>> childMap) {
        if (voList.size() < 1 || childMap.isEmpty()) return;
        for (int i = 0; i < voList.size(); i++) {
            OutlineTreeVo vo = voList.get(i);
            if (childMap.containsKey(vo.getId()) && childMap.get(vo.getId()).size() > 0) {
                vo.setLeaf(false);
                vo.setSort(i);
                vo.setChildren(childMap.get(vo.getId()));
            }
        }
    }

    /**
     * 树形数据编号
     *
     * @param voList 树形数据
     * @param parent 父节点
     */
    private void createDataNo(List<OutlineTreeVo> voList, OutlineTreeVo parent) {
        for (int i = 0; i < voList.size(); i++) {
            OutlineTreeVo vo = voList.get(i);
            int index = i + 1;
            if (StringUtils.isEmpty(parent.getNo())) {
                vo.setNo(index + "");
            } else {
                vo.setNo(parent.getNo() + "." + index);
                vo.setPid(parent.getId());
                vo.setPname(parent.getTitle());
            }
            vo.setTitle(vo.getNo() + "-" + vo.getTitle());
            List<OutlineTreeVo> children = vo.getChildren();
            if (children != null && children.size() > 0) {
                createDataNo(children, vo);
            }

        }

    }
}