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


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang.StringUtils;
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.LimsTestingCategoryMapper;
import org.jeecg.modules.lims.testing.mapper.LimsTestingItemMapper;
import org.jeecg.modules.lims.testing.mapper.LimsTestingTypeMapper;
import org.jeecg.modules.lims.testing.service.ILimsTestingCategoryService;
import org.jeecg.modules.lims.testing.vo.OutlineTreeVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;


/**
 * @Description: lims_testing_category
 * @Author: jeecg-boot
 * @Date: 2023-04-20
 * @Version: V1.0
 */
@Service
public class LimsTestingCategoryServiceImpl extends ServiceImpl<LimsTestingCategoryMapper, LimsTestingCategory> implements ILimsTestingCategoryService {
    @Autowired
    private LimsTestingCategoryMapper categoryMapper;
    @Autowired
    private LimsTestingTypeMapper typeMapper;
    @Autowired
    private LimsTestingItemMapper itemMapper;

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

    @Override
    public List<OutlineTreeVo> queryTreeList(String outlineId) {
        //1.鉴定类别
        List<String> catIds = new ArrayList<>();
        List<LimsTestingCategory> catList = new ArrayList<>();
        List<OutlineTreeVo> catVoList = new ArrayList<>();
        queryCatList(outlineId, catList, catIds, catVoList);

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

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

        //鉴定类型填充children
        fitData(typVoList, typChild);
        //鉴定类别填充children
        fitData(catVoList, catChild);

        createDataNo(catVoList, new OutlineTreeVo());

        return catVoList;
    }

    /**
     * 查询鉴定类别数据
     *
     * @param outlineId 鉴定大纲id
     * @param catList   鉴定类别数据
     * @param catIds    鉴定类别所有id
     * @param catVoList 鉴定类别数据转tree数据
     */
    private void queryCatList(String outlineId, List<LimsTestingCategory> catList, List<String> catIds, List<OutlineTreeVo> catVoList) {
        QueryWrapper<LimsTestingCategory> categoryQueryWrapper = new QueryWrapper<>();
        categoryQueryWrapper.lambda().eq(LimsTestingCategory::getOutlineId, outlineId).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);

        List<String> ids = catList.stream().map(LimsTestingCategory::getId).collect(Collectors.toList());
        catIds.addAll(ids);

    }

    /**
     * 查询鉴定类型数据
     *
     * @param catIds    鉴定类别所有id
     * @param typList   鉴定类型数据
     * @param typIds    鉴定类型所有id
     * @param typVoList 鉴定类型数据转tree数据
     * @param catChild  鉴定类别的 children
     */
    private void queryTypList(List<String> catIds, List<LimsTestingType> typList, List<String> typIds, List<OutlineTreeVo> typVoList, Map<String, List<OutlineTreeVo>> catChild) {
        QueryWrapper<LimsTestingType> typQueryWrapper = new QueryWrapper<>();
        if (catIds.size() < 1) return;
        typQueryWrapper.lambda().in(LimsTestingType::getCategoryId, catIds).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);
        List<String> ids = typList.stream().map(LimsTestingType::getId).collect(Collectors.toList());
        typIds.addAll(ids);
    }

    /**
     * 查询鉴定类型数据
     *
     * @param typIds     鉴定类型所有id
     * @param itmList    鉴定项目数据
     * @param itemVoList 鉴定项目数据转tree数据
     * @param typChild   鉴定类型的 children
     */
    private void queryItmList(List<String> typIds, List<LimsTestingItem> itmList, List<OutlineTreeVo> itemVoList, Map<String, List<OutlineTreeVo>> typChild) {
        QueryWrapper<LimsTestingItem> itemQueryWrapper = new QueryWrapper<>();
        if (typIds.size() < 1) return;
        itemQueryWrapper.lambda().in(LimsTestingItem::getTypeId, typIds).orderByAsc(LimsTestingItem::getSort);
        itmList.addAll(itemMapper.selectList(itemQueryWrapper));
        List<OutlineTreeVo> voList = itmList.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.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);
        List<String> ids = itmList.stream().map(LimsTestingItem::getId).collect(Collectors.toList());
        typIds.addAll(ids);
    }

    /**
     * 填充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);
            }

        }

    }

}