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

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.persistent.NullJournal;
import jp.ac.u_ryukyu.ie.cr.jungle.query.traverser.InterfaceTraverser;
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.transaction.editor.jungleTreeEditor.JungleTreeEditor;
import jp.ac.u_ryukyu.ie.cr.jungle.transaction.node.TreeNode;
import jp.ac.u_ryukyu.ie.cr.jungle.tree.DifferenceListJungleTree;
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.jungleError.Error;
import org.junit.Assert;
import org.junit.Test;

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

/**
 * Created by e115731 on 2017/01/07.
 */
public class DifferentialInterfaceTraverserTest {

    //3種類の木のTraverseについて調べる
    @Test
    public void DifferentialInterfaceTraverserTests1() {
        String key = "key";
        String indexKey = "indexKey";
        Jungle jungle = new DefaultJungle(new NullJournal(), "hoge");

        List<Integer> list = Arrays.asList(0,1,2);
        test(key,indexKey,jungle,list,2);

                /*

                    root
                      |
                      ○
                      |
                   -------
                   |  |  |
                   ○  ○  ●
                         |
                        ○
                         |
                      -------
                      |  |  |
                      ○  ○  ○
                     上記の形の木ができる
                     ●はrevision1の木のEndNode
                     revision1の木の探索において、ここでInterfaceTraverserの探索が止まるかを調べる
         */

        list = Arrays.asList(0,1,0);
        test(key,indexKey,jungle,list,0);

                /*

                    root
                      |
                      ○
                      |
                   -------
                   |  |  |
                  ●  ○   ○
                   |
                  ○
                   |
                -------
                |  |  |
                ○  ○  ○
                     上記の形の木ができる
                     ●はrevision1の木のEndNode
                     revision1の木の探索において、ここでInterfaceTraverserの探索が止まるかを調べる
         */

        list = Arrays.asList(0,0,1);
        test(key,indexKey,jungle,list,1);

                /*

                    root
                      |
                      ○
                      |
                   -------
                   |  |  |
                  ○  ●  ○
                      |
                     ○
                      |
                   -------
                   |  |  |
                   ○  ○  ○
                     上記の形の木ができる
                     ●はrevision1の木のEndNode
                     revision1の木の探索において、ここでInterfaceTraverserの探索が止まるかを調べる
         */
       // test2Left(key, indexKey, jungle);
    }

    private void test(String key, String indexKey, Jungle jungle,List<Integer> nodeInsertOrder, int endNodePosition) {
        jungle.createNewDifferenceTree("TestTree" + endNodePosition);
        JungleTree tree = jungle.getTreeByName("TestTree" + endNodePosition);
        JungleTreeEditor editor = tree.getJungleTreeEditor();
        NodePath path = new DefaultNodePath();
        for (int position : nodeInsertOrder) {
            editor = addNode(key, indexKey, editor, path, position);
        }
        Either<Error, JungleTreeEditor> either = editor.success();
        if (either.isA())
            junit.framework.Assert.fail();

        editor = tree.getJungleTreeEditor();
        for (int position : nodeInsertOrder) {
            editor = addNode(key, indexKey, editor, path, position);
        }
        either = editor.success();
        if (either.isA())
            junit.framework.Assert.fail();



        DifferenceListJungleTree oldTree = (DifferenceListJungleTree)tree.getOldTree(1).b(); //1つ前の木を取得する
        TreeNode endNode = oldTree.getEndNode();
        TreeNode oldRoot = oldTree.getRootNode();
        TreeNode child = oldRoot.getChildren().at(0).b().getChildren().at(endNodePosition).b(); //黒丸の位置のノードを取得している
        Assert.assertEquals(endNode,child); //指定した場所がちゃんとendノードになっているかを調べている
        InterfaceTraverser traverser = oldTree.getTraverser(false); //Indexを使ってはいけない。Indexには過去の木が入っているためである
        Iterator<TreeNode> iterator = traverser.find((TreeNode node) -> {
            return true; //返ってくるノードの数を調べたいのでここはreturn trueで良い;
        });

        int nodeCount = 0;
        while (iterator.hasNext()) {
            iterator.next();
            nodeCount++;
        }
        int expectCount = 5; //前の木のノード数
        Assert.assertEquals(expectCount, nodeCount);
    }


    private JungleTreeEditor addNode(String key, String indexKey, JungleTreeEditor editor, NodePath path, int i) {
        Either<Error, JungleTreeEditor> either = editor.addNewChildAt(path, i);
        if (either.isA())
            junit.framework.Assert.fail();
        editor = either.b();
        String value = path.add(i).toString();
        either = editor.putAttribute(path.add(i), key, ByteBuffer.wrap(value.getBytes()));
        if (either.isA())
            junit.framework.Assert.fail();
        editor = either.b();
        either = editor.putAttribute(path.add(i), indexKey, ByteBuffer.wrap(value.getBytes()));
        if (either.isA())
            junit.framework.Assert.fail();
        editor = either.b();
        return editor;
    }

}