package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser;

import java.util.Iterator;

import fj.data.List;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NulIterator;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.query.PathNodeIterator;
import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.query.Query;
import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.Index;
import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.IndexManager;
import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;

public class InterfaceTraverser {

  TreeNode node;
  Index index;
  ParentIndex parentIndex;
  boolean parentUpdateFlag;
  IndexManager indexManager;
  boolean useIndex;

  public InterfaceTraverser(TreeNode root, IndexManager indexManager, boolean indexFlag) {
    this(root, new Index(), new ParentIndex(), indexManager, indexFlag);
  }

  public InterfaceTraverser(TreeNode root, Index index, ParentIndex parentIndex, IndexManager indexManager,
      boolean useIndex) {
    this.node = root;
    this.index = index;
    this.indexManager = indexManager;
    this.parentIndex = parentIndex;
    if (parentIndex.isEmpty())
      parentUpdateFlag = true;
    else
      parentUpdateFlag = false;
    this.useIndex = useIndex;
  }

  public Index getIndex() {
    return index;
  }

  public void commit() {
    parentUpdateFlag = false;
    indexManager.commit(index, parentIndex);
  }

  public ParentIndex getParentIndex() {
    return parentIndex;
  }

  public void setIndex(Index index) {
    this.index = index;
  }

  public void createIndex() {

    final PathNodeIterator itNode = new PathNodeIterator(node);
    for (; itNode.hasNext();) {
      TreeNode targetNode = itNode.next();
      if (parentUpdateFlag)
        parentIndex = parentIndex.set(targetNode);
      List<String> keys = targetNode.getAttributes().getKeys();
      for (String key : keys) {
        String value = targetNode.getAttributes().getString(key);
        if (value != null)
          index = index.set(key, value, targetNode);
      }
    }
  }

  /**
   * subTree以下のNodeに対してKey,Valueのペアでindexを使って探索を行う
   * 
   * @param query
   * @param subTree
   * @param key
   * @param searchValue
   * @return
   */
  public Iterator<TreeNode> findInSubTree(final Query query, TreeNode subTree, String key, String searchValue) {
    /*
     * indexを使って取ってきたNodeのPathと、subTreeのPathを先頭から１つずつ比較し、
     * indexから取ってきたNodeのPathが一致した場合、そのNodeを返す
     */
    List<TreeNode> nodeList = index.get(key, searchValue);
    if (nodeList != null && useIndex) {

      if (nodeList.isEmpty())
        return new NulIterator<TreeNode>();// 空のIteratorを返す

      // ここでNode以下にあるか調べる
      List<TreeNode> filteredList = List.nil();

      for (TreeNode targetNode : nodeList) {
        TreeNode parent = targetNode;
        while (parent != null) {
          parent = parentIndex.get(parent);
          if (parent.equals(subTree))
            filteredList = filteredList.cons(targetNode);
        }
      }

      return filteredList.iterator();

    } else {
      final PathNodeIterator itNode = new PathNodeIterator(subTree);
      return new Iterator<TreeNode>() {

        private TreeNode matchNode = nextmatch(itNode);

        private TreeNode nextmatch(PathNodeIterator itNode) {

          for (; itNode.hasNext();) {
            TreeNode targetNode = itNode.next();
            if (query.condition(targetNode))
              return targetNode;
          }
          return null;
        }

        @Override
        public boolean hasNext() {
          if (matchNode == null) {
            return false;
          }
          return true;
        }

        @Override
        public TreeNode next() {
          TreeNode currentNode = matchNode;
          matchNode = nextmatch(itNode);
          return currentNode;
        }

        @Override
        public void remove() {
        }

      };
    }
  }

  /**
   * subTree以下のNodeに対してKeyに対応する値をindexを使って探索する
   * 
   * @param query
   * @param subTree
   * @param key
   * @param searchValue
   * @return
   */
  public Iterator<TreeNode> findInSubTreeAllValue(final Query query, TreeNode subTree, String key) {
    /*
     * indexからinnerIndexを取得 取得したinnerIndexが保有するKeyを取得
     * そのKeyを保有するNodeとNodeのPathを取得する
     * indexを使って取ってきたNodeのPathと、subTreeのPathを先頭から１つずつ比較し、
     * indexから取ってきたNodeのPathが一致した場合、そのNodeを返す
     */
    Iterator<TreeNode> NodeIterator = index.getAll(key);
    if (NodeIterator != null && useIndex) {
      List<TreeNode> filteredList = List.nil();
      for (; NodeIterator.hasNext();) {
        TreeNode targetNode = NodeIterator.next();
        TreeNode parent = targetNode;
        while (parent != null) {
          parent = parentIndex.get(parent);
          if (parent.equals(subTree))
            filteredList = filteredList.cons(targetNode);
        }
      }
      return filteredList.iterator();

    } else {

      final PathNodeIterator itNode = new PathNodeIterator(subTree);
      return new Iterator<TreeNode>() {

        private TreeNode matchPair = nextmatch(itNode);

        private TreeNode nextmatch(PathNodeIterator itNode) {

          for (; itNode.hasNext();) {
            TreeNode targetNode = itNode.next();
            if (query.condition(targetNode))
              return targetNode;
          }
          return null;
        }

        @Override
        public boolean hasNext() {
          if (matchPair == null) {
            return false;
          }
          return true;
        }

        @Override
        public TreeNode next() {
          TreeNode currentNode = matchPair;
          matchPair = nextmatch(itNode);
          return currentNode;
        }

        @Override
        public void remove() {
        }

      };
    }
  }

  public Iterator<TreeNode> find(final Query query, final String key, String searchValue) {

    List<TreeNode> nodeList = index.get(key, searchValue);
    if (nodeList != null && useIndex) {
      return nodeList.iterator();
    } else {

      final PathNodeIterator itNode = new PathNodeIterator(node);
      return new Iterator<TreeNode>() {

        private TreeNode matchNode = nextmatch(itNode);

        private TreeNode nextmatch(PathNodeIterator itNode) {

          for (; itNode.hasNext();) {
            TreeNode targetNode = itNode.next();
            String value = targetNode.getAttributes().getString(key);
            if (useIndex) {
              if (value != null)
                index = index.set(key, value, targetNode);
            }
            if (parentUpdateFlag)
              parentIndex = parentIndex.set(targetNode);
            if (query.condition(targetNode))
              return targetNode;
          }
          if (useIndex || parentUpdateFlag)
            commit();
          return null;
        }

        @Override
        public boolean hasNext() {
          if (matchNode == null) {
            return false;
          }
          return true;
        }

        @Override
        public TreeNode next() {
          TreeNode currentPair = matchNode;
          matchNode = nextmatch(itNode);
          return currentPair;
        }

        @Override
        public void remove() {
        }

      };
    }
  }

  public Iterator<TreeNode> findAll(final Query query, final String key) {

    Iterator<TreeNode> nodeList = index.getAll(key);
    if (nodeList != null && useIndex) {

      return nodeList;

    } else {

      final PathNodeIterator itNode = new PathNodeIterator(node);
      return new Iterator<TreeNode>() {

        private TreeNode matchNode = nextmatch(itNode);

        private TreeNode nextmatch(PathNodeIterator itNode) {

          for (; itNode.hasNext();) {
            TreeNode targetNode = itNode.next();
            String value = targetNode.getAttributes().getString(key);
            if (useIndex) {
              if (value != null)
                index = index.set(key, value, targetNode);
            }
            if (parentUpdateFlag)
              parentIndex = parentIndex.set(targetNode);
            if (query.condition(targetNode))
              return targetNode;
          }
          if (useIndex || parentUpdateFlag)
            commit();
          return null;
        }

        @Override
        public boolean hasNext() {
          if (matchNode == null) {
            return false;
          }
          return true;
        }

        @Override
        public TreeNode next() {
          TreeNode currentPair = matchNode;
          matchNode = nextmatch(itNode);
          return currentPair;
        }

        @Override
        public void remove() {
        }

      };
    }
  }
}