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

import jp.ac.u_ryukyu.ie.cr.jungle.DefaultJungle;
import jp.ac.u_ryukyu.ie.cr.jungle.Jungle;
import jp.ac.u_ryukyu.ie.cr.jungle.core.Attributes;
import jp.ac.u_ryukyu.ie.cr.jungle.query.traverser.nodeiterator.DefaultNodeIterator;
import jp.ac.u_ryukyu.ie.cr.jungle.store.nodepath.DefaultNodePath;
import jp.ac.u_ryukyu.ie.cr.jungle.store.nodepath.NodePath;
import jp.ac.u_ryukyu.ie.cr.jungle.store.nodepath.RedBlackTreeNodePath;
import jp.ac.u_ryukyu.ie.cr.jungle.transaction.editor.jungleTreeEditor.JungleTreeEditor;
import jp.ac.u_ryukyu.ie.cr.jungle.transaction.node.TreeNode;
import jp.ac.u_ryukyu.ie.cr.jungle.transaction.node.redBlackTree.ColorlessTreeNode;
import jp.ac.u_ryukyu.ie.cr.jungle.tree.JungleTree;
import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
import jp.ac.u_ryukyu.ie.cr.jungle.util.Error.Error;
import org.junit.Assert;
import org.junit.Test;

import java.nio.ByteBuffer;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class RedBlackTreeEditorNodeTest {

    int testCount = 10;

    @Test
    public void RedBlackTreeEditorNode() {
        String key = "balanceKey";
        Jungle jungle = new DefaultJungle(null, "hogehoge");
        JungleTree tree = jungle.createNewRedBlackTree("TreeName", "balanceKey");
        NodePath path = new DefaultNodePath();

        for (int count = 1; count <= testCount; count++) {
            JungleTreeEditor editor = tree.getJungleTreeEditor();
            ByteBuffer value = ByteBuffer.wrap(("value" + count).getBytes());
            Either<Error, JungleTreeEditor> either = editor.addNewChildAndPutAttribute(path, 0, key, value);
            Assert.assertFalse(either.isA());
            editor = either.b();
            either = editor.success();
            Assert.assertFalse(either.isA());

            TreeNode rootNode = tree.getRootNode();
            DefaultNodeIterator iterator = new DefaultNodeIterator(rootNode);
            int nodeCount = 0;
            List<String> list = new LinkedList<>();
            for (int i = 1; i <= count; i++) {
                list.add(("value" + i));
            }


            while (iterator.hasNext()) { //ちゃんとノードの追加ができているか、全てのノードが木にあるかをを調べる
                nodeCount++;
                TreeNode n = iterator.next();
                Attributes attribute = n.getAttributes();
                String str = attribute.getString(key);
                int index = list.indexOf(str);
                list.remove(index);
            }

            Assert.assertEquals(list.size(), 0);
            int expectCount = count;
            Assert.assertEquals(expectCount, nodeCount);

            ColorlessTreeNode rootNode2 = (ColorlessTreeNode) rootNode; //test用methodを使うためにcastしている
            rootNode2.checkDepth(0, 0); //赤黒木のバランスが取れているかを調べる
        }

        System.out.println("------------------------------------------- delete -----------------------------------------------------------------------------------");
        for (int count = 1; count <= testCount; count++) {
            JungleTreeEditor editor = tree.getJungleTreeEditor();
            ByteBuffer value = ByteBuffer.wrap(("value" + count).getBytes());
            NodePath redBlackTreeNodePath = new RedBlackTreeNodePath(key,value);
            Either<Error, JungleTreeEditor> either = editor.deleteChildAt(redBlackTreeNodePath, 0);
            Assert.assertFalse(either.isA());
            editor = either.b();
            either = editor.success();
            Assert.assertFalse(either.isA());

            ColorlessTreeNode rootNode = (ColorlessTreeNode) tree.getRootNode();
            Iterator<TreeNode> iterator = new DefaultNodeIterator(rootNode);
            int nodeCount = 0;

            while (iterator.hasNext() && rootNode.getAttributes().get(key) != null) { //削除時間違えて他のノードを消してないかを調べる
                ColorlessTreeNode node = (ColorlessTreeNode) iterator.next();
                ByteBuffer seach = node.getAttributes().get(key);
                Assert.assertTrue(rootNode.get(seach));
                nodeCount++;
            }

            int expectCount = testCount - count;
            Assert.assertEquals(expectCount, nodeCount);
        }


    }
}