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

import java.util.Iterator;

import fj.Ord;
import fj.data.List;
import fj.data.Option;
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.PathNodeIndexIterator;
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<Pair<TreeNode, NodePath>>>> index;
	JungleTreeEditor editor;

	public InterfaceTraverser(TreeNode _root, JungleTreeEditor editor) {
		this.node = _root;
		this.index = TreeMap.empty(Ord.stringOrd);
		this.editor = editor;
	}

	public InterfaceTraverser(
			TreeNode _root,
			TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index,
			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, String key, String searchValue) {
		
		if (!index.get(key).isNone()) {

			TreeMap<String, List<Pair<TreeNode, NodePath>>> innerIndex = this.index.get(key).some();
			Option<List<Pair<TreeNode, NodePath>>> opList = innerIndex.get(searchValue);

			if (opList.isNone())
				return null;

			final List<Pair<TreeNode, NodePath>> list = opList.some();
			return list.iterator();

		} else {
			
			final PathNodeIterator itNode = new PathNodeIterator(node);
			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();
						String value = pathNode.left().getAttributes().getString(key);
						Option<TreeMap<String, List<Pair<TreeNode, NodePath>>>> innerIndexOp = index.get(key);
						System.out.println("value = "+ value);

						if (value != null) {
							if (innerIndexOp.isNone()) {

								TreeMap<String, List<Pair<TreeNode, NodePath>>> innerIndex = TreeMap.empty(Ord.stringOrd);
								List<Pair<TreeNode, NodePath>> list = List.nil();
								list = list.cons(pathNode);
								innerIndex = innerIndex.set(value, list);
								index = index.set(key, innerIndex);

							} else {

								TreeMap<String, List<Pair<TreeNode, NodePath>>> innerIndex = innerIndexOp.some();
								innerIndex.set(value, null);
								Option<List<Pair<TreeNode, NodePath>>> opList = innerIndex.get(value);

								if (opList.isNone()) {

									List<Pair<TreeNode, NodePath>> list = List.nil();
									list = list.cons(pathNode);
									innerIndex = innerIndex.set(value, list);

								} else {

									List<Pair<TreeNode, NodePath>> list = opList.some();
									list = list.cons(pathNode);
									innerIndex = innerIndex.set(value, list);

								}
								index = index.set(key, innerIndex);

							}
						}

						if (query.condition(pathNode.left()))
							return pathNode;
					}
					return null;
				}

				@Override
				public boolean hasNext() {
					if (matchPair == null) {
//						index = itNode.getIndex();
						return false;
					}
					return true;
				}

				@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

				}

			};
		}
	}
}