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

import java.util.Iterator;

import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.Children;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.NodeEditorError;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
import fj.data.List;

public class DefaultTraverser implements Traverser
{
	@Override
	public Either<Error,Traversal> traverse(final TreeNode _root,Evaluator _evaluator)
	{
		Children wrapper = new Children(){
			@Override
			public Iterator<TreeNode> iterator(){
				List<TreeNode> list = List.nil();
				return list.cons(_root).iterator();
			}
			@Override
			public int size(){
				return 1;
			}
			@Override
			public Either<Error,TreeNode> at(int _pos){
				if(_pos != 0){
					return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
				}
				return DefaultEither.newB(_root);
			}
		};
		
		//Children<T> chs = _root.getChildren();
		Children chs = wrapper;
		
		Either<Error,List<Direction<TreeNode>>> ret = _traverse(chs,_evaluator,-1);
		if(ret.isA()){
			return DefaultEither.newA(ret.a());
		}
		
		List<Direction<TreeNode>> list = ret.b();
		
		final Iterable<Direction<TreeNode>> iterable = list;
		final TreeNode destination = ret.b().last().getTarget();
		
		Traversal traversal = new Traversal(){
			@Override
			public Iterator<Direction<TreeNode>> iterator(){
				return iterable.iterator();
			}

			@Override
			public TreeNode destination(){
				return destination;
			}
		};
		
		return DefaultEither.newB(traversal);
	}
	
	private Either<Error,List<Direction<TreeNode>>> _traverse(Children _chs,Evaluator _evaluator,int _pos)
	{
		int pos = _pos;
		for(TreeNode ch : _chs){
			Evaluation e = _evaluator.evaluate(ch,pos);
			Result r = e.result();
			if(r == Result.ACCEPT){
				return _accept(ch,pos,e.evaluator());
			}
			
			if(r == Result.GOAL){
				return DefaultEither.newB(_goal(ch,pos));
			}
			
			if(r == Result.BREAK){
				break;
			}
			
			if(r == Result.CONTINUE){
				pos ++;
				continue;
			}
			
			return DefaultEither.newA(TraverserError.UNDEFINED_OPERATOR);
		}
		
		return DefaultEither.newA(TraverserError.PATH_NOT_FOUND);
	}
	
	private List<Direction<TreeNode>> _goal(final TreeNode _current,final int _pos)
	{
		Direction<TreeNode> d = new Direction<TreeNode>(){
			@Override
			public int getPosition()
			{
				return _pos;
			}
			@Override
			public TreeNode getTarget()
			{
				return _current;
			}
		};
		
		List<Direction<TreeNode>> list = List.nil();
		List<Direction<TreeNode>> newList = list.cons(d);
		
		return newList;
	}
	
	private <T extends TreeNode> Either<Error,List<Direction<TreeNode>>> _accept(final T _current,final int _pos,Evaluator _evaluator)
	{
		Children chs = _current.getChildren();
		Either<Error,List<Direction<TreeNode>>> either = _traverse(chs,_evaluator,0);
		if(either.isA()){
			return either;
		}
		
		List<Direction<TreeNode>> list = either.b();
		Direction<TreeNode> d = new Direction<TreeNode>(){
			@Override
			public int getPosition()
			{
				return _pos;
			}
			@Override
			public T getTarget()
			{
				return _current;
			}
		};
		
		List<Direction<TreeNode>> newList = list.cons(d);
		return DefaultEither.newB(newList);
	}
}