package jp.ac.u_ryukyu.cr.ie.tatsuki.bbs;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import fj.Ord;
import fj.P2;
import fj.data.TreeMap;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.InterfaceTraverser;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;

public class JuGrix {
	
	JungleTree personTree;
	JungleTree organizationTree;
	JungleTree roleTree;
	JungleTree rdeTree;
	public JuGrix(){
		try{
			loadXml reader = new loadXml();
			personTree = reader.loadTestData("Person.xml");
			organizationTree = reader.loadTestData("Organization.xml");
			roleTree = reader.loadTestData("Role.xml");
			rdeTree = reader.loadTestData("RoleDescriptionElement.xml");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public boolean isActive(String id){
		
		InterfaceTraverser ifTraverser = personTree.getTraverser();
		Iterator<Pair<TreeNode,NodePath>> pairIterator = ifTraverser.find(
				(TreeNode node) -> {
					String personId = node.getAttributes().getString("id");
					if (personId == null)
						return false;
					if (personId.equals(id)) 
						return true;
					return false;
				}
				,"id",id);

		if (pairIterator.hasNext())
			return true;
		return false;
		
	}
	
	public Iterator<String> personIds(String orgId, LinkedList<String> roleIds){
		return personIdsSearch(orgId, roleIds).iterator();
	}
	
	public LinkedList<String> personIdLink(String orgId, LinkedList<String> roleIds){
		return personIdsSearch(orgId, roleIds);
	}
	
	public Iterator<String> personIds(LinkedList<String> orgIds ,LinkedList<String> roleIds){
		
		LinkedList<String> personIds = new LinkedList<String>();

		for (String orgId : orgIds) {
			personIds.addAll(personIdsSearch(orgId, roleIds));
		}
		return personIds.iterator();
	}
	
	private LinkedList<String> personIdsSearch(String id, LinkedList<String> roleIds) {
		
		if (!filter(id, roleIds))
			return new LinkedList<String>();
			
		InterfaceTraverser personTraverser = personTree.getTraverser();
		Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = personTraverser.find(
				(TreeNode node) -> {
					String personId = node.getAttributes().getString("element");
					if (personId == null)
						return false;
					if (personId.equals("Person")) 
						return true;
					return false;
				}
				,"element","Person");
		
		LinkedList<String> names = new LinkedList<String>();
		
		for (;pairPersonIterator.hasNext();) {
			
			Pair<TreeNode, NodePath> pairPerson = pairPersonIterator.next();
			Iterator<Pair<TreeNode,NodePath>> pairIdIterator = personTraverser.findInSubTree(
					(TreeNode node) -> {
						String personId = node.getAttributes().getString("text");
						if (personId == null)
							return false;
						if (personId.equals(id)) 
							return true;
						return false;
					}
					,pairPerson.left(),"text",id);
			
			if (pairIdIterator.hasNext()) {
					String name = pairPerson.left().getAttributes().getString("id");
					names.add(name);
			}
		}
		return names;
	}


	public boolean filter(String orgId, LinkedList<String> roleIds) {
		if (roleIds == null)
			return true;
		 
		InterfaceTraverser orgTraverser = organizationTree.getTraverser();
		
		Iterator<Pair<TreeNode,NodePath>> orgNodeIterator = orgTraverser.find(
				(TreeNode node) -> {
					String personId = node.getAttributes().getString("element");
					if (personId == null)
						return false;
					if (!personId.equals("Organization")) 
						return false;
					 String compareOrgId = node.getAttributes().getString("id");
					if (compareOrgId == null)
						return false;
					if (compareOrgId.equals(orgId))
						return true;
					return false;
				},"id", orgId);
		
		if (!orgNodeIterator.hasNext())
			return false;
		
		TreeNode searchNode = orgNodeIterator.next().left();
		
		for (String id : roleIds) {
			Pattern personPattern = Pattern.compile("r:");
			Matcher personMacher = personPattern.matcher(id);
			if (personMacher.find()) {
				if (!roleFilter(id , searchNode))
					return false;
			}
			
			Pattern organizationPattern = Pattern.compile("rde:");
			Matcher organizationMacher = organizationPattern.matcher(id);
			if (organizationMacher.find()) {
				if (!rdeFilter(id,searchNode))
					return false;
			}
		}
		return true;
	}

	private boolean rdeFilter(String id, TreeNode targetNode) {
		
		InterfaceTraverser orgTraverser = organizationTree.getTraverser();
		Iterator<Pair<TreeNode,NodePath>> pairIdIterator = orgTraverser.findInSubTree(
				(TreeNode node) -> {
					String element = node.getAttributes().getString("element");
					if (element == null)
						return false;
					if (!element.equals("roleRefId")) 
						return false;
					String roleId = node.getAttributes().getString("text");
					if (roleId != null)
						return true;
					return false;
				}
				,targetNode,"element", "roleRefId");
		
		TreeMap<String, String> idMap = TreeMap.empty(Ord.stringOrd);
		for (; pairIdIterator.hasNext();) {
			String roleId = pairIdIterator.next().left().getAttributes().getString("text");
			idMap = idMap.set(roleId,roleId);
		}
		
		Iterator<P2<String, String>> ids = idMap.iterator();
		InterfaceTraverser roleTraverser = roleTree.getTraverser();
		
		for (;ids.hasNext();) {
			String roleId = ids.next()._1();
			Iterator<Pair<TreeNode,NodePath>> roleNodeIterator = roleTraverser.find(
					(TreeNode node) -> {
						String element = node.getAttributes().getString("element");
						if (element == null)
							return false;
						if (!element.equals("Role")) 
							return false;
						String compareRoleId = node.getAttributes().getString("id");
						if (compareRoleId == null)
							return false;
						if (compareRoleId.equals(roleId))
							return true;
						return false;
					}
					,"id",roleId);
			// -----------------------------------------bug------------------------------------------
			for (;roleNodeIterator.hasNext();) {
				TreeNode roleNode = roleNodeIterator.next().left();
				Iterator<Pair<TreeNode,NodePath>> rdeNodeIterator = roleTraverser.findInSubTree(
						(TreeNode node) -> {
							String elementName = node.getAttributes().getString("element");
							if (elementName == null)
								return false;
							if (!elementName.equals("roleDescriptionElementRefIds")) 
								return false;
							String rdeId = node.getAttributes().getString("text");
							if (rdeId == null)
								return false;
							Pattern personPattern = Pattern.compile(id);
							Matcher personMacher = personPattern.matcher(rdeId);
							if (personMacher.find())
								return true;
							return false;
						}
						,roleNode,"text","id");
					
				if (!rdeNodeIterator.hasNext())
					return false;
			}
			
		}
		return true;
	}

	public boolean roleFilter(String id, TreeNode orgNode) {
		System.out.println(orgNode.getAttributes().getString("id"));
		InterfaceTraverser orgTraverser = organizationTree.getTraverser();
		
		Iterator<Pair<TreeNode,NodePath>> pairIdIterator = orgTraverser.findInSubTree(
				(TreeNode node) -> {
					String elementName = node.getAttributes().getString("element");
					if (elementName == null)
						return false;
					if (!elementName.equals("roleRefIds")) 
						return false;
					String roleId = node.getAttributes().getString("text");
					if (roleId == null)
						return false;
					if (roleId.equals(id))
						return true;
					return false;
				}
				,orgNode,"text", id);
		
		if (pairIdIterator.hasNext()){
			System.out.println(pairIdIterator.next().left().getAttributes().getString("text"));
			return true;
		}
		return false;
	}

	public Iterator<String> roleIds(String id) {
		Pattern personPattern = Pattern.compile("p:");
		Matcher personMacher = personPattern.matcher(id);
		if (personMacher.find()) {
			return searchRoleIds(personTree, id, "Person");
		}
		
		Pattern organizationPattern = Pattern.compile("o:");
		Matcher organizationMacher = organizationPattern.matcher(id);
		if (organizationMacher.find()) {
			return searchRoleIds(organizationTree, id, "Organization");
		}
		
		return null;
	}
	
	public Iterator<String> searchRoleIds(JungleTree tree, String id, String element){
		
		InterfaceTraverser ifTraverser = tree.getTraverser();
		Iterator<Pair<TreeNode,NodePath>> searchTargetIterator = ifTraverser.find(
				(TreeNode node) -> {
					String nodeElement = node.getAttributes().getString("element");
					if (nodeElement == null)
						return false;
					if (!nodeElement.equals(element)) 
						return false;
					String nodeId = node.getAttributes().getString("id");
					if (nodeId == null)
						return false;
					if (nodeId.equals(id)) 
						return true;
					return false;
				}
				,"id",id);
		
		LinkedList<String> ids = new LinkedList<String>();
		
		for (;searchTargetIterator.hasNext();) {
			
			Pair<TreeNode, NodePath> searchTargetPair = searchTargetIterator.next();
			Iterator<Pair<TreeNode,NodePath>> pairIdIterator = ifTraverser.findInSubTree(
					(TreeNode node) -> {
						String nodeElement = node.getAttributes().getString("element");
						if (nodeElement == null)
							return false;
						if (!nodeElement.equals("roleRefId")) 
							return false;
						String nodeId = node.getAttributes().getString("text");
						if (nodeId != null)
							return true;
						return false;
					}
					,searchTargetPair.left(),"element","roleRefId");
			

			for (;pairIdIterator.hasNext();){
				Pair<TreeNode, NodePath> idNodePath = pairIdIterator.next();
				String attribute = idNodePath.left().getAttributes().getString("text");
				
				Iterator<String> checkList = ids.iterator();
				for (;checkList.hasNext();) {
					if(checkList.next().equals(attribute))
						attribute = null;
				}
				
				if (attribute != null) {
					ids.add(attribute);
					System.out.println("-------------------------" + attribute + "-------------------------");
				}
			}
		}
		return ids.iterator();
	}
	
	
	public Iterator<String> competentRoleId(String personId) {
		
		InterfaceTraverser ifTraverser = personTree.getTraverser();
		Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = searchPerson(personId, ifTraverser);
		
		if (!pairPersonIterator.hasNext()) 
			return new NullIterator();
		TreeNode person = pairPersonIterator.next().left();
		
		Iterator<Pair<TreeNode,NodePath>> targetPairIterator = ifTraverser.findInSubTree(
				(TreeNode node) -> {
					String nodeElement = node.getAttributes().getString("element");
					if (nodeElement == null)
						return false;
					if (!nodeElement.equals("priority")) 
						return false;
					String priority = node.getAttributes().getString("text");
					if (priority == null)
						return false;
					if (priority.equals("0"))
						return true;
					return false;
				}
				,person,"text","0");
		
		
		LinkedList<String> idList = new LinkedList<String>();
		for (;targetPairIterator.hasNext();) {
			NodePath searchPath = targetPairIterator.next().right();
			Pair<Integer, NodePath> searchPair = searchPath.last();
			NodePath targetPath = searchPair.right().add(searchPair.left() + 1);
			TreeNode targetNode = getTarget(person, targetPath);
			String id = targetNode.getAttributes().getString("text");
			idList.add(id);
		}
		
		return idList.iterator();
	}

	
	public Iterator<String> concurrentRoleIds(String personId) {
		
		InterfaceTraverser ifTraverser = personTree.getTraverser();
		Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = searchPerson(
				personId, ifTraverser);
		
		if (!pairPersonIterator.hasNext()) 
			return new NullIterator();
		TreeNode person = pairPersonIterator.next().left();
		
		Iterator<Pair<TreeNode,NodePath>> targetPairIterator = ifTraverser.findInSubTree(
				(TreeNode node) -> {
					String nodeElement = node.getAttributes().getString("element");
					if (nodeElement == null)
						return false;
					if (!nodeElement.equals("priority")) 
						return false;
					String priority = node.getAttributes().getString("text");
					if (priority == null)
						return false;
					if (!priority.equals("0"))
						return true;
					return false;
				}
				,person,"text","0");
		
		
		LinkedList<String> idList = new LinkedList<String>();
		for (;targetPairIterator.hasNext();) {
			NodePath searchPath = targetPairIterator.next().right();
			Pair<Integer, NodePath> searchPair = searchPath.last();
			NodePath targetPath = searchPair.right().add(searchPair.left() + 1);
			TreeNode targetNode = getTarget(person, targetPath);
			String id = targetNode.getAttributes().getString("text");
			idList.add(id);
		}
		
		return idList.iterator();
	}
	private Iterator<Pair<TreeNode, NodePath>> searchPerson(String personId,
			InterfaceTraverser ifTraverser) {
		Iterator<Pair<TreeNode,NodePath>> pairPersonIterator = ifTraverser.find(
				(TreeNode node) -> {
					String nodeElement = node.getAttributes().getString("element");
					if (nodeElement == null)
						return false;
					if (!nodeElement.equals("Person")) 
						return false;
					String nodeId = node.getAttributes().getString("id");
					if (nodeId == null)
						return false;
					if (nodeId.equals(personId)) 
						return true;
					return false;
				}
				,"element","Person");
		return pairPersonIterator;
	}
	
	
	
	public Iterator<String> deepPersonIds(String orgId, LinkedList<String> filterIds) {
		
		Iterator<String> childrensIterator = deepChildOrganizationIds(orgId, new LinkedList<String>());
		if (!childrensIterator.hasNext())
			return new NullIterator();
		
		LinkedList<String> childrenPersonList = new LinkedList<String>();
		//childrenPersonList.addAll(personIdLink(orgId, filterIds));
		for (;childrensIterator.hasNext();) {
			String id = childrensIterator.next();
			childrenPersonList.addAll(personIdLink(id, filterIds));
		}
	
		return childrenPersonList.iterator();
	}
	
	public Iterator<String> deepChildOrganizationIdsPlus(String orgId, LinkedList<String> filterIds) {
		LinkedList<String> orgList = new LinkedList<String>();
		if (filter(orgId, filterIds))
			orgList.add(orgId);
		orgList.addAll(_deepChildOrganizationIds(orgId,filterIds));
		return orgList.iterator();
	}
	
	public Iterator<String> deepChildOrganizationIds(String orgId, LinkedList<String> filterIds) {
		return _deepChildOrganizationIds(orgId,filterIds).iterator();
	}
	
	public LinkedList<String> _deepChildOrganizationIds(String orgId, LinkedList<String> filterIds) {
				
		Iterator<String> childrensIterator = childOrganizationIds(orgId,new LinkedList<String>());
		if (!childrensIterator.hasNext())
			return new LinkedList<String>();
		
		LinkedList<String> childrenList = new LinkedList<String>();
		for (;childrensIterator.hasNext();) {
			String childrenId = childrensIterator.next();
			if(filter(childrenId,filterIds))
				childrenList.add(childrenId);
			childrenList.addAll(_deepChildOrganizationIds(childrenId, filterIds));
		}
	
		return childrenList;
	}


	public Iterator<String> childOrganizationIds(String orgId, LinkedList<String> filterIds) {
		if(!filter(orgId,filterIds))
			return new NullIterator();
		InterfaceTraverser orgTraverser = organizationTree.getTraverser();
		Iterator<Pair<TreeNode, NodePath>> pairPersonIterator =  orgTraverser.find(
				(TreeNode node) -> {
					String nodeElement = node.getAttributes().getString("element");
					if (nodeElement == null)
						return false;
					if (!nodeElement.equals("Organization")) 
						return false;
					String nodeId = node.getAttributes().getString("id");
					if (nodeId == null)
						return false;
					if (nodeId.equals(orgId)) 
						return true;
					return false;
				},"id", orgId);
		
		if (!pairPersonIterator.hasNext()) 
			return new NullIterator();
		TreeNode person = pairPersonIterator.next().left();
		
		
		Iterator<Pair<TreeNode,NodePath>> chilrenOrgIdsIterator = orgTraverser.findInSubTree(
				(TreeNode node) -> {
					String nodeElement = node.getAttributes().getString("element");
					if (nodeElement == null)
						return false;
					if (nodeElement.equals("childOrganizations")) 
						return true;
					return false;
				}
				,person,"element","childOrganizations");
		
		if (!chilrenOrgIdsIterator.hasNext()) 
			return new NullIterator();
		
		TreeNode chilerenOrgIds = chilrenOrgIdsIterator.next().left();
		
		Iterator<Pair<TreeNode,NodePath>> chilrenOrgIdIterator = orgTraverser.findInSubTree(
				(TreeNode node) -> {
					String nodeElement = node.getAttributes().getString("element");
					if (nodeElement == null)
						return false;
					if (!nodeElement.equals("organizationRefIds")) 
						return false;
					nodeElement = node.getAttributes().getString("text");
					if (nodeElement != null)
						return true;
					return false;
				}
				,chilerenOrgIds, "element", "organizationRefIds");
		
		LinkedList<String> ids = new LinkedList<String>();
		
		for (;chilrenOrgIdIterator.hasNext();) {
			ids.add(chilrenOrgIdIterator.next().left().getAttributes().getString("text"));
		}
		
		return ids.iterator();
	}
	
	
	
	public TreeNode getTarget(TreeNode node , NodePath path){
		TreeNode target;
		Pair<Integer, NodePath> pathNode = path.pop();
		int num = pathNode.left();
		NodePath newPath = pathNode.right();
		if (num == -1 && newPath.size() != 0)
			return getTarget(node, newPath);
			
		Either<Error, TreeNode> either = node.getChildren().at(num);
		if (either.isA())
			return node;
		
		TreeNode child = either.b();
		if (pathNode.right().size() == 0)
			return child;
		
		target = getTarget(child,pathNode.right());
		return target;
	}
	
	class NullIterator implements Iterator<String>{

		@Override
		public boolean hasNext() {
			return false;
		}

		@Override
		public String next() {
			return null;
		}
		
	}

	public String rolePriority(String personId, String roleId) {
		InterfaceTraverser personTraverser = personTree.getTraverser();
		Iterator<Pair<TreeNode,NodePath>> personIterator = personTraverser.find(
				(TreeNode node) -> {
					String element = node.getAttributes().getString("element");
					if (element == null)
						return false;
					if (!element.equals("Person")) 
						return false;
					String nodeId = node.getAttributes().getString("id");
					if (nodeId == null)
						return false;
					if (nodeId.equals(personId)) 
						return true;
					return false;
				},"id",personId);
		
		if (!personIterator.hasNext())
			return "";
		
		TreeNode targetNode = personIterator.next().left();
	
		Iterator<Pair<TreeNode,NodePath>> priorityIterator = personTraverser.findInSubTree(
				(TreeNode node) -> {
					String element = node.getAttributes().getString("element");
					if (element == null)
						return false;
					if (!element.equals("roleRefId")) 
						return false;
					String compareRoleId = node.getAttributes().getString("text");
					if (compareRoleId == null)
						return false;
					if (compareRoleId.equals(roleId)) 
						return true;
					return false;
				},targetNode,"element","roleRefId");
		
		for (;priorityIterator.hasNext();) {
			Pair<TreeNode, NodePath> priorityPair = priorityIterator.next();
			NodePath roleNodePath = priorityPair.right();
			Pair<Integer, NodePath> last = roleNodePath.last();
			NodePath priorityNodePath = last.right().add(last.left() - 1);
			TreeNode priorityNode = getTarget(targetNode,priorityNodePath);
			if (priorityNode.getAttributes().getString("element").equals("priority"))
				return priorityNode.getAttributes().getString("text");
		}
		return "";
	}

	public Iterator<String> parentOrganizationIds(String orgId, LinkedList<String> filterIds) {
		return _parentOrganizationIds(orgId, filterIds).iterator();
	}
	public LinkedList<String> _parentOrganizationIds(String orgId, LinkedList<String> filterIds) {
		
		InterfaceTraverser orgTraverser = organizationTree.getTraverser();
		Iterator<Pair<TreeNode,NodePath>> orgIterator = orgTraverser.find(
				(TreeNode node) -> {
					String element = node.getAttributes().getString("element");
					if (element == null)
						return false;
					if (!element.equals("Organization")) 
						return false;
					String nodeId = node.getAttributes().getString("id");
					if (nodeId == null)
						return false;
					if (nodeId.equals(orgId)) 
						return true;
					return false;
				},"element","Organization");
		
		if (!orgIterator.hasNext())
			return new LinkedList<String>();
		
		TreeNode orgNode = orgIterator.next().left();
		
		Iterator<Pair<TreeNode,NodePath>> parentOrgIterator = orgTraverser.findInSubTree(
				(TreeNode node) -> {
					String element = node.getAttributes().getString("element");
					if (element == null)
						return false;
					if (element.equals("parentOrganizations")) 
						return true;
					return false;
				}, orgNode,"element", "parentOrganizations");
		
		LinkedList<String> parentIds = new LinkedList<String>();
		
		for (;parentOrgIterator.hasNext();) {
			TreeNode parentOrgNode = parentOrgIterator.next().left();
			
			Iterator<Pair<TreeNode,NodePath>> parentNodeIterator = orgTraverser.findInSubTree(
					(TreeNode node) -> {
						String element = node.getAttributes().getString("element");
						if (element == null)
							return false;
						if (!element.equals("organizationRefId")) 
							return false;
						String parentId = node.getAttributes().getString("text");
						if (parentId != null)
							return true;
						return false;
					}, parentOrgNode,"element","organizationRefId");
			
			for (;parentNodeIterator.hasNext();) {
				String parentId = parentNodeIterator.next().left().getAttributes().getString("text");
				if (filter(parentId, filterIds))
					parentIds.add(parentId);
			}
			
			
		}
		
		return parentIds;
	}

	public Iterator<String> deepParentOrganizationIds(String orgId, LinkedList<String> filterIds) {
		return _deepParentOrganizationIds(orgId, filterIds).iterator();
	}
	
	public LinkedList<String> _deepParentOrganizationIds(String orgId, LinkedList<String> filterIds) {

		
		Iterator<String> parentIds = parentOrganizationIds(orgId, filterIds);
		if (!parentIds.hasNext())
			return new LinkedList<String>();
		
		LinkedList<String> parentIdList = new LinkedList<String>();
		
		for (;parentIds.hasNext();) {
			String parentId = parentIds.next();
			if (filter(parentId, filterIds))
				parentIdList.add(parentId);
			parentIdList.addAll(_deepParentOrganizationIds(parentId, filterIds));
		}
		return parentIdList;
	}

	public Iterator<String> deepParentOrganizationIdsPlus(String id,LinkedList<String> filterIds) {
		LinkedList<String> parentIds = new LinkedList<String>();
		if (filter(id, filterIds))
			parentIds.add(id);
		 parentIds.addAll(_deepParentOrganizationIds(id,filterIds));
		return parentIds.iterator();
	}

	public String stringPathToId(String args) {
		String[] splitPath = args.split(":");
		
		String str = splitPath[2];
		for (int count = 3; count < splitPath.length;count++) {
			str = str + ":" + splitPath[count];
		}
		
		final String StrPath = str;
		
		InterfaceTraverser traverser = null;
		TreeNode root = null ;
		if (splitPath[0].equals("r")) {
			traverser = roleTree.getTraverser();
			root = roleTree.getRootNode();
		}
		if (splitPath[0].equals("rde")) {
			traverser = rdeTree.getTraverser();
			root = rdeTree.getRootNode();
		}
		
		Iterator<Pair<TreeNode,NodePath>> idIterator = traverser.find(
				(TreeNode node) -> {
					String element = node.getAttributes().getString("element");
					if (element == null)
						return false;
					if (!element.equals("path")) 
						return false;
					String pathString = node.getAttributes().getString("text");
					if (pathString == null)
						return false;
					if (pathString.equals(StrPath))
						return true;
					return false;
				}, "text","StrPath");
		
		if (!idIterator.hasNext()) 
			return "";
		
		Pair<TreeNode, NodePath> nodePair = idIterator.next();
		NodePath path = nodePair.right();
		NodePath targetPath = path.last().right();
		
		TreeNode targetNode = getTarget(root, targetPath);
		String targetId = targetNode.getAttributes().getString("id");
		return targetId;
	}

	public Iterator<String> roleDescriptionElementIds(String id, LinkedList<String> filterIds) {
		
		 Iterator<String> orgIds = deepParentOrganizationIdsPlus(id, filterIds);
		 
		 LinkedList<String> rdeIds = new LinkedList<String>();
		 
		for (;orgIds.hasNext();) {
			String orgId = orgIds.next();
			Iterator<String> roleIds =  roleIds(orgId);
			for (;roleIds.hasNext();) {
				String roleId = roleIds.next();
				String rdeId = getRde(roleId);
				String[] rdeSplit = rdeId.split(" ");
				for (String rde : rdeSplit) {
					if (!rde.equals(""))
						rdeIds.add(rde);
				}
			}
		}
		
		return rdeIds.iterator();
	}

	private String getRde(String roleId) {
		
		InterfaceTraverser traverser = roleTree.getTraverser();
		
		Iterator<Pair<TreeNode,NodePath>> roleIterator = traverser.find(
				(TreeNode node) -> {
					String element = node.getAttributes().getString("element");
					if (element == null)
						return false;
					if (!element.equals("Role")) 
						return false;
					String id = node.getAttributes().getString("id");
					if (id == null)
						return false;
					if (id.equals(roleId))
						return true;
					return false;
				},"id",roleId);
		
		if (!roleIterator.hasNext())
			return "";
		
		TreeNode roleNode = roleIterator.next().left();
		
		Iterator<Pair<TreeNode,NodePath>> rdeIterator = traverser.findInSubTree(
				(TreeNode node) -> {
					String element = node.getAttributes().getString("element");
					if (element == null)
						return false;
					if (!element.equals("roleDescriptionElementRefIds")) 
						return false;
					String rde = node.getAttributes().getString("text");
					if (rde != null)
						return true;
					return false;
				},roleNode,"element","roleDescriptionElementRefIds");
		
		if (!rdeIterator.hasNext())
			return "";
		
		return rdeIterator.next().left().getAttributes().getString("text");
	}

	
}