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

import java.util.Stack;

import fj.Ord;
import fj.data.List;
import fj.data.Option;
import fj.data.TreeMap;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNodeChildren;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.TreeMapOrd;

public class IndexCreater {

  TreeNode root;
  TreeNode node;
  int childNumber;
  private TreeNodeChildren children;
  private Stack<TreeNode> nodeStack = new Stack<TreeNode>();
  private Stack<Integer> searchStack = new Stack<Integer>();
  ParentIndex parentIndex = new ParentIndex();
  TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> indexList = TreeMap.empty(Ord.stringOrd);

  public IndexCreater(TreeNode rootNode) {
    this.root = rootNode;
    this.node = rootNode;
    while (node != null) {
      TreeNode targetNode = node;
      List<String> keys = targetNode.getAttributes().getKeys();
      for (String key : keys) {
        String value = targetNode.getAttributes().getString(key);
        if (value != null)
          indexList = set(key, value, targetNode);
      }
      if (node.getChildren().size() > 0) {
        nodeStack.push(node);
        TreeNode parent = node;
        children = node.getChildren();
        node = children.at(0).b();
        parentIndex.set(parent, node);
        childNumber = 1;
        searchStack.push(childNumber);
      } else if (node == root) {
        node = null; // no more node
        children = null;
        return;
      } else if (children != null && children.size() > childNumber) {
        childNumber = searchStack.pop();
        TreeNode parent = nodeStack.pop();
        nodeStack.push(parent);
        node = children.at(childNumber).b();
        parentIndex.set(parent, node);
        searchStack.push(++childNumber);
      } else {
        node = nodeStack.pop();
        children = node.getChildren();
        childNumber = searchStack.pop();
        for (; children.size() == childNumber;) {
          if (node == root) {
            node = null; // no more node
            children = null;
            return;
          }
          node = nodeStack.pop();
          children = node.getChildren();
          childNumber = searchStack.pop();
        }
        if (node != null && childNumber < children.size()) {
          nodeStack.push(node);
          TreeNode parent = node;
          node = children.at(childNumber).b();
          parentIndex.set(parent, node);
          searchStack.push(++childNumber);
        }
      }
    }
  }

  public TreeMap<String, TreeMap<String, TreeMap<TreeNode, TreeNode>>> 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 indexList;
    }

    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 indexList;
  }

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

  public ParentIndex getParentIndex() {
    return parentIndex;
  }
}