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

import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultNodePath;
import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.DefaultTreeEditor;
import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.logger.LoggingNode;
import jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer.AppendChildAt;
import jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer.PutAttribute;
import jp.ac.u_ryukyu.ie.cr.jungle.tests.util.TestUtil;
import jp.ac.u_ryukyu.ie.cr.jungle.transaction.DefaultTreeNode;
import jp.ac.u_ryukyu.ie.cr.jungle.traverser.DefaultEvaluator;
import jp.ac.u_ryukyu.ie.cr.jungle.traverser.DefaultTraverser;
import jp.ac.u_ryukyu.ie.cr.jungle.traverser.Traversal;
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 DefaultTreeEditorTest extends TestCase {
    public DefaultTreeEditor instance() {
        DefaultTraverser traverser = new DefaultTraverser();
        return new DefaultTreeEditor(traverser);
    }

    public void testEdittingDoesNotEffectToOtherTree() {
        TreeNode root = TestUtil.createMockTree(3);
        DefaultTreeEditor editor = new DefaultTreeEditor(new DefaultTraverser());
        DefaultNodePath path = new DefaultNodePath().add(0).add(2);

        TreeNode oldRoot = root;

        DefaultTreeEditor currentEditor = editor;
        String key = "path";


        TreeNode currentRoot = root;
        for (DefaultNodePath part : path.inits()) {
            String str = part.toString();
            ByteBuffer value = ByteBuffer.wrap(str.getBytes());
            PutAttribute putAttribute = new PutAttribute(key, value);
            Either<Error, LoggingNode> either = currentEditor.edit(currentRoot, part, putAttribute);
            if (either.isA()) {
                Assert.fail();
            }
            currentRoot = either.b().getWrap();
        }

        TreeNode newRoot = currentRoot;
        DefaultTraverser traverser = new DefaultTraverser();

        for (DefaultNodePath part : path.inits()) {
            Either<Error, Traversal> either = traverser.traverse(newRoot, new DefaultEvaluator(part));
            if (either.isA()) {
                Assert.fail();
            }
            TreeNode target = either.b().destination();
            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> either = traverser.traverse(oldRoot, new DefaultEvaluator(part));
            if (either.isA()) {
                Assert.fail();
            }
            TreeNode target = either.b().destination();
            ByteBuffer actual = target.getAttributes().get(key);

            Assert.assertNull(actual);
        }

    }

    public void testEdit() {
        DefaultTreeEditor instance = instance();
        DefaultTreeNode node = new DefaultTreeNode();
        DefaultNodePath path = new DefaultNodePath();

        Either<Error, LoggingNode> either = instance.edit(node, path, new AppendChildAt(0));
        if (either.isA()) {
            Assert.fail();
        }
        TreeNode newRoot = either.b().getWrap();
        Assert.assertEquals(1, newRoot.getChildren().size());
    }
}