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

import java.util.Iterator;

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<T extends TraversableNode<T>> implements Traverser<T>
{
	@Override
	public Either<Error,Traversal<T>> traverse(final T _root,Evaluator<T> _evaluator)
	{
		TraversableChildren<T> wrapper = new TraversableChildren<T>(){
			@Override
			public Iterator<T> iterator(){
				List<T> list = List.nil();
				return list.cons(_root).iterator();
			}
			@Override
			public int size(){
				return 1;
			}
		};
		
		Either<Error,List<Direction<T>>> ret = _traverse(wrapper,_evaluator);
		if(ret.isA()){
			return DefaultEither.newA(ret.a());
		}
		
		final Iterable<Direction<T>> iterable = ret.b();
		final T destination = ret.b().last().getTarget();
		
		Traversal<T> traversal = new Traversal<T>(){
			@Override
			public Iterator<Direction<T>> iterator(){
				return iterable.iterator();
			}

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