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


import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
import jp.ac.u_ryukyu.ie.cr.jungle.store.NodePath;
import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultNodePath;
import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
import jp.ac.u_ryukyu.ie.cr.jungle.transaction.DefaultTreeNode;
import jp.ac.u_ryukyu.ie.cr.jungle.traverser.*;
import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
import junit.framework.Assert;
import junit.framework.TestCase;

import java.nio.ByteBuffer;

public class TraverserTest extends TestCase
{

	public void testTraverse()
	{
		int maxHeight = 3;

		TreeNode root = createTree(0,maxHeight,new DefaultNodePath());
		Traverser traverser = new DefaultTraverser();

		List<DefaultNodePath> paths = generatePathPattern(new DefaultNodePath(),0,maxHeight);
		paths = paths.addLast(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.tail();
				parts = parts.delete(parts.length() - 1);
				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 = new List();
		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.addLast(path);
		}

		return paths;
	}

	public static String key = "KEY";
	public static DefaultTreeNode factory = new DefaultTreeNode();

	public TreeNode createTree(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(_curY + 1,_maxHeight,_address.add(i));
			either = parent.getChildren().addNewChildAt(i,ch);
			if(either.isA()){
				Assert.fail();
			}

			parent = either.b();
		}

		return parent;
	}
}