package jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index;

import java.nio.ByteBuffer;

import fj.Ord;
import fj.data.List;
import fj.data.Option;
import fj.data.TreeMap;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingAttributes;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.LoggingNode;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.logger.OperationLog;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DeleteAttributeOperation;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.PutAttributeOperation;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.DefaultEither;
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;

public class LoggingIndexAttributes extends LoggingAttributes {

	private final TreeNode wrap;
	private final OperationLog log;
	private TreeMap<String,TreeMap<String, List<TreeNode>>> index;
	
	public LoggingIndexAttributes(TreeNode _wrap, OperationLog _log, TreeMap<String,TreeMap<String, List<TreeNode>>> index) {
		super(_wrap, _log);
		this.wrap = _wrap;
		this.log = _log;
		this.index = index;
	}

	private Either<Error,Logging> edit(NodeOperation _op)
	{
		Either<Error,TreeNode> either = _op.invoke(wrap);
		if(either.isA()){
			return DefaultEither.newA(either.a());
		}
		
		TreeNode newNode = either.b();
		OperationLog newLog = log.add(_op);
		Logging newLogNode = new LoggingNode(newNode,newLog);
		
		return DefaultEither.newB(newLogNode);
	}

	public Either<Error,Logging> delete(final String key)
	{
	/*	DeleteAttributeOperation deleteAttribute = new DeleteAttributeOperation(key);
		Either<Error, Logging> either = edit(deleteAttribute);
		
		if(either.isA())
			return either;
		
		Logging logNode = either.b();
		TreeNode node = logNode.getWrap();
		OperationLog log = logNode.getOperationLog();
		index = index.delete(key);
		Logging logIndexNode = new LoggingIndexNode(node, log, index);
		return DefaultEither.newB(logIndexNode);*/return null;
	}

	public Either<Error,Logging> put(final String key,final ByteBuffer value)
	{
		/*PutAttributeOperation putAttribute = new PutAttributeOperation(key,value);
		Either<Error, Logging> either = edit(putAttribute);
		if(either.isA())
			return either;
		
		Logging logNode = either.b();
		TreeNode newNode = logNode.getWrap();
		OperationLog newLog = logNode.getOperationLog();
		Option<TreeMap<String, TreeNode>> opAttributeIndex = index.get(key);
        String indexKey = new String(value.array());
		TreeMap<String, TreeNode> list = TreeMap.empty(Ord.stringOrd);

	    if (opAttributeIndex.isNone()) {
	        TreeMap<String, TreeNode> newAttributeindex = TreeMap.empty(Ord.stringOrd);
	        list = list.set(indexKey,newNode);
	    } else {
	        Option<TreeNode> oplist = opAttributeIndex.some().get(indexKey);
	        list = opAttributeIndex.some();
	        list = list.cons(newNode);
	    }

	      
		if (opList.isNone()) {
			list = list.set(,newNode);
		} else {
			list = opList.some();
			list = list.cons(newNode);
		}
		TreeMap<String,List<TreeNode>> newIndex = index.set(indexKey,list);
		Logging logIndexNode = new LoggingIndexNode(newNode, newLog, newIndex);
		return DefaultEither.newB(logIndexNode);*/
		return null;
	}
}