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.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,TreeNode> nodeIndex;
	TreeMap<String,String> attributeIndex;	
	
	public InterfaceTraverser(TreeNode _root) {
		node = _root;
		//pathNodes = this.traverse(_root,new DefaultNodePath(),-1);
	}
	
	public InterfaceTraverser getTraverser(JungleTree tree) {
		return new InterfaceTraverser(tree.getRootNode());
	}
	

	/*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 Iterator<Pair<TreeNode, NodePath>> find(final Query query) {
		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();
                    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
                
            }

		};

	}
	

}