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


import java.util.Iterator;

import fj.Ord;
import fj.P2;
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>>> index;
  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.index = 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 index;
  }

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

  public ParentIndex getParentIndex() {
    return parentIndex;
  }

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

  public void createIndex() {

    long t1 = System.currentTimeMillis();
    IndexCreater creater = new IndexCreater(node);
    long t2 = System.currentTimeMillis();
   // System.out.println("createIndex time = " + (t2 - t1));
    index = 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> get(String key, String value) {

  Option<TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexOp = index.get(key);
  if (indexOp.isNone())
    return new NulIterator<TreeNode>();

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

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

     Iterator<TreeNode> nodeIterator = get(key, searchValue);
    if (nodeIterator.hasNext() && 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() {
//        }
//
//      };
//    }
//  }
}