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

import java.nio.ByteBuffer;

import org.junit.Assert;

import fj.data.List;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNode;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultEvaluator;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.Direction;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.Traversal;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.Traverser;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
import junit.framework.TestCase;

public abstract class TraverserTest extends TestCase
{
	public abstract Traverser instance();
	
	public void testTraverse()
	{
		int maxHeight = 3;
		TreeNode root = createTree(0,0,maxHeight,new DefaultNodePath());
		
		//TraversableNodeWrapper<DefaultTreeNode> traversable = new TraversableNodeWrapper<DefaultTreeNode>(root);
		Traverser traverser = instance();
	
		// generate all pattern.
		List<DefaultNodePath> paths = generatePathPattern(new DefaultNodePath(),0,maxHeight);
		paths = paths.cons(new DefaultNodePath());
		
		for(DefaultNodePath path : paths){
			DefaultEvaluator evaluator = new DefaultEvaluator(path);
			Either<Error,Traversal> ret = traverser.traverse(root,evaluator);
			if(ret.isA()){
				Assert.fail();
			}
			
			Traversal traversal = ret.b();
			TreeNode target = traversal.destination();
			String expect = path.toString();
			ByteBuffer value = target.getAttributes().get(key);
			String actual = new String(value.array());
			Assert.assertEquals(expect,actual);
			
			List<DefaultNodePath> parts = path.inits();
			
			for(Direction<TreeNode> d : traversal){
				DefaultNodePath part = parts.head();
				parts = parts.tail();
				value = d.getTarget().getAttributes().get(key);
				String actualCurrentPathStr = new String(value.array());
				String expectCurrentPathStr = part.toString();
				Assert.assertEquals(expectCurrentPathStr,actualCurrentPathStr);
			}
		}
	}
	
	public List<DefaultNodePath> generatePathPattern(DefaultNodePath _cur,int _curHeight,int _maxHeight)
	{
		List<DefaultNodePath> paths = List.nil();
		for(int p = 0;p <= _curHeight;p ++){
			DefaultNodePath path = _cur.add(p);
			if(_curHeight != _maxHeight - 1){
				List<DefaultNodePath> newpaths = generatePathPattern(path,_curHeight+1,_maxHeight);
				paths = paths.append(newpaths);
			}
			paths = paths.cons(path);
		}
		
		return paths;
	}
	
	public static String key = "KEY";
	public static ByteBuffer value = ByteBuffer.wrap(key.getBytes());
	public static DefaultTreeNode factory = new DefaultTreeNode();
	
	public TreeNode createTree(int _curX,int _curY,int _maxHeight,NodePath _address)
	{
		TreeNode parent = factory.createNewNode();
		Either<Error,TreeNode> either = parent.getAttributes().put(key,ByteBuffer.wrap(_address.toString().getBytes()));
		if(either.isA()){
			Assert.fail();
		}
		parent = either.b();
		
		if(_curY == _maxHeight){
			return parent;
		}
		
		for(int i = 0;i < _curY + 1;i ++){
			TreeNode ch = createTree(i,_curY + 1,_maxHeight,_address.add(i));
			either = parent.getChildren().addNewChildAt(i,ch);
			if(either.isA()){
				Assert.fail();
			}
			
			parent = either.b();
		}
		
		return parent;
	}
}