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.Pair;
import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.query.PathNodeIterator;
import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.query.Query;

public class InterfaceTraverser {

	InterfaceTraverser traverser;
	TreeNode node;
	TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index;
	public TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> getIndex() {
		return index;
	}

	public void setIndex(
			TreeMap<String, TreeMap<String, List<Pair<TreeNode, NodePath>>>> index) {
		this.index = 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 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

				}

			};
		}
	}
}