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

import java.util.Iterator;

import fj.data.List;
import fj.data.TreeMap;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;
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.query.SearchQuery;
import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.query.UpdateQuery;

public class InterfaceTraverser {
	InterfaceTraverser traverser;

	TreeNode node;
	TreeMap<String,TreeMap<String, List<TreeNode>>> index;
	JungleTreeEditor editor;

	public InterfaceTraverser(TreeNode _root, TreeMap<String,TreeMap<String, List<TreeNode>>> indez, JungleTreeEditor editor) {
		this.node = _root;
		this.index = index;
		this.editor = editor;
	}


	public InterfaceTraverser getTraverser(JungleTree tree) {
		return new InterfaceTraverser(tree.getRootNode(), tree.getIndex(), tree.getTreeEditor());
	}

	public void set(TreeNode root){
		this.node = root;
	}
	/*
	 * public IteratorPathNode traverse(TreeNode _node ,NodePath _path ,int
	 * _pos){
	 * 
	 * Children children = _node.getChildren(); Either<Error,TreeNode> either =
	 * children.at(0); IteratorPathNode list = new IteratorPathNodeImpl(); int
	 * pathCount = _pos; if(children.size() == 0){ list = list.add(new
	 * Pair<TreeNode, NodePath>(node, _path.add(_pos))); return list; }
	 * 
	 * for(TreeNode child : children){ list =
	 * list.append(traverse(child,_path,pathCount)); pathCount++; }
	 * 
	 * list = list.add(new Pair<TreeNode,NodePath>(_node, _path.add(_pos)));
	 * return list; }
	 * 
	 * public int count(Query _query, String _key, String _attribute){ return
	 * this.find(_query,_key,_attribute); }
	 * 
	 * public List<Pair<NodePath,TreeNode>> distinct(String _key ,String...
	 * _attribute){ return null; }
	 */
	
	public JungleTreeEditor update(final Query query) {
		/*Iterator<Pair<TreeNode, NodePath>> findNode = find(query);
		//do {
			for (; findNode.hasNext();) {
				Either<Error, JungleTreeEditor> either = editor.putAttribute(findNode.next().right(), "KEY", query.getUpdateAttribute());
				if (either.isA())
					;// wait delay write
				editor = either.b();
			}
		//} while (editor.success().isA());
*/
		return editor;
	}

	public Iterator<Pair<TreeNode, NodePath>> find(final Query query) {
		final PathNodeIterator itNode = new PathNodeIterator(node, query);
		
		return new Iterator<Pair<TreeNode, NodePath>>() {

			private Pair<TreeNode, NodePath> matchPair = nextmatch(itNode);

			private Pair<TreeNode, NodePath> nextmatch(PathNodeIterator itNode) {
				for (; itNode.hasNext();) {
					Pair<TreeNode, NodePath> pathNode = itNode.next();
					if (query.condition(pathNode.left()))
						return pathNode;
				}
				return null;
			}

			@Override
			public boolean hasNext() {
				return matchPair != null;
			}

			@Override
			public Pair<TreeNode, NodePath> next() {
				Pair<TreeNode, NodePath> currentPair = matchPair;
				matchPair = nextmatch(itNode);
				return currentPair;
			}

			@Override
			public void remove() {
				// TODO Auto-generated method stub

			}

		};

	}

}