package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction;

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

import fj.P2;
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.TreeNodeChildren;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.NodeEditorError;
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;

public class DefaultTreeNodeChildren implements TreeNodeChildren
{
	public static void main(String _args[])
	{
		List<Integer> list = List.range(0,5);
		P2<List<Integer>, List<Integer>> split = list.splitAt(0);
		System.out.println(split._1().length());
		System.out.println(split._2().length());
		
	}
	
	public List<TreeNode> children;
	public TreeMap<String,ByteBuffer> attrs;

	public DefaultTreeNodeChildren(List<TreeNode> _children,TreeMap<String,ByteBuffer> _attrs)
	{
		children = _children;
		attrs = _attrs;
	}
	
	private boolean boundaryCheck(int _pos)
	{
		int size = children.length();
		if(size < _pos){
			return false;
		}
		
		return true;
	}

	@Override
	public List<TreeNode> getChildrenAsRawList(){
		return children;
	}
	@Override
	public Either<Error,TreeNode> addNewChildAt(int _pos)
	{
		if(!boundaryCheck(_pos) || _pos < 0){
			return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
		}
		
		P2<List<TreeNode>,List<TreeNode>> split = children.splitAt(_pos);
		List<TreeNode> newChildren = split._1().snoc(new DefaultTreeNode()).append(split._2());
		TreeNode newNode = new DefaultTreeNode(newChildren,attrs);
		return DefaultEither.newB(newNode);
	}

	@Override
	public Either<Error,TreeNode> deleteChildAt(int _pos)
	{
		if(!boundaryCheck(_pos) || _pos < 0 || size() == 0){
			return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
		}
				
		P2<List<TreeNode>,List<TreeNode>> split = children.splitAt(_pos);
		List<TreeNode> newChildren = split._1().append(split._2().tail());
		TreeNode newNode = new DefaultTreeNode(newChildren,attrs);
		
		return DefaultEither.newB(newNode);
	}

	@Override
	public int size()
	{
		return children.length();
	}

	@Override
	public Iterator<TreeNode> iterator()
	{
		return children.iterator();
	}

	@Override
	public Either<Error,TreeNode> replaceNode(int _pos,TreeNode _replacement)
	{
		int size = children.length();
		if(!(0 <= _pos && _pos < size)){
			return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
		}
		TreeNode replacement = _replacement;
		
		P2<List<TreeNode>,List<TreeNode>> split = children.splitAt(_pos + 1);
		List<TreeNode> init = split._1().reverse().tail().reverse();
		List<TreeNode> newInit = init.snoc(replacement);
		List<TreeNode> newList = newInit.append(split._2());
		TreeNode node = new DefaultTreeNode(newList,attrs);
		return DefaultEither.newB(node);
	}

	@Override
	public Either<Error,TreeNode> at(int _pos)
	{
    if(children.length() < _pos + 1){
      return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
    }

	  TreeNode Node = children.index(_pos);
		
		return DefaultEither.newB(Node);
	}

	@Override
	public Either<Error,TreeNode> addNewChildAt(int _pos,TreeNode _newChild)
	{
		if(!boundaryCheck(_pos) || _pos < 0){
			return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
		}
		
		
		P2<List<TreeNode>,List<TreeNode>> split = children.splitAt(_pos);
		List<TreeNode> newChildren = split._1().snoc(_newChild).append(split._2());
		TreeNode newNode = new DefaultTreeNode(newChildren,attrs);
		
		return DefaultEither.newB(newNode);
	}
}