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 ac.jp.u_ryukyu.cr.ie.tatsuki.xmlReader.LoadXml;
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(boolean index) {

    try {
      LoadXml reader = new LoadXml();

      if (index == true) {
        personTree = reader.loadTestDataCreateIndex("Person.xml");
        organizationTree = reader.loadTestDataCreateIndex("Organization.xml");
        roleTree = reader.loadTestDataCreateIndex("Role.xml");
        rdeTree = reader.loadTestDataCreateIndex("RoleDescriptionElement.xml");
      } else {
        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 personTraverser = personTree.getTraverser();
    Iterator<Pair<TreeNode, NodePath>> personIdpairIterator = personTraverser.find((TreeNode node) -> {
      String personId = node.getAttributes().getString("Person-id");
      if (personId == null)
        return false;
      if (personId.equals(id))
        return true;
      return false;
    }, "Person-id", id);

    if (personIdpairIterator.hasNext())
      return true;
    return false;

  }

  public Iterator<String> personIds(String orgId, LinkedList<String> roleIds) {

    Iterator<String> parentOrgIdIterator = parentOrganizationIds(orgId, roleIds);
    TreeMap<String, String> personIdsTreeMap = TreeMap.empty(Ord.stringOrd);
    
    if (filter(orgId, roleIds))
      personIdsTreeMap = personIdsSearch(orgId, personIdsTreeMap);

    for (; parentOrgIdIterator.hasNext();) {
      personIdsTreeMap = personIdsSearch(parentOrgIdIterator.next(), personIdsTreeMap);
    }

    if (personIdsTreeMap.isEmpty())
      return new NullIterator();

    Iterator<P2<String, String>> personIdsIterator = personIdsTreeMap.iterator();
    return new Iterator<String>() {

      @Override
      public boolean hasNext() {
        if (personIdsIterator.hasNext())
          return true;
        return false;
      }

      @Override
      public String next() {
        return personIdsIterator.next()._1();
      }

    };
  }

  public Iterator<String> personIds(LinkedList<String> orgIds, LinkedList<String> roleIds) {

    TreeMap<String, String> personIds = TreeMap.empty(Ord.stringOrd);
    for (String orgId : orgIds) {
      personIds = personIdsSearch(orgId, personIds);
    }

    if (personIds.isEmpty())
      return new NullIterator();

    Iterator<P2<String, String>> personIdsIterator = personIds.iterator();

    return new Iterator<String>() {
      String personId;

      @Override
      public boolean hasNext() {
        for (; personIdsIterator.hasNext();) {
          personId = personIdsIterator.next()._1();
          if (filter(personId, roleIds))
            return true;
        }
        return false;
      }

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

    };
  }

  private TreeMap<String, String> personIdsSearch(String orgId, TreeMap<String, String> orgIdsTreeMap) {

    InterfaceTraverser personTraverser = personTree.getTraverser();

    Iterator<Pair<TreeNode, NodePath>> personIdPairIterator = personTraverser.findAll((TreeNode node) -> {
      String personId = node.getAttributes().getString("element");
      if (personId == null)
        return false;
      if (personId.equals("Person"))
        return true;
      return false;
    }, "Person-id");

    for (; personIdPairIterator.hasNext();) {

      Pair<TreeNode, NodePath> personIdPair = personIdPairIterator.next();

      Iterator<Pair<TreeNode, NodePath>> orgIdPairIterator = personTraverser.findInSubTree((TreeNode node) -> {
        String personId = node.getAttributes().getString("text-organizationRefId");
        if (personId == null)
          return false;
        if (personId.equals(orgId))
          return true;
        return false;
      }, personIdPair, "text-organizationRefId", orgId);

      if (orgIdPairIterator.hasNext()) {
        String personId = personIdPair.left().getAttributes().getString("Person-id");
        if (personId != null)
          orgIdsTreeMap = orgIdsTreeMap.set(personId, personId);
      }
    }
    return orgIdsTreeMap;
  }

  public boolean filter(String orgId, LinkedList<String> roleIds) {
    if (roleIds == null)
      return true;

    if (roleIds.isEmpty())
      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("Organization-id");
      if (compareOrgId == null)
        return false;
      if (compareOrgId.equals(orgId))
        return true;
      return false;
    }, "Organization-id", orgId);

    if (!orgNodeIterator.hasNext())
      return false;

    Pair<TreeNode, NodePath> searchNodePair = orgNodeIterator.next();

    for (String id : roleIds) {
      Pattern personPattern = Pattern.compile("r:");
      Matcher personMacher = personPattern.matcher(id);
      if (personMacher.find()) {
        if (roleFilter(id, searchNodePair))
          return false;
      }

      Pattern organizationPattern = Pattern.compile("rde:");
      Matcher organizationMacher = organizationPattern.matcher(id);
      if (organizationMacher.find()) {
        if (!rdeFilter(id, searchNodePair))
          return false;
      }
    }
    return true;
  }

  private boolean rdeFilter(String id, Pair<TreeNode, NodePath> searchNodePair) {

    InterfaceTraverser orgTraverser = organizationTree.getTraverser();
    Iterator<Pair<TreeNode, NodePath>> pairIdIterator = orgTraverser.findInSubTreeAllValue((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-roleRefId");
      if (roleId != null)
        return true;
      return false;
    }, searchNodePair, "text-roleRefId");

    TreeMap<String, String> idMap = TreeMap.empty(Ord.stringOrd);
    for (; pairIdIterator.hasNext();) {
      String roleId = pairIdIterator.next().left().getAttributes().getString("text-roleRefId");
      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("Role-id");
        if (compareRoleId == null)
          return false;
        if (compareRoleId.equals(roleId))
          return true;
        return false;
      }, "Role-id", roleId);

      for (; roleNodeIterator.hasNext();) {
        Pair<TreeNode, NodePath> rolePair = roleNodeIterator.next();
        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-roleDescriptionElementRefIds");
          if (rdeId == null)
            return false;
          Pattern personPattern = Pattern.compile(id);
          Matcher personMacher = personPattern.matcher(rdeId);
          if (personMacher.find())
            return true;
          return false;
        }, rolePair, "text-roleDescriptionElementRefIds", id);

        if (!rdeNodeIterator.hasNext())
          return false;
      }

    }
    return true;
  }

  public boolean roleFilter(String id, Pair<TreeNode, NodePath> searchNodePair) {
    // System.out.println(searchNodePair.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-roleRefIds");
      if (roleId == null)
        return false;
      if (roleId.equals(id))
        return true;
      return false;
    }, searchNodePair, "text-roleRefIds", id);

    if (pairIdIterator.hasNext()) {
      System.out.println(pairIdIterator.next().left().getAttributes().getString("text-roleRefIds"));
      return false;
    }
    return true;
  }

  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 new NullIterator();
  }

  public Iterator<String> searchRoleIds(JungleTree tree, String id, String element) {

    InterfaceTraverser traverser = tree.getTraverser();

    Iterator<Pair<TreeNode, NodePath>> idPairIterator = traverser.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(element + "-id");
      if (nodeId == null)
        return false;
      if (nodeId.equals(id))
        return true;
      return false;
    }, element + "-id", id);

    TreeMap<String, String> idsTreeMap = TreeMap.empty(Ord.stringOrd);
    ;

    for (; idPairIterator.hasNext();) {

      Pair<TreeNode, NodePath> targetPair = idPairIterator.next();

      Iterator<Pair<TreeNode, NodePath>> roleIdPairIterator = traverser.findInSubTreeAllValue((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-roleRefId");
        if (nodeId != null)
          return true;
        return false;
      }, targetPair, "text-roleRefId");

      for (; roleIdPairIterator.hasNext();) {
        Pair<TreeNode, NodePath> roleIdPair = roleIdPairIterator.next();
        String roleId = roleIdPair.left().getAttributes().getString("text-roleRefId");
        idsTreeMap = idsTreeMap.set(roleId, roleId);
      }
    }

    if (idsTreeMap.isEmpty())
      return new NullIterator();

    Iterator<P2<String, String>> ids = idsTreeMap.iterator();
    return new Iterator<String>() {

      @Override
      public boolean hasNext() {
        if (ids.hasNext())
          return true;
        return false;
      }

      @Override
      public String next() {
        return ids.next()._1();
      }

    };
  }

  public Iterator<String> competentRoleId(String personId) {

    InterfaceTraverser personTraverser = personTree.getTraverser();
    Iterator<Pair<TreeNode, NodePath>> personIdPairIterator = personTraverser.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("Person-id");
      if (nodeId == null)
        return false;
      if (nodeId.equals(personId))
        return true;
      return false;
    }, "Person-id", personId);

    if (!personIdPairIterator.hasNext())
      return new NullIterator();

    Pair<TreeNode, NodePath> personIdPair = personIdPairIterator.next();

    Iterator<Pair<TreeNode, NodePath>> priorityPairIterator = personTraverser.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-priority");
      if (priority == null)
        return false;
      if (priority.equals("0"))
        return true;
      return false;
    }, personIdPair, "text-priority", "0");

    TreeMap<String, String> roleIdTreeMap = TreeMap.empty(Ord.stringOrd);

    for (; priorityPairIterator.hasNext();) {

      Pair<TreeNode, NodePath> priorityPair = priorityPairIterator.next();
      NodePath priorityPath = priorityPair.right();
      Pair<Integer, NodePath> removeLastPair = priorityPath.last();
      NodePath roleIdNodePath = removeLastPair.right().add(removeLastPair.left() + 1);
      TreeNode roleIdNode = getTarget(personTree.getRootNode(), roleIdNodePath);
      String roleId = roleIdNode.getAttributes().getString("text-roleRefId");
      roleIdTreeMap = roleIdTreeMap.set(roleId, roleId);
    }
    Iterator<P2<String, String>> roleIdP2Iterator = roleIdTreeMap.iterator();
    return new Iterator<String>() {

      @Override
      public boolean hasNext() {
        if (roleIdP2Iterator.hasNext())
          return true;
        return false;
      }

      @Override
      public String next() {
        return roleIdP2Iterator.next()._1();
      }
    };
  }

  public Iterator<String> concurrentRoleIds(String personId) {

    InterfaceTraverser personTraverser = personTree.getTraverser();
    Iterator<Pair<TreeNode, NodePath>> personIdPairIterator = personTraverser.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("Person-id");
      if (nodeId == null)
        return false;
      if (nodeId.equals(personId))
        return true;
      return false;
    }, "Person-id", personId);

    if (!personIdPairIterator.hasNext())
      return new NullIterator();

    Pair<TreeNode, NodePath> personidPair = personIdPairIterator.next();

    Iterator<Pair<TreeNode, NodePath>> priorityPairIterator = personTraverser.findInSubTreeAllValue(
        (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-priority");
          if (priority != null)
            return true;
          return false;
        }, personidPair, "text-priority");

    TreeMap<String, String> roleIdTreeMap = TreeMap.empty(Ord.stringOrd);

    for (; priorityPairIterator.hasNext();) {

      Pair<TreeNode, NodePath> priorityPair = priorityPairIterator.next();
      TreeNode priorityNode = priorityPair.left();
      int priority = Integer.parseInt(priorityNode.getAttributes().getString("text-priority"));
      if (priority > 0) {
        NodePath priorityPath = priorityPair.right();
        Pair<Integer, NodePath> removeLastPair = priorityPath.last();
        NodePath roleIdNodePath = removeLastPair.right().add(removeLastPair.left() + 1);
        TreeNode roleIdNode = getTarget(personTree.getRootNode(), roleIdNodePath);
        String roleId = roleIdNode.getAttributes().getString("text-roleRefId");
        roleIdTreeMap = roleIdTreeMap.set(roleId, roleId);
      }
    }
    Iterator<P2<String, String>> roleIdP2Iterator = roleIdTreeMap.iterator();
    return new Iterator<String>() {

      @Override
      public boolean hasNext() {
        if (roleIdP2Iterator.hasNext())
          return true;
        return false;
      }

      @Override
      public String next() {
        return roleIdP2Iterator.next()._1();
      }
    };
  }

  public Iterator<String> deepPersonIds(String orgId, LinkedList<String> filterIds) {
    
    TreeMap<String, String> personIdsTreeMap = TreeMap.empty(Ord.stringOrd);
    Iterator<String> childrensIterator = deepChildOrganizationIdsPlus(orgId, filterIds);
    
    
    if (!childrensIterator.hasNext())
      return new NullIterator();

    for (; childrensIterator.hasNext();) {
      String id = childrensIterator.next();
      personIdsTreeMap = personIdsSearch(id, personIdsTreeMap);
    }

    if (personIdsTreeMap.isEmpty())
      return new NullIterator();

    Iterator<P2<String, String>> personIds = personIdsTreeMap.iterator();
    return new Iterator<String>() {

      @Override
      public boolean hasNext() {
        if (personIds.hasNext())
          return true;
        return false;
      }

      @Override
      public String next() {
        return personIds.next()._1();
      }
    };
  }

  public Iterator<String> deepChildOrganizationIdsPlus(String orgId, LinkedList<String> filterIds) {
    TreeMap<String, String> orgIdsTreeMap = TreeMap.empty(Ord.stringOrd);

    orgIdsTreeMap = orgIdsTreeMap.set(orgId, orgId);
    orgIdsTreeMap = _deepChildOrganizationIds(orgId, orgIdsTreeMap);

    if (orgIdsTreeMap.isEmpty())
      return new NullIterator();

    Iterator<P2<String, String>> orgIdsP2Iterator = orgIdsTreeMap.iterator();
    return new Iterator<String>() {

      String childOrgId;

      @Override
      public boolean hasNext() {
        for (; orgIdsP2Iterator.hasNext();) {
          childOrgId = orgIdsP2Iterator.next()._1();
          if (filter(childOrgId, filterIds))
            return true;
        }
        return false;
      }

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

  public Iterator<String> deepChildOrganizationIds(String orgId, LinkedList<String> filterIds) {

    TreeMap<String, String> orgIdsTreeMap = TreeMap.empty(Ord.stringOrd);
    TreeMap<String, String> newOrgIdsTreeMap = _deepChildOrganizationIds(orgId, orgIdsTreeMap);
    if (newOrgIdsTreeMap.isEmpty())
      return new NullIterator();

    Iterator<P2<String, String>> orgIdP2Iterator = newOrgIdsTreeMap.iterator();

    return new Iterator<String>() {
      String childOrgId;

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

      @Override
      public boolean hasNext() {
        for (; orgIdP2Iterator.hasNext();) {
          childOrgId = orgIdP2Iterator.next()._1();
          if (filter(childOrgId, filterIds))
            return true;
        }
        return false;
      }
    };
  }

  public TreeMap<String, String> _deepChildOrganizationIds(String orgId, TreeMap<String, String> orgIdsTreeMap) {

    TreeMap<String, String> childrenIdTreeMap = _childOrganizationIds(orgId, TreeMap.empty(Ord.stringOrd));

    if (childrenIdTreeMap.isEmpty())
      return orgIdsTreeMap;

    Iterator<P2<String, String>> childrenIdIterator = childrenIdTreeMap.iterator();

    for (; childrenIdIterator.hasNext();) {
      String childrenId = childrenIdIterator.next()._1();
      orgIdsTreeMap = orgIdsTreeMap.set(childrenId, childrenId);
      orgIdsTreeMap = _deepChildOrganizationIds(childrenId, orgIdsTreeMap);
    }

    return orgIdsTreeMap;
  }

  public Iterator<String> childOrganizationIds(String orgId, LinkedList<String> filterIds) {
    TreeMap<String, String> childrenOrgIdTreeMap = TreeMap.empty(Ord.stringOrd);
    TreeMap<String, String> newChildrenOrgIdTreeMap = _childOrganizationIds(orgId, childrenOrgIdTreeMap);

    if (newChildrenOrgIdTreeMap.isEmpty())
      return new NullIterator();

    Iterator<P2<String, String>> childrenOrgIdIterator = newChildrenOrgIdTreeMap.iterator();

    return new Iterator<String>() {
      String childOrgId;

      @Override
      public boolean hasNext() {

        if (childrenOrgIdIterator.hasNext()) {
          childOrgId = childrenOrgIdIterator.next()._1();
          if (filter(childOrgId, filterIds))
            return true;
        }
        return false;
      }

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

  }

  public TreeMap<String, String> _childOrganizationIds(String orgId, TreeMap<String, String> childOrgIdsTreeMap) {

    InterfaceTraverser orgTraverser = organizationTree.getTraverser();

    Iterator<Pair<TreeNode, NodePath>> orgIdPairIterator = 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("Organization-id");
      if (nodeId == null)
        return false;
      if (nodeId.equals(orgId))
        return true;
      return false;
    }, "Organization-id", orgId);

    if (!orgIdPairIterator.hasNext())
      return childOrgIdsTreeMap;

    Pair<TreeNode, NodePath> orgIdPair = orgIdPairIterator.next();

    Iterator<Pair<TreeNode, NodePath>> chilrenOrgPairIterator = orgTraverser.findInSubTree((TreeNode node) -> {
      String nodeElement = node.getAttributes().getString("element");
      if (nodeElement == null)
        return false;
      if (nodeElement.equals("childOrganizations"))
        return true;
      return false;
    }, orgIdPair, "element", "childOrganizations");

    if (!chilrenOrgPairIterator.hasNext())
      return childOrgIdsTreeMap;

    Pair<TreeNode, NodePath> chilerenOrg = chilrenOrgPairIterator.next();

    Iterator<Pair<TreeNode, NodePath>> chilrenOrgIdPairIterator = orgTraverser.findInSubTreeAllValue(
        (TreeNode node) -> {
          String nodeElement = node.getAttributes().getString("element");
          if (nodeElement == null)
            return false;
          if (!nodeElement.equals("organizationRefIds"))
            return false;
          nodeElement = node.getAttributes().getString("text-organizationRefIds");
          if (nodeElement != null)
            return true;
          return false;
        }, chilerenOrg, "text-organizationRefIds");

    for (; chilrenOrgIdPairIterator.hasNext();) {
      String childrenOrgId = chilrenOrgIdPairIterator.next().left().getAttributes()
          .getString("text-organizationRefIds");
      childOrgIdsTreeMap = childOrgIdsTreeMap.set(childrenOrgId, childrenOrgId);

    }

    return childOrgIdsTreeMap;
  }

  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>> personIdPairIterator = personTraverser.find((TreeNode node) -> {
      String element = node.getAttributes().getString("element");
      if (element == null)
        return false;
      if (!element.equals("Person"))
        return false;
      String nodePersonId = node.getAttributes().getString("Person-id");
      if (nodePersonId == null)
        return false;
      if (nodePersonId.equals(personId))
        return true;
      return false;
    }, "Person-id", personId);

    if (!personIdPairIterator.hasNext())
      return "";

    Pair<TreeNode, NodePath> targetPersonIdPair = personIdPairIterator.next();

    Iterator<Pair<TreeNode, NodePath>> roleIdPairIterator = 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-roleRefId");
      if (compareRoleId == null)
        return false;
      if (compareRoleId.equals(roleId))
        return true;
      return false;
    }, targetPersonIdPair, "text-roleRefId", roleId);

    for (; roleIdPairIterator.hasNext();) {
      Pair<TreeNode, NodePath> roleIdPair = roleIdPairIterator.next();
      NodePath roleIdNodePath = roleIdPair.right();
      Pair<Integer, NodePath> removeLastPath = roleIdNodePath.last();
      NodePath priorityNodePath = removeLastPath.right().add(removeLastPath.left() - 1);
      TreeNode priorityNode = getTarget(personTree.getRootNode(), priorityNodePath);
      if (priorityNode.getAttributes().getString("element").equals("priority"))
        return priorityNode.getAttributes().getString("text-priority");
    }
    return "";
  }

  public Iterator<String> parentOrganizationIds(String orgId, LinkedList<String> filterIds) {

    TreeMap<String, String> parentIdsTreeMap = _parentOrganizationIds(orgId);
    if (parentIdsTreeMap.isEmpty())
      return new NullIterator();

    Iterator<P2<String, String>> parentIdP2Iterator = parentIdsTreeMap.iterator();
    return new Iterator<String>() {
      String parentId;

      @Override
      public boolean hasNext() {
        for (; parentIdP2Iterator.hasNext();) {
          parentId = parentIdP2Iterator.next()._1();
          if (filter(parentId, filterIds))
            return true;
        }
        return false;
      }

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

    };
  }

  public TreeMap<String, String> _parentOrganizationIds(String orgId) {

    InterfaceTraverser orgTraverser = organizationTree.getTraverser();
    Iterator<Pair<TreeNode, NodePath>> orgIdPairIterator = 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("Organization-id");
      if (nodeId == null)
        return false;
      if (nodeId.equals(orgId))
        return true;
      return false;
    }, "Organization-id", orgId);

    if (!orgIdPairIterator.hasNext())
      return TreeMap.empty(Ord.stringOrd);

    Pair<TreeNode, NodePath> orgNode = orgIdPairIterator.next();

    Iterator<Pair<TreeNode, NodePath>> parentOrgPairIterator = 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");

    TreeMap<String, String> parentIdsTreeMap = TreeMap.empty(Ord.stringOrd);

    for (; parentOrgPairIterator.hasNext();) {
      Pair<TreeNode, NodePath> parentOrgNode = parentOrgPairIterator.next();

      Iterator<Pair<TreeNode, NodePath>> parentOrgIdPairIterator = orgTraverser.findInSubTreeAllValue(
          (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-organizationRefId");
            if (parentId != null)
              return true;
            return false;
          }, parentOrgNode, "text-organizationRefId");

      for (; parentOrgIdPairIterator.hasNext();) {
        String parentId = parentOrgIdPairIterator.next().left().getAttributes().getString("text-organizationRefId");
        parentIdsTreeMap = parentIdsTreeMap.set(parentId, parentId);
      }

    }

    return parentIdsTreeMap;

  }

  public Iterator<String> deepParentOrganizationIds(String orgId, LinkedList<String> filterIds) {
    TreeMap<String, String> parentIdsTreeMap = TreeMap.empty(Ord.stringOrd);
    TreeMap<String, String> newParentIdsTreeMap = _deepParentOrganizationIds(orgId, parentIdsTreeMap);

    if (newParentIdsTreeMap.isEmpty())
      return new NullIterator();

    Iterator<P2<String, String>> parentIds = newParentIdsTreeMap.iterator();

    return new Iterator<String>() {
      String parentOrgId;

      @Override
      public boolean hasNext() {
        for (; parentIds.hasNext();) {
          parentOrgId = parentIds.next()._1();
          if (filter(parentOrgId, filterIds))
            return true;
        }
        return false;
      }

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

    };
  }

  public TreeMap<String, String> _deepParentOrganizationIds(String orgId, TreeMap<String, String> orgIds) {

    TreeMap<String, String> parentIdsTreeMap = _parentOrganizationIds(orgId);

    if (parentIdsTreeMap.isEmpty())
      return orgIds;

    Iterator<P2<String, String>> parentIdsIterator = parentIdsTreeMap.iterator();
    for (; parentIdsIterator.hasNext();) {
      String parentId = parentIdsIterator.next()._1();
      orgIds = orgIds.set(parentId, parentId);
      orgIds = _deepParentOrganizationIds(parentId, orgIds);
    }
    return orgIds;
  }

  public Iterator<String> deepParentOrganizationIdsPlus(String id, LinkedList<String> filterIds) {

    TreeMap<String, String> parentIdsTreeMap = TreeMap.empty(Ord.stringOrd);

    parentIdsTreeMap = parentIdsTreeMap.set(id, id);
    parentIdsTreeMap = _deepParentOrganizationIds(id, parentIdsTreeMap);

    if (parentIdsTreeMap.isEmpty())
      return new NullIterator();

    Iterator<P2<String, String>> personIds = parentIdsTreeMap.iterator();
    return new Iterator<String>() {
      String parentOrgId;

      @Override
      public boolean hasNext() {
        for (; personIds.hasNext();) {
          parentOrgId = personIds.next()._1();
          if (filter(parentOrgId, filterIds))
            return true;
        }
        return false;
      }

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

    };
  }

  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;
    String elementName = null;
    if (splitPath[0].equals("r")) {
      traverser = roleTree.getTraverser();
      root = roleTree.getRootNode();
      elementName = "Role";
    }
    if (splitPath[0].equals("rde")) {
      traverser = rdeTree.getTraverser();
      root = rdeTree.getRootNode();
      elementName = "RoleDescriptionElement";
    }

    Iterator<Pair<TreeNode, NodePath>> PathNameIterator = 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-path");
      if (pathString == null)
        return false;
      if (pathString.equals(StrPath))
        return true;
      return false;
    }, "text-path", StrPath);

    if (!PathNameIterator.hasNext())
      return "";

    Pair<TreeNode, NodePath> pathNamePair = PathNameIterator.next();
    NodePath pathNamePath = pathNamePair.right();
    NodePath pathNameIdPath = pathNamePath.last().right();

    TreeNode pathNameIdNode = getTarget(root, pathNameIdPath);
    String pathNameId = pathNameIdNode.getAttributes().getString(elementName + "-id");
    return pathNameId;
  }

  public Iterator<String> roleDescriptionElementIds(String id, LinkedList<String> filterIds) {

    Iterator<String> orgIdsIterator = deepParentOrganizationIdsPlus(id, filterIds);

    TreeMap<String, String> rdeIdsTreeMap = TreeMap.empty(Ord.stringOrd);

    for (; orgIdsIterator.hasNext();) {
      String orgId = orgIdsIterator.next();
      Iterator<String> roleIdIteraotr = roleIds(orgId);
      for (; roleIdIteraotr.hasNext();) {
        String roleId = roleIdIteraotr.next();
        Iterator<String> rdeIdIterator = getRde(roleId);
        for (; rdeIdIterator.hasNext();) {
          String rdeId = rdeIdIterator.next();
          rdeIdsTreeMap = rdeIdsTreeMap.set(rdeId, rdeId);
        }
      }
    }
    if (rdeIdsTreeMap.isEmpty())
      return new NullIterator();

    Iterator<P2<String, String>> rdeIds = rdeIdsTreeMap.iterator();
    return new Iterator<String>() {

      @Override
      public boolean hasNext() {
        if (rdeIds.hasNext())
          return true;
        return false;
      }

      @Override
      public String next() {
        return rdeIds.next()._1();
      }
    };
  }

  private Iterator<String> getRde(String roleId) {

    InterfaceTraverser traverser = roleTree.getTraverser();

    Iterator<Pair<TreeNode, NodePath>> roleIdPairIterator = 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("Role-id");
      if (id == null)
        return false;
      if (id.equals(roleId))
        return true;
      return false;
    }, "Role-id", roleId);

    if (!roleIdPairIterator.hasNext())
      return new NullIterator();

    Pair<TreeNode, NodePath> roleIdPair = roleIdPairIterator.next();

    Iterator<Pair<TreeNode, NodePath>> rdeIdPairIterator = traverser.findInSubTreeAllValue((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-roleDescriptionElementRefIds");
      if (rde != null)
        return true;
      return false;
    }, roleIdPair, "text-roleDescriptionElementRefIds");

    if (!rdeIdPairIterator.hasNext())
      return new NullIterator();

    return new Iterator<String>() {

      @Override
      public boolean hasNext() {
        if (rdeIdPairIterator.hasNext())
          return true;
        return false;
      }

      @Override
      public String next() {
        return rdeIdPairIterator.next().left().getAttributes().getString("text-roleDescriptionElementRefIds");
      }
    };

  }

}