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

import java.util.Iterator;
import java.util.LinkedList;
import java.util.Stack;
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.impl.TreeNode;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.InterfaceTraverser;
import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;

public class JuGrix {

  JungleTree personTree;
  JungleTree organizationTree;
  JungleTree roleTree;
  JungleTree rdeTree;
  boolean useIndex;

  public JuGrix(boolean useIndex) {

    try {
      this.useIndex = useIndex;
      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 JuGrix(boolean useIndex, JungleTree personTree, JungleTree organizationTree, JungleTree roleTree) {

    try {
      this.useIndex = useIndex;
      LoadXml reader = new LoadXml();
      this.personTree = personTree;
      this.organizationTree = organizationTree;
      this.roleTree = roleTree;
      rdeTree = reader.loadTestData("RoleDescriptionElement.xml");

    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  public boolean isActive(String id) {

    InterfaceTraverser personTraverser = personTree.getTraverser(useIndex);
    Iterator<TreeNode> 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> filterIds) {

    InterfaceTraverser orgTraverser = organizationTree.getTraverser(useIndex);

    Iterator<TreeNode> orgIdNodeIterator = orgTraverser.find((TreeNode node) -> {
      String nodeElement = node.getAttributes().getString("element");
      if (nodeElement == null)
        return false;
      if (!nodeElement.equals("Organization"))
        return false;
      String targetOrgId = node.getAttributes().getString("Organization-id");
      if (targetOrgId == null)
        return false;
      if (targetOrgId.equals(orgId))
        return true;
      return false;
    }, "Organization-id", orgId);

    if (!orgIdNodeIterator.hasNext())
      return new NullIterator<String>();

    TreeNode orgIdNode = orgIdNodeIterator.next();
    TreeNode orgRoleIdNodes = orgIdNode.getChildren().at(2).b();
    TreeNode orgRoleIdNode = orgRoleIdNodes.getChildren().at(0).b();
    String orgRoleId = orgRoleIdNode.getAttributes().getString("text-roleRefId");
    if (!filter(filterIds, orgRoleId))
      return new NullIterator<String>();

    InterfaceTraverser traverser = personTree.getTraverser(useIndex);

    return new Iterator<String>() {
      Iterator<TreeNode> orgIdNodeIterator = traverser.find((TreeNode node) -> {
        String nodeElement = node.getAttributes().getString("element");
        if (nodeElement == null)
          return false;
        if (!nodeElement.equals("organizationRefId"))
          return false;
        String targetOrgId = node.getAttributes().getString("text-organizationRefId");
        if (targetOrgId == null)
          return false;
        if (targetOrgId.equals(orgId))
          return true;
        return false;
      }, "text-organizationRefId", orgId);

      String targetPersonId;

      @Override
      public boolean hasNext() {
        for (; orgIdNodeIterator.hasNext();) {
          TreeNode orgIdNode = orgIdNodeIterator.next();
          ParentIndex parentIndex = traverser.getParentIndex();
          TreeNode OrganizationMappedByRoleNode = parentIndex.get(orgIdNode);
          TreeNode parentOrganizations = parentIndex.get(OrganizationMappedByRoleNode);
          TreeNode targetPersonIdNode = parentIndex.get(parentOrganizations);
          targetPersonId = targetPersonIdNode.getAttributes().getString("Person-id");
          return true;
        }
        return false;
      }

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

    };
  }

  public Iterator<String> roleIds(String id, LinkedList<String> filterIds) {
    Pattern personPattern = Pattern.compile("p:");
    Matcher personMacher = personPattern.matcher(id);
    if (personMacher.find()) {
      return searchPersonRoleIds(personTree, id, "Person", filterIds);
    }

    Pattern organizationPattern = Pattern.compile("o:");
    Matcher organizationMacher = organizationPattern.matcher(id);
    if (organizationMacher.find()) {
      return searchOrgRoleIds(organizationTree, id, "Organization", filterIds);
    }

    return new NullIterator<String>();
  }

  public Iterator<String> searchPersonRoleIds(JungleTree tree, String id, String element, LinkedList<String> filterIds) {

    InterfaceTraverser traverser = tree.getTraverser(useIndex);

    return new Iterator<String>() {

      String roleRefId = "";
      Iterator<TreeNode> idNodeIterator = 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);

      Iterator<TreeNode> OrganizationMappedByRoleIterator = getParentOrgs();

      @Override
      public boolean hasNext() {

        if (OrganizationMappedByRoleIterator == null)
          return false;

        if (OrganizationMappedByRoleIterator.hasNext())
          roleRefId = search();
        else
          roleRefId = null;

        if (roleRefId != null)
          return true;

        OrganizationMappedByRoleIterator = getParentOrgs();
        if (OrganizationMappedByRoleIterator != null)
          roleRefId = search();

        if (roleRefId != null)
          return true;

        return this.hasNext();
      }

      private String search() {
        for (; OrganizationMappedByRoleIterator.hasNext();) {
          TreeNode OrganizationMappedByRole = OrganizationMappedByRoleIterator.next();
          TreeNode organizationRefIdNode = OrganizationMappedByRole.getChildren().at(0).b();
          String organizationRefId = organizationRefIdNode.getAttributes().getString("text-organizationRefId");
          if (!filterIds.contains(organizationRefId))
            continue;

          TreeNode roleRefIdNode = OrganizationMappedByRole.getChildren().at(1).b();
          return roleRefIdNode.getAttributes().getString("text-roleRefId");
        }
        OrganizationMappedByRoleIterator = getParentOrgs();

        return null;
      }

      private Iterator<TreeNode> getParentOrgs() {
        for (; idNodeIterator.hasNext();) {
          TreeNode targetPersonNode = idNodeIterator.next();
          TreeNode parentOrganizations = targetPersonNode.getChildren().at(5).b();
          return parentOrganizations.getChildren().iterator();
        }
        return null;
      }

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

    };
  }

  public Iterator<String> searchOrgRoleIds(JungleTree tree, String id, String element, LinkedList<String> filterIds) {

    InterfaceTraverser traverser = tree.getTraverser(useIndex);

    return new Iterator<String>() {

      String roleRefId = "";
      Iterator<TreeNode> idNodeIterator = 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);
      Iterator<TreeNode> OrganizationMappedByRoleIterator = getParentOrgs();

      @Override
      public boolean hasNext() {

        if (OrganizationMappedByRoleIterator == null)
          return false;
        if (OrganizationMappedByRoleIterator.hasNext())
          roleRefId = search();
        else
          roleRefId = null;
        if (roleRefId != null)
          return true;

        OrganizationMappedByRoleIterator = getParentOrgs();
        if (OrganizationMappedByRoleIterator != null)
          roleRefId = search();

        if (roleRefId != null)
          return true;

        return false;
      }

      private String search() {
        for (; OrganizationMappedByRoleIterator.hasNext();) {
          TreeNode OrganizationMappedByRole = OrganizationMappedByRoleIterator.next();
          TreeNode organizationRefIdNode = OrganizationMappedByRole.getChildren().at(0).b();
          String organizationRefId = organizationRefIdNode.getAttributes().getString("text-organizationRefId");
          if (!filterIds.contains(organizationRefId))
            continue;

          TreeNode roleRefIdNode = OrganizationMappedByRole.getChildren().at(1).b();
          return roleRefIdNode.getAttributes().getString("text-roleRefId");
        }
        OrganizationMappedByRoleIterator = getParentOrgs();

        return null;
      }

      private Iterator<TreeNode> getParentOrgs() {
        for (; idNodeIterator.hasNext();) {
          TreeNode targetPersonNode = idNodeIterator.next();
          TreeNode parentOrganizations = targetPersonNode.getChildren().at(4).b();
          return parentOrganizations.getChildren().iterator();
        }
        return null;
      }

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

    };
  }

  public Iterator<String> competentRoleId(String personId) {

    InterfaceTraverser personTraverser = personTree.getTraverser(useIndex);

    return new Iterator<String>() {

      String roleId = "";
      Iterator<TreeNode> personNodeIterator = personTraverser.find((TreeNode node) -> {
        String nodeElement = node.getAttributes().getString("element");
        if (nodeElement == null)
          return false;
        if (!nodeElement.equals("Person"))
          return false;
        String targetPersonId = node.getAttributes().getString("Person-id");
        if (targetPersonId == null)
          return false;
        if (targetPersonId.equals(personId))
          return true;
        return false;
      }, "PersonId", personId);
      Iterator<TreeNode> PriorityMappedByRoleIterator = new NullIterator<TreeNode>();

      @Override
      public boolean hasNext() {

        for (; PriorityMappedByRoleIterator.hasNext();) {
          if (search())
            return true;
        }

        for (; personNodeIterator.hasNext();) {
          TreeNode personNode = personNodeIterator.next();
          TreeNode prioritiesNode = personNode.getChildren().at(6).b();
          PriorityMappedByRoleIterator = prioritiesNode.getChildren().iterator();
          for (; PriorityMappedByRoleIterator.hasNext();) {
            if (search())
              return true;
          }
        }
        return false;
      }

      private boolean search() {
        TreeNode priorityMappedByRole = PriorityMappedByRoleIterator.next();
        TreeNode priorityNode = priorityMappedByRole.getChildren().at(0).b();
        String priority = priorityNode.getAttributes().getString("text-priority");
        if (priority.equals("0")) {
          TreeNode roleIdNode = priorityMappedByRole.getChildren().at(1).b();
          roleId = roleIdNode.getAttributes().getString("text-roleRefId");
          return true;
        }
        return false;
      }

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

  public Iterator<String> concurrentRoleIds(String personId) {

    InterfaceTraverser personTraverser = personTree.getTraverser(useIndex);

    return new Iterator<String>() {

      String roleId = "";
      Iterator<TreeNode> personNodeIterator = personTraverser.find((TreeNode node) -> {
        String nodeElement = node.getAttributes().getString("element");
        if (nodeElement == null)
          return false;
        if (!nodeElement.equals("Person"))
          return false;
        String targetPersonId = node.getAttributes().getString("Person-id");
        if (targetPersonId == null)
          return false;
        if (targetPersonId.equals(personId))
          return true;
        return false;
      }, "PersonId", personId);
      Iterator<TreeNode> PriorityMappedByRoleIterator = new NullIterator<TreeNode>();

      @Override
      public boolean hasNext() {

        for (; PriorityMappedByRoleIterator.hasNext();) {
          if (search())
            return true;
        }

        for (; personNodeIterator.hasNext();) {
          TreeNode personNode = personNodeIterator.next();
          TreeNode prioritiesNode = personNode.getChildren().at(6).b();
          PriorityMappedByRoleIterator = prioritiesNode.getChildren().iterator();
          for (; PriorityMappedByRoleIterator.hasNext();) {
            if (search())
              return true;
          }
        }
        return false;
      }

      private boolean search() {
        TreeNode priorityMappedByRole = PriorityMappedByRoleIterator.next();
        TreeNode priorityNode = priorityMappedByRole.getChildren().at(0).b();
        int priority = Integer.parseInt(priorityNode.getAttributes().getString("text-priority"));

        if (priority > 0) {
          TreeNode roleIdNode = priorityMappedByRole.getChildren().at(1).b();
          roleId = roleIdNode.getAttributes().getString("text-roleRefId");
          return true;
        }
        return false;

      }

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

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

    return new Iterator<String>() {
      Iterator<String> orgIdIterator = deepParentOrganizationIdsPlus(orgId, filterIds);
      private Iterator<String> personIterator = new NullIterator<String>();
      String personId = "";

      @Override
      public boolean hasNext() {
        for (; orgIdIterator.hasNext();) {
          if (personIterator.hasNext()) {
            personId = personIterator.next();
            return true;
          }

          String targetOrgId = orgIdIterator.next();
          personIterator = personIds(targetOrgId, new LinkedList<>());
          if (personIterator.hasNext()) {
            personId = personIterator.next();
            return true;
          }
        }
        return false;
      }

      @Override
      public String next() {
        // TODO Auto-generated method stub
        return personId;
      }

    };
  }

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

    return new Iterator<String>() {
      Iterator<String> childOrgIdIterator = deepChildOrganizationIds(orgId, filterIds);
      String childOrgId = initOrgId();

      @Override
      public boolean hasNext() {
        return childOrgId != null;
      }

      private String initOrgId() {
        if (filter(filterIds, orgId))
          return orgId;
        if (childOrgIdIterator.hasNext())
          return childOrgIdIterator.next();
        return null;
      }

      @Override
      public String next() {
        String str = childOrgId;
        if (childOrgIdIterator.hasNext())
          childOrgId = childOrgIdIterator.next();
        else
          childOrgId = null;
        return str;
      }

    };
  }

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

    return new Iterator<String>() {

      Iterator<TreeNode> childOrgnizationIdsIterator = childOrganizationIdsNode(orgId);
      Stack<String> orgIdStack = new Stack<String>();

      String childOrgId;

      @Override
      public boolean hasNext() {

        for (; childOrgnizationIdsIterator.hasNext();) {
          TreeNode parentOrgIdNode = childOrgnizationIdsIterator.next();
          childOrgId = parentOrgIdNode.getAttributes().getString("text-organizationRefId");
          orgIdStack.push(childOrgId);
          if (orgNodefilter(filterIds, parentOrgIdNode))
            return true;
        }
        if (orgIdStack.isEmpty())
          return false;

        childOrgnizationIdsIterator = childOrganizationIdsNode(orgIdStack.pop());
        return this.hasNext();
      }

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

    };
  }

  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) {

    return new Iterator<String>() {
      Iterator<TreeNode> orgNodeIterator = childOrganizationIdsNode(orgId);
      String organizationRefId;

      @Override
      public boolean hasNext() {
        for (; orgNodeIterator.hasNext();) {
          TreeNode organizationRefIdNode = orgNodeIterator.next();
          organizationRefId = organizationRefIdNode.getAttributes().getString("text-organizationRefId");
          return true;
        }
        return false;
      }

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

    };
  }

  public Iterator<TreeNode> childOrganizationIdsNode(String orgId) {

    InterfaceTraverser orgTraverser = organizationTree.getTraverser(useIndex);

    return new Iterator<TreeNode>() {
      TreeNode childOrgNode;

      Iterator<TreeNode> orgIdNodeIterator = 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);

      Iterator<TreeNode> childOrganizations = getParentOrgs();

      @Override
      public boolean hasNext() {

        if (childOrganizations == null)
          return false;
        if (childOrganizations.hasNext())
          childOrgNode = search();
        else
          childOrgNode = null;
        if (childOrgNode != null)
          return true;

        childOrganizations = getParentOrgs();
        if (childOrganizations != null)
          childOrgNode = search();

        if (childOrgNode != null)
          return true;

        return this.hasNext();
      }

      @Override
      public TreeNode next() {
        return childOrgNode;
      }

      private TreeNode search() {
        for (; childOrganizations.hasNext();) {
          TreeNode OrganizationMappedByRole = childOrganizations.next();
          TreeNode organizationRefIdsNode = OrganizationMappedByRole.getChildren().at(0).b();
          TreeNode organizationRefIdNode = organizationRefIdsNode.getChildren().at(0).b();
          return organizationRefIdNode;

        }
        childOrganizations = getParentOrgs();

        return null;
      }

      private Iterator<TreeNode> getParentOrgs() {
        for (; orgIdNodeIterator.hasNext();) {
          TreeNode targetPersonNode = orgIdNodeIterator.next();
          TreeNode parentOrganizations = targetPersonNode.getChildren().at(3).b();
          return parentOrganizations.getChildren().iterator();
        }
        return null;
      }
    };

  }

  private boolean orgNodefilter(LinkedList<String> filterIds, TreeNode orgNode) {
    String orgId = orgNode.getAttributes().getString("text-organizationRefId");

    return filter(filterIds, orgId);
  }

  private boolean filter(LinkedList<String> filterIds, String id) {

    Pattern orgPattern = Pattern.compile("o:");
    Matcher orgMacher = orgPattern.matcher(id);
    if (orgMacher.find()) {
      id = getRole(id);
    }

    for (String filterId : filterIds) {
      Pattern rolePattern = Pattern.compile("r:");
      Matcher roleMacher = rolePattern.matcher(filterId);
      if (roleMacher.find()) {
        if (!filterId.equals(id)) {
          return false;
        }
      } else {
        Pattern rdePattern = Pattern.compile("rde:");
        Matcher rdeMacher = rdePattern.matcher(filterId);
        if (rdeMacher.find()) {
          if (!getRde(id, filterId))
            return false;
        }
      }
    }
    return true;
  }

  private String getRole(String orgId) {
    InterfaceTraverser orgTraverser = organizationTree.getTraverser(useIndex);
    Iterator<TreeNode> orgNodeIterator = 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");
      if (nodeId == null)
        return false;
      if (nodeId.equals(orgId))
        return true;
      return false;
    }, "Organization-id", orgId);

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

    TreeNode orgNode = orgNodeIterator.next();
    TreeNode roleRefIds = orgNode.getChildren().at(2).b();
    TreeNode roleRefId = roleRefIds.getChildren().at(0).b();
    String roleId = roleRefId.getAttributes().getString("text-roleRefId");
    return roleId;
  }

  private boolean getRde(String roleId, String filterId) {

    InterfaceTraverser roleTraverser = roleTree.getTraverser(useIndex);
    Iterator<TreeNode> rdeIdNodeIterator = roleTraverser.find((TreeNode node) -> {
      String nodeElement = node.getAttributes().getString("element");
      if (nodeElement == null)
        return false;
      if (!nodeElement.equals("Role"))
        return false;
      String nodeId = node.getAttributes().getString("Role-id");
      if (nodeId == null)
        return false;
      if (nodeId.equals(roleId))
        return true;
      return false;
    }, "Role-id", roleId);

    for (; rdeIdNodeIterator.hasNext();) {
      TreeNode rdeIdNode = rdeIdNodeIterator.next();
      TreeNode roleDescriptionElementRefIds = rdeIdNode.getChildren().at(6).b();
      Iterator<TreeNode> roleDescriptionElementRefIdIterator = roleDescriptionElementRefIds.getChildren().iterator();
      for (; roleDescriptionElementRefIdIterator.hasNext();) {
        String roleDescriptionElementRefId = roleDescriptionElementRefIdIterator.next().getAttributes()
            .getString("text-roleDescriptionElementRefId");
        if (roleDescriptionElementRefId.equals(filterId))
          return true;
      }
    }
    return false;
  }

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

    InterfaceTraverser orgTraverser = organizationTree.getTraverser(useIndex);

    Iterator<TreeNode> orgIdNodeIterator = 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 (!orgIdNodeIterator.hasNext())
      return childOrgIdsTreeMap;

    TreeNode orgIdNode = orgIdNodeIterator.next();

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

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

    TreeNode chilerenOrg = chilrenOrgNodeIterator.next();

    Iterator<TreeNode> chilrenOrgIdNodeIterator = 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 (; chilrenOrgIdNodeIterator.hasNext();) {
      String childrenOrgId = chilrenOrgIdNodeIterator.next().getAttributes().getString("text-organizationRefIds");
      childOrgIdsTreeMap = childOrgIdsTreeMap.set(childrenOrgId, childrenOrgId);

    }

    return childOrgIdsTreeMap;
  }

  class NullIterator<T> implements Iterator<T> {

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

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

  }

  public String rolePriority(String personId, String roleId) {

    InterfaceTraverser personTraverser = personTree.getTraverser(useIndex);

    Iterator<TreeNode> roleIdNodeIterator = personTraverser.find((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;
    }, "text-roleRefId", roleId);

    for (; roleIdNodeIterator.hasNext();) {
      TreeNode roleIdNode = roleIdNodeIterator.next();
      ParentIndex parentIndex = personTraverser.getParentIndex();
      TreeNode roleIdParentNode = parentIndex.get(roleIdNode);
      TreeNode parent = parentIndex.get(roleIdParentNode);
      parent = parentIndex.get(parent);
      String nodePersonId = parent.getAttributes().getString("Person-Id");
      if (nodePersonId != null && !nodePersonId.equals(personId))
        continue;
      TreeNode priorityNode = roleIdParentNode.getChildren().at(0).b();
      if (priorityNode.getAttributes().getString("element").equals("priority"))
        return priorityNode.getAttributes().getString("text-priority");
    }
    return "";
  }

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

    return new Iterator<String>() {
      Iterator<TreeNode> orgNodeIterator = parentOrganizationIdsNode(id);
      String organizationRefId;

      @Override
      public boolean hasNext() {
        for (; orgNodeIterator.hasNext();) {
          TreeNode organizationRefIdNode = orgNodeIterator.next();
          String orgId = organizationRefIdNode.getAttributes().getString("text-organizationRefId");
          if (!filter(filterIds, orgId))
            continue;
          organizationRefId = orgId;
          return true;
        }
        return false;
      }

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

    };
  }

  public Iterator<TreeNode> parentOrganizationIdsNode(String id) {

    return new Iterator<TreeNode>() {
      InterfaceTraverser traverser = getTraverser(id);
      String element;
      int pos;

      Iterator<TreeNode> idNodeIterator = 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);

      TreeNode orgId;
      Iterator<TreeNode> parentOrganizationsIterator = getparentOrganizations();

      private Iterator<TreeNode> getparentOrganizations() {
        for (; idNodeIterator.hasNext();) {
          TreeNode targetPersonNode = idNodeIterator.next();
          TreeNode parentOrganizations = targetPersonNode.getChildren().at(pos).b();
          return parentOrganizations.getChildren().iterator();
        }
        return null;
      }

      @Override
      public boolean hasNext() {
        if (parentOrganizationsIterator == null)
          return false;
        if (parentOrganizationsIterator.hasNext())
          orgId = search();
        else
          orgId = null;
        if (orgId != null)
          return true;

        for (; parentOrganizationsIterator != null;) {
          parentOrganizationsIterator = getparentOrganizations();
          if (parentOrganizationsIterator != null)
            orgId = search();

          if (orgId != null)
            return true;
        }
        return false;
      }

      @Override
      public TreeNode next() {
        return orgId;
      }

      private TreeNode search() {
        for (; parentOrganizationsIterator.hasNext();) {
          TreeNode OrganizationMappedByRole = parentOrganizationsIterator.next();
          TreeNode organizationRefIdNode = OrganizationMappedByRole.getChildren().at(0).b();
          return organizationRefIdNode;
        }
        parentOrganizationsIterator = getparentOrganizations();

        return null;
      }

      private InterfaceTraverser getTraverser(String id) {
        Pattern rolePattern = Pattern.compile("p:");
        Matcher roleMacher = rolePattern.matcher(id);
        if (roleMacher.find()) {
          element = "Person";
          pos = 5;
          return personTree.getTraverser(useIndex);
        }

        Pattern rdePattern = Pattern.compile("o:");
        Matcher rdeMacher = rdePattern.matcher(id);
        if (rdeMacher.find()) {
          element = "Organization";
          pos = 4;
          return organizationTree.getTraverser(useIndex);
        }
        return null;
      }

    };
  }

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

    return new Iterator<String>() {
      Iterator<TreeNode> parentOrgnizationIdsIterator = parentOrganizationIdsNode(orgId);
      Stack<String> orgIdStack = new Stack<String>();

      String parentOrgId;

      @Override
      public boolean hasNext() {

        for (; parentOrgnizationIdsIterator.hasNext();) {
          TreeNode parentOrgIdNode = parentOrgnizationIdsIterator.next();
          parentOrgId = parentOrgIdNode.getAttributes().getString("text-organizationRefId");
          orgIdStack.push(parentOrgId);
          if (orgNodefilter(filterIds, parentOrgIdNode))
            return true;
        }
        if (orgIdStack.isEmpty())
          return false;

        parentOrgnizationIdsIterator = parentOrganizationIdsNode(orgIdStack.pop());
        return this.hasNext();
      }

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

    };
  }

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

    return new Iterator<String>() {
      Iterator<String> parentOrgIdIterator = deepParentOrganizationIds(id, filterIds);
      String parentOrgId = initOrgId();

      @Override
      public boolean hasNext() {
        return parentOrgId != null;
      }

      private String initOrgId() {
        if (filter(filterIds, id))
          return id;

        if (parentOrgIdIterator.hasNext())
          return parentOrgIdIterator.next();
        return null;
      }

      @Override
      public String next() {
        String str = parentOrgId;
        parentOrgId = null;
        if (parentOrgIdIterator.hasNext())
          parentOrgId = parentOrgIdIterator.next();
        return str;
      }

    };
  }

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

    Iterator<TreeNode> 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 "";

    TreeNode pathNameNode = PathNameIterator.next();
    ParentIndex parentIndex = traverser.getParentIndex();
    TreeNode pathNameIdNode = parentIndex.get(pathNameNode);
    String pathNameId = pathNameIdNode.getAttributes().getString(elementName + "-id");
    return pathNameId;
  }

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

    return new Iterator<String>() {
      Iterator<String> parentOrgIdIterator = deepParentOrganizationIdsPlus(id, filterIds);
      Iterator<String> rdeIdIterator = new NullIterator<String>();

      @Override
      public boolean hasNext() {

        if (rdeIdIterator.hasNext())
          return true;

        if (parentOrgIdIterator.hasNext()) {
          String orgId = parentOrgIdIterator.next();
          String roleId = getRole(orgId);
          rdeIdIterator = getRde(roleId);
        } else {
          return false;
        }

        return this.hasNext();
      }

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

  private Iterator<String> getRde(String roleId) {

    InterfaceTraverser traverser = roleTree.getTraverser(useIndex);

    return new Iterator<String>() {

      Iterator<TreeNode> roleIdNodeIterator = 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);
      String rdeId;
      Iterator<TreeNode> roleDescriptionElementRefIdIterator = new NullIterator<TreeNode>();

      @Override
      public boolean hasNext() {
        for (; roleIdNodeIterator.hasNext();) {

          if (roleDescriptionElementRefIdIterator.hasNext()) {
            rdeId = roleDescriptionElementRefIdIterator.next().getAttributes()
                .getString("text-roleDescriptionElementRefId");
            return true;
          }

          TreeNode roleId = roleIdNodeIterator.next();
          TreeNode roleDescriptionElementRefIds = roleId.getChildren().at(6).b();
          roleDescriptionElementRefIdIterator = roleDescriptionElementRefIds.getChildren().iterator();
          if (roleDescriptionElementRefIdIterator.hasNext()) {
            rdeId = roleDescriptionElementRefIdIterator.next().getAttributes()
                .getString("text-roleDescriptionElementRefId");
            return true;
          }

        }
        return false;
      }

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

  }

}