package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.impl.treeeditor;

import java.nio.ByteBuffer;

import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNode;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNodePath;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultTreeEditor;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TraversableNodeWrapper;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.AppendChildAt;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.tests.util.TestUtil;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.ClonableDefaultNode;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultEvaluator;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.Traversal;
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.Assert;
import junit.framework.TestCase;

public class DefaultTreeEditorTest extends TestCase
{
	public DefaultTreeEditor<ClonableDefaultNode> instance()
	{
		DefaultTraverser traverser = new DefaultTraverser();
		ClonableDefaultNode root = new ClonableDefaultNode(new DefaultNode());
		return new DefaultTreeEditor<ClonableDefaultNode>(root,traverser);
	}
	
	public void testEdittingDoesNotEffectToOtherTree()
	{
		ClonableDefaultNode root = TestUtil.createMockTree(3);
		DefaultTreeEditor<ClonableDefaultNode> editor = new DefaultTreeEditor<ClonableDefaultNode>(root,new DefaultTraverser());
		DefaultNodePath path = new DefaultNodePath().add(0).add(2);
		
		ClonableDefaultNode oldRoot = editor.getRootNode();
		
		DefaultTreeEditor<ClonableDefaultNode> currentEditor = editor;
		String key = "path";
		
		for(DefaultNodePath part : path.inits()){
			ByteBuffer value = ByteBuffer.wrap(part.toString().getBytes());
			Either<Error, DefaultTreeEditor<ClonableDefaultNode>> either = currentEditor.putAttribute(part,key,value);
			if(either.isA()){
				Assert.fail();
			}
			currentEditor = either.b();
		}
		
		ClonableDefaultNode newRoot = currentEditor.getRootNode();
		
		DefaultTraverser traverser = new DefaultTraverser();
		for(DefaultNodePath part : path.inits()){
			Either<Error,Traversal<TraversableNodeWrapper<ClonableDefaultNode>>> either = traverser.traverse(new TraversableNodeWrapper<ClonableDefaultNode>(newRoot),new DefaultEvaluator(part));
			if(either.isA()){
				Assert.fail();
			}
			ClonableDefaultNode target = either.b().destination().getWrapped();
			String expected = part.toString();
			String actual = new String(target.getAttributes().get(key).array());
			
			Assert.assertEquals(expected,actual);
		}
		
		for(DefaultNodePath part : path.inits()){
			Either<Error,Traversal<TraversableNodeWrapper<ClonableDefaultNode>>> either = traverser.traverse(new TraversableNodeWrapper<ClonableDefaultNode>(oldRoot),new DefaultEvaluator(part));
			if(either.isA()){
				Assert.fail();
			}
			ClonableDefaultNode target = either.b().destination().getWrapped();
			ByteBuffer actual = target.getAttributes().get(key);
			
			Assert.assertNull(actual);
		}
		
	}
	
	public void testAppendChild()
	{
		DefaultTreeEditor<ClonableDefaultNode> instance = instance();
		DefaultNodePath path = new DefaultNodePath(); // root
		
		Either<Error, DefaultTreeEditor<ClonableDefaultNode>> either = instance.appendChild(path,0);
		if(either.isA()){
			Assert.fail();
		}
		instance = either.b();
		
		ClonableDefaultNode node = instance.getRootNode();
		Assert.assertEquals(1,node.getChildren().size());
	}
	
	public void testDeleteChild()
	{
		DefaultTreeEditor<ClonableDefaultNode> instance = instance();
		DefaultNodePath path = new DefaultNodePath();
		
		Either<Error,DefaultTreeEditor<ClonableDefaultNode>> either = instance.appendChild(path,0);
		if(either.isA()){
			Assert.fail();
		}
		instance = either.b();
		ClonableDefaultNode node = instance.getRootNode();
		Assert.assertEquals(1,node.getChildren().size());
		
		either = instance.deleteChild(path,0);
		if(either.isA()){
			Assert.fail();
		}
		instance = either.b();
		node = instance.getRootNode();
		Assert.assertEquals(0,node.getChildren().size());
	}
	
	public DefaultTreeEditor<ClonableDefaultNode> testPutAttribute()
	{
		DefaultTreeEditor<ClonableDefaultNode> instance = instance();
		DefaultNodePath path = new DefaultNodePath();
		
		ClonableDefaultNode old = instance.getRootNode();
		
		String key = "KEY";
		ByteBuffer value = ByteBuffer.wrap(key.getBytes());
		
		Either<Error,DefaultTreeEditor<ClonableDefaultNode>> either = instance.putAttribute(path,key,value);
		if(either.isA()){
			Assert.fail();
		}
		instance = either.b();
		
		ClonableDefaultNode root = instance.getRootNode();
		ByteBuffer actual = root.getAttributes().get(key);
		
		Assert.assertEquals(0,actual.compareTo(value));
		
		return instance;
	}
	
	public void testDeleteAttribute()
	{
		DefaultTreeEditor<ClonableDefaultNode> instance = testPutAttribute();
		DefaultNodePath path = new DefaultNodePath();
		
		String key = "KEY";
		
		Either<Error, DefaultTreeEditor<ClonableDefaultNode>> either = instance.deleteAttribute(path, key);
		if(either.isA()){
			Assert.fail();
		}
		instance = either.b();
		
		ByteBuffer actual = instance.getRootNode().getAttributes().get(key);
		Assert.assertNull(actual);
	}
	
	public void testEdit()
	{
		DefaultTreeEditor<ClonableDefaultNode> instance = instance();
		DefaultNodePath path = new DefaultNodePath();
		
		Either<Error, DefaultTreeEditor<ClonableDefaultNode>> either = instance.edit(path,new AppendChildAt(0));
		if(either.isA()){
			Assert.fail();
		}
		instance = either.b();
		
		ClonableDefaultNode node = instance.getRootNode();
		Assert.assertEquals(1,node.getChildren().size());
	}
}