package com.ruoyi.project.service.impl;

import java.util.Iterator;
import java.util.List;

import com.ruoyi.common.core.domain.AddressSelect;
import com.ruoyi.common.core.domain.TreeSelect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import java.util.ArrayList;
import java.util.stream.Collectors;

import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.project.mapper.BasePrcaddressDictMapper;
import com.ruoyi.project.service.IBasePrcaddressDictService;
import com.ruoyi.common.core.domain.entity.BasePrcaddressDict;

/**
 * 省市区管理Service业务层处理
 * 
 * @author ruoyi
 * @date 2021-11-15
 */
@Service
public class BasePrcaddressDictServiceImpl extends ServiceImpl<BasePrcaddressDictMapper, BasePrcaddressDict> implements IBasePrcaddressDictService 
{

    @Autowired
    private BasePrcaddressDictMapper basePrcaddressDictMapper;


    /**
     * 查询省市区管理列表
     * 
     * @param basePrcaddressDict 省市区管理
     * @return 省市区管理
     */
    @Override
    public List<BasePrcaddressDict> queryList(BasePrcaddressDict basePrcaddressDict) {
        LambdaQueryWrapper<BasePrcaddressDict> wrappers = Wrappers.lambdaQuery();
        if (StringUtils.isNotBlank(basePrcaddressDict.getAreanumber())){
            wrappers.eq(BasePrcaddressDict::getAreanumber ,basePrcaddressDict.getAreanumber());
        }
        if (StringUtils.isNotBlank(basePrcaddressDict.getAreaname())){
            wrappers.like(BasePrcaddressDict::getAreaname ,basePrcaddressDict.getAreaname());
        }
        if (StringUtils.isNotBlank(basePrcaddressDict.getSuperiorareanumber())){
            wrappers.eq(BasePrcaddressDict::getSuperiorareanumber ,basePrcaddressDict.getSuperiorareanumber());
        }
        if (basePrcaddressDict.getArealv() != null){
            wrappers.eq(BasePrcaddressDict::getArealv ,basePrcaddressDict.getArealv());
        }
        if (StringUtils.isNotBlank(basePrcaddressDict.getPym())){
            wrappers.eq(BasePrcaddressDict::getPym ,basePrcaddressDict.getPym());
        }
        if (StringUtils.isNotBlank(basePrcaddressDict.getWbm())){
            wrappers.eq(BasePrcaddressDict::getWbm ,basePrcaddressDict.getWbm());
        }
        return this.list(wrappers);
    }

    @Override
    public List<BasePrcaddressDict> selectBasePrcaddressDictList(BasePrcaddressDict basePrcaddressDict) {
        return basePrcaddressDictMapper.selectBasePrcaddressDictList(basePrcaddressDict);
    }

    @Override
    public List<AddressSelect> buildAddressTreeSelect(List<BasePrcaddressDict> basePrcaddressDicts) {
        List<BasePrcaddressDict> addressTrees = buildAddressTree(basePrcaddressDicts);
        return addressTrees.stream().map(AddressSelect::new).collect(Collectors.toList());

    }

    @Override
    public List<BasePrcaddressDict> buildAddressTree(List<BasePrcaddressDict> basePrcaddressDicts) {
        List<BasePrcaddressDict> returnList = new ArrayList<BasePrcaddressDict>();
        List<String> tempList = new ArrayList<String>();
        for (BasePrcaddressDict basePrcaddressDict : basePrcaddressDicts) {
            tempList.add(basePrcaddressDict.getAreanumber());
        }
        for (Iterator<BasePrcaddressDict> iterator = basePrcaddressDicts.iterator(); iterator.hasNext();){

            BasePrcaddressDict basePrcaddressDict = (BasePrcaddressDict) iterator.next();
            // 如果是顶级节点, 遍历该父节点的所有子节点
            if (!tempList.contains(basePrcaddressDict.getSuperiorareanumber()))
            {
                recursionFn(basePrcaddressDicts, basePrcaddressDict);
                returnList.add(basePrcaddressDict);
            }

        }

        if (returnList.isEmpty())
        {
            returnList = basePrcaddressDicts;
        }
        return returnList;
    }


    /**
     * 递归列表
     */
    private void recursionFn(List<BasePrcaddressDict> list, BasePrcaddressDict t)
    {
        // 得到子节点列表
        List<BasePrcaddressDict> childList = getChildList(list, t);
        t.setChildren(childList);
        for (BasePrcaddressDict tChild : childList)
        {
            if (hasChild(list, tChild))
            {
                recursionFn(list, tChild);
            }
        }
    }

    /**
     * 得到子节点列表
     */
    private List<BasePrcaddressDict> getChildList(List<BasePrcaddressDict> list, BasePrcaddressDict t)
    {
        List<BasePrcaddressDict> tlist = new ArrayList<BasePrcaddressDict>();
        Iterator<BasePrcaddressDict> it = list.iterator();
        while (it.hasNext())
        {
            BasePrcaddressDict n = (BasePrcaddressDict) it.next();
            if (StringUtils.isNotNull(n.getSuperiorareanumber()) && n.getSuperiorareanumber().equals(t.getAreanumber()))
            {
                tlist.add(n);
            }
        }
        return tlist;
    }

    /**
     * 判断是否有子节点
     */
    private boolean hasChild(List<BasePrcaddressDict> list, BasePrcaddressDict t)
    {
        return getChildList(list, t).size() > 0 ? true : false;
    }


}