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

import java.util.Iterator;

import fj.Ord;
import fj.P2;
import fj.data.List;
import fj.data.Option;
import fj.data.TreeMap;
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.IndexCreater;
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;
  TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexList;
  ParentIndex parentIndex;
  boolean parentUpdateFlag;
  IndexManager indexManager;
  boolean useIndex;

  public InterfaceTraverser(TreeNode root, IndexManager indexManager, boolean indexFlag) {
    this(root, TreeMap.empty(Ord.stringOrd), new ParentIndex(), indexManager, indexFlag);
  }

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

  public TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> getIndex() {
    return indexList;
  }

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

  public ParentIndex getParentIndex() {
    return parentIndex;
  }

  public void setIndex(TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> index) {
    this.indexList = index;
  }

  public void createIndex() {
    // long t1 = System.currentTimeMillis();
    IndexCreater creater = new IndexCreater(node);
    // long t2 = System.currentTimeMillis();
    // System.out.println("createIndex time = " + (t2 - t1));
    indexList = creater.getIndex();
    parentIndex = creater.getParentIndex();
  }

  /**
   * 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を返す
  // */
  // Iterator<TreeNode> nodeIterator = index.get(key, searchValue);
  // if (nodeIterator.hasNext() && useIndex) {
  //
  // // ここでNode以下にあるか調べる
  // 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 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) {

    Iterator<TreeNode> nodeIterator = get(key, searchValue);
    if (nodeIterator != null && useIndex) {
      return nodeIterator;
    } 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() {
  // }
  //
  // };
  // }
  // }
  
  public Iterator<TreeNode> get(String key, String value) {

    Option<TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexOp = indexList.get(key);
    if (indexOp.isNone())
      return null;

    TreeMap<String, TreeMap<TreeNode, TreeNode>> index = indexOp.some();
    Option<TreeMap<TreeNode, TreeNode>> nodeMapOp = index.get(value);

    if (nodeMapOp.isNone())
      return new NulIterator<TreeNode>();

    Iterator<P2<TreeNode, TreeNode>> mapIterator = nodeMapOp.some().iterator();
    return new Iterator<TreeNode>() {

      @Override
      public boolean hasNext() {
        return mapIterator.hasNext();
      }

      @Override
      public TreeNode next() {
        return mapIterator.next()._1();
      }

    };
  }
}