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

import java.nio.ByteBuffer;

import fj.data.List;
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,List<TreeNode>> index;
	
	public LoggingIndexAttributes(TreeNode _wrap, OperationLog _log, 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);
	}

	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();
		String indexKey = new String(value.array());
		List<TreeNode> list = index.get(indexKey).some();
		list = list.cons(newNode);
		index.set(indexKey, list);
		Logging logIndexNode = new LoggingIndexNode(newNode, newLog, index);
		return DefaultEither.newB(logIndexNode);
	}
}