package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index;

import java.util.Iterator;

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.shoshi.jungle.util.TreeMapOrd;
import fj.Ord;
import fj.P2;
import fj.data.Option;
import fj.data.TreeMap;

public class Index {

  TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexList;

  public Index() {
   indexList = TreeMap.empty(Ord.stringOrd);    
  }

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

  public Index set(String key, String value, TreeNode node) {
    
    Option<TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexOp = indexList.get(key);
    if (indexOp.isNone()) {
      TreeMap<String, TreeMap<TreeNode, TreeNode>> index = TreeMap.empty(Ord.stringOrd);
      TreeMap<TreeNode, TreeNode> nodeMap = TreeMap.empty(TreeMapOrd.treeNodeOrd);
      nodeMap = nodeMap.set(node, node);
      TreeMap<String, TreeMap<TreeNode, TreeNode>> newIndex = index.set(value, nodeMap);
      indexList = indexList.set(key, newIndex);
      return this;
    }

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

    TreeMap<TreeNode, TreeNode> newNodeMap;
    if (nodeMapOp.isSome()) {
      TreeMap<TreeNode, TreeNode> nodeMap = nodeMapOp.some();
      newNodeMap = nodeMap.set(node, node);
    } else {
      TreeMap<TreeNode, TreeNode> nodeMap = TreeMap.empty(TreeMapOrd.treeNodeOrd);
      newNodeMap = nodeMap.set(node, node);
    }
    TreeMap<String, TreeMap<TreeNode, TreeNode>> newIndex = index.set(value, newNodeMap);
    indexList = indexList.set(key, newIndex);

    return this;
  }

  // public Index delete(String key, String value, TreeNode node) {
  // Option<TreeMap<String, List<TreeNode>>> indexOp = indexList.get(key);
  // if (indexOp.isNone())
  // return this;
  //
  // TreeMap<String, List<TreeNode>> index = indexOp.some();
  // TreeMap<String, List<TreeNode>> newIndex = index;
  // Option<List<TreeNode>> nodeListOp = index.get(value);
  // if (nodeListOp.isSome()) {
  // List<TreeNode> nodeList = nodeListOp.some();
  // List<TreeNode> newNodeList = List.nil();
  // for (TreeNode indexingNode : nodeList) {
  // if (indexingNode.equals(node))
  // newNodeList = newNodeList.cons(indexingNode);
  // }
  //
  // newIndex = index.set(value, newNodeList);
  // } else {
  // return this;
  // }
  // TreeMap<String, TreeMap<String, List<TreeNode>>> newIndexList =
  // indexList.set(key, newIndex);
  // return new Index(newIndexList);
  // }

  public Iterator<TreeNode> get(String key, String value) {

    Option<TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexOp = indexList.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> getAll(String key) {

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

    final TreeMap<String, TreeMap<TreeNode, TreeNode>> index = indexOp.some();
    if (!index.isEmpty())
      return new NulIterator<TreeNode>();

    return new Iterator<TreeNode>() {

      Iterator<P2<String, TreeMap<TreeNode, TreeNode>>> treeMapIterator = index.iterator();
      Iterator<P2<TreeNode, TreeNode>> nodeIterator = new NulIterator<P2<TreeNode, TreeNode>>();
      TreeNode node;

      @Override
      public boolean hasNext() {

        if (nodeIterator.hasNext()) {
          node = nodeIterator.next()._1();
          return true;
        }

        for (; treeMapIterator.hasNext();) {
          TreeMap<TreeNode, TreeNode> nodeMap = treeMapIterator.next()._2();
          nodeIterator = nodeMap.iterator();
          if (nodeIterator.hasNext()) {
            node = nodeIterator.next()._1();
            return true;
          }
        }
        return false;
      }

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

    };

  }

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

}