package jp.ac.u_ryukyu.ie.cr.tatsuki.query;

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

import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.DefaultJungle;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.Jungle;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
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.TreeNode;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeNode;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.InterfaceTraverser;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;

import org.junit.Assert;
import org.junit.Test;

import fj.data.List;
import fj.data.Option;
import fj.data.TreeMap;

public class SearchQueryTest {

  @Test
	public void SearchQueryTest() {
		Jungle jungle = new DefaultJungle(null, "hogehoge",new DefaultTreeEditor(new DefaultTraverser()));
		jungle.createNewTree("tree");
		JungleTree tree = jungle.getTreeByName("tree");
		createTree(tree);
		tree.getRootNode();
		InterfaceTraverser ifTraverser = tree.getTraverser();
		TreeMap<String, TreeMap<String, List< NodePath>>> cheackIndex = ifTraverser.getIndex();
		Assert.assertTrue(cheackIndex.isEmpty());
		
		Iterator<Pair<TreeNode, NodePath>> searchNode = ifTraverser.find(
		        (TreeNode node) -> {
		            List<ByteBuffer> attributeList = node.getAttributes().get(key);
		            if(attributeList.isNotEmpty()){
		              for (ByteBuffer attribute : attributeList) {
		                byte[] byteAttribute = attribute.array();
		                String str = new String(byteAttribute);
		                System.out.println("attribute = " + str);
		                if (str.equals("<-1,0,1>"))
		                  return true;
		                continue;
		              }
		            }
		            return false;
		        }
		        ,key,"<-1,0,1>");
		
		
		while (searchNode.hasNext()){
		  TreeNode node = searchNode.next().left();
			Assert.assertTrue(compare(node,"<-1,0,1>"));			
		}
				
		TreeMap<String, TreeMap<String, List<NodePath>>> index = ifTraverser.getIndex();
		Option<TreeMap<String, List<NodePath>>> opIndex = index.get(key);
		Assert.assertTrue(!opIndex.isNone());
		TreeMap<String, List<NodePath>> innerIndex = opIndex.some();
		Assert.assertTrue(!innerIndex.get("<-1,0,0>").isNone());
	}

  public boolean compare(TreeNode compareNode, String compareAttribute) {
     Iterator<String> labNameIterator = compareNode.getAttributes().getString(key);
     Assert.assertTrue(labNameIterator.hasNext());
     String labName = labNameIterator.next(); 
    if (labName.equals(compareAttribute))
      return true;
    return false;
  }

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

  public void createTree(JungleTree tree) {
    NodePath root = new DefaultNodePath();
    createChildren(tree, root, 0);

    for (int x = 0; x < 2; x++) {
      createChildren(tree, root.add(0), x);
      for (int y = 0; y < 2; y++) {
        createChildren(tree, root.add(0).add(x), y);
      }
    }

  }

  public void createChildren(JungleTree tree, NodePath root, int num) {
    JungleTreeEditor editor = tree.getTreeEditor();// Treeのeditorを作成
    Either<Error, JungleTreeEditor> either = editor.addNewChildAt(root, num); // 新しく入れるところへのパス
    if (either.isA()) {
      Assert.fail();
    }
    editor = either.b();
    either = editor.success();
    if (either.isA()) {
      Assert.fail();
    }
    NodePath childPath = root.add(num);
    editor = tree.getTreeEditor();
    NodePath attribute = root.add(num);
    System.out.println(attribute.toString());
    either = editor.putAttribute(childPath, key, ByteBuffer.wrap(attribute.toString().getBytes()));
    if (either.isA()) {
      Assert.fail();
    }
    editor = either.b();
    either = editor.success();
  }
}