package com.jwipc.sys.util;


import com.jwipc.sys.dto.MenuTreeDTO;

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

/**
 * 把一个list集合,里面的bean含有 parentId 转为树形式
 */
public class TreeUtil {

    /**
     * 根据父节点的ID获取所有子节点
     * @param list 分类表
     * @param typeId 传入的父节点ID
     * @param prefix 子节点前缀
     */
    public List<MenuTreeDTO> getChildTreeObjects(List<MenuTreeDTO> list, int typeId, String prefix){
        if(list == null){
            return null;
        }
        for (Iterator<MenuTreeDTO> iterator = list.iterator(); iterator.hasNext();) {
            MenuTreeDTO node = (MenuTreeDTO) iterator.next();
            // 一、根据传入的某个父节点ID,遍历该父节点的所有子节点
            if (node.getParentId()==typeId) {
                recursionFn(list, node,prefix);
            }
            // 二、遍历所有的父节点下的所有子节点
            /*if (node.getParentId()==0) {
                recursionFn(list, node);
            }*/
        }
        return returnList;
    }

    /**
     * 根据父节点的ID获取所有子节点
     *
     * @param list     分类表
     * @param praentId 传入的父节点ID
     * @return String
     */
    public List<MenuTreeDTO> getChildMenuTreeDTOs(List<MenuTreeDTO> list, Long praentId) {
        for (Iterator<MenuTreeDTO> iterator = list.iterator(); iterator.hasNext(); ) {
            MenuTreeDTO t = iterator.next();
            // 一、根据传入的某个父节点ID,遍历该父节点的所有子节点
            if (t.getParentId().equals(praentId)) {
                //if(t.getType().equals("0")||t.getType().equals("1")){
                recursionFn(list, t);
                returnList.add(t);
                //}
            }
        }
        return returnList;
    }

    /**
     * 递归列表
     *
     * @param list
     * @param t
     * @author lefan
     * Email: 124972225@qq.com
     * @date 2013-12-4 下午7:27:30
     */
    private void recursionFn(List<MenuTreeDTO> list, MenuTreeDTO t) {
        List<MenuTreeDTO> childList = getChildList(list, t);// 得到子节点列表
        t.setChildren(childList);
        for (MenuTreeDTO tChild : childList) {
            if (hasChild(list, tChild)) {// 判断是否有子节点
                //returnList.add(MenuTreeDTO);
                Iterator<MenuTreeDTO> it = childList.iterator();
                while (it.hasNext()) {
                    MenuTreeDTO n = it.next();
                    recursionFn(list, n);
                }
            }
        }
    }

    // 得到子节点列表
    private List<MenuTreeDTO> getChildList(List<MenuTreeDTO> list, MenuTreeDTO t) {

        List<MenuTreeDTO> tlist = new ArrayList<MenuTreeDTO>();
        Iterator<MenuTreeDTO> it = list.iterator();
        while (it.hasNext()) {
            MenuTreeDTO n = it.next();
            List<MenuTreeDTO> tsublist = new ArrayList<MenuTreeDTO>();

            if (n.getParentId().intValue() == t.getId().intValue()) {
                tlist.add(n);
            }
        }
        return tlist;
    }

    List<MenuTreeDTO> returnList = new ArrayList<MenuTreeDTO>();

    /**
     * 根据父节点的ID获取所有子节点
     *
     * @param list   分类表
     * @param typeId 传入的父节点ID
     * @param prefix 子节点前缀
     */
    public List<MenuTreeDTO> getChildMenuTreeDTOs(List<MenuTreeDTO> list, int typeId, String prefix) {
        if (list == null) return null;
        for (Iterator<MenuTreeDTO> iterator = list.iterator(); iterator.hasNext(); ) {
            MenuTreeDTO node = iterator.next();
            // 一、根据传入的某个父节点ID,遍历该父节点的所有子节点
            if (node.getParentId() == typeId) {
                recursionFn(list, node, prefix);
            }
            // 二、遍历所有的父节点下的所有子节点
            /*if (node.getParentId()==0) {
                recursionFn(list, node);
            }*/
        }
        return returnList;
    }

    private void recursionFn(List<MenuTreeDTO> list, MenuTreeDTO node, String p) {
        List<MenuTreeDTO> childList = getChildList(list, node);// 得到子节点列表
        if (hasChild(list, node)) {// 判断是否有子节点
            returnList.add(node);
            Iterator<MenuTreeDTO> it = childList.iterator();
            while (it.hasNext()) {
                MenuTreeDTO n = it.next();
                n.setName(p + n.getName());
                recursionFn(list, n, p + p);
            }
        } else {
            returnList.add(node);
        }
    }

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

    // 本地模拟数据测试
//	public void main(String[] args) {
		/*long start = System.currentTimeMillis();
		List<MenuTreeDTO> MenuTreeDTOList = new ArrayList<MenuTreeDTO>();
		
		MenuTreeDTOUtil mt = new MenuTreeDTOUtil();
		List<MenuTreeDTO> ns=mt.getChildMenuTreeDTOs(MenuTreeDTOList,0);
		for (MenuTreeDTO m : ns) {
			System.out.println(m.getName());
			System.out.println(m.getChildren());
		}
		long end = System.currentTimeMillis();
		System.out.println("用时:" + (end - start) + "ms");*/
//	}

}
