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.core.Node;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultAttributes;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultChildren;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNode;
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;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.IterableConverter;

public class DefaultTreeNodeChildren implements TreeNodeChildren<DefaultTreeNode>
{
	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());
		
	}
	
	private final DefaultNode node;
	
	public DefaultTreeNodeChildren(DefaultNode _node)
	{
		node = _node;
	}
	
	private boolean boundaryCheck(int _pos)
	{
		int size = node.getChildren().size();
		if(size < _pos){
			return false;
		}
		
		return true;
	}

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

	@Override
	public Either<Error,DefaultTreeNode> deleteChildAt(int _pos)
	{
		if(!boundaryCheck(_pos) || _pos < 0 || size() == 0){
			return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
		}
		
		DefaultChildren chs = node.getChildren();
		List<Node> raw = chs.getChildrenAsRawList();
		
		P2<List<Node>,List<Node>> split = raw.splitAt(_pos);
		List<Node> newChildren = split._1().append(split._2().tail());
		
		DefaultAttributes attrs = node.getAttributes();
		TreeMap<String, ByteBuffer> map = attrs.getAttributesAsRawMap();
		
		DefaultNode newNode = new DefaultNode(newChildren,map);
		
		return DefaultEither.newB(new DefaultTreeNode(newNode));
	}

	@Override
	public int size()
	{
		return node.getChildren().size();
	}

	@Override
	public Iterator<DefaultTreeNode> iterator()
	{
		IterableConverter.Converter<DefaultTreeNode,DefaultNode> converter = new IterableConverter.Converter<DefaultTreeNode,DefaultNode>(){
			@Override
			public DefaultTreeNode conv(DefaultNode _b)
			{
				return new DefaultTreeNode(_b);
			}
		};
		
		List<Node> raw = node.getChildren().getChildrenAsRawList();
		return new IterableConverter<DefaultTreeNode,DefaultNode>(raw,converter).iterator();
	}

	@Override
	public Either<Error,DefaultTreeNode> replaceNode(int _pos,DefaultTreeNode _replacement)
	{
		int size = node.getChildren().size();
		if(!(0 <= _pos && _pos < size)){
			return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
		}
		DefaultNode replacement = _replacement.getWrap();
		
		List<DefaultNode> rawList = node.getChildren().getChildrenAsRawList();
		P2<List<DefaultNode>,List<DefaultNode>> split = rawList.splitAt(_pos + 1);
		List<DefaultNode> init = split._1().reverse().tail().reverse();
		List<DefaultNode> newInit = init.snoc(replacement);
		List<DefaultNode> newList = newInit.append(split._2());
		TreeMap<String, ByteBuffer> rawMap = node.getAttributes().getAttributesAsRawMap();
		
		return DefaultEither.newB(new DefaultTreeNode(new DefaultNode(newList,rawMap)));
	}

	@Override
	public Either<Error,DefaultTreeNode> at(int _pos)
	{
		List<DefaultNode> rawList = node.getChildren().getChildrenAsRawList();
		DefaultNode ch = rawList.index(_pos);
		if(ch == null){
			return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
		}
		
		return DefaultEither.newB(new DefaultTreeNode(ch));
	}

	@Override
	public Either<Error,DefaultTreeNode> addNewChildAt(int _pos,DefaultTreeNode _newChild)
	{
		if(!boundaryCheck(_pos) || _pos < 0){
			return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
		}
		Node newChild = _newChild.getWrap();
		
		List<Node> raw = node.getChildren().getChildrenAsRawList();
		TreeMap<String, ByteBuffer> rawMap = node.getAttributes().getAttributesAsRawMap();
		
		P2<List<Node>,List<DefaultNode>> split = raw.splitAt(_pos);
		List<Node> newChildren = split._1().snoc(newChild).append(split._2());
		Node newNode = new DefaultNode(newChildren,rawMap);
		
		return DefaultEither.newB(new DefaultTreeNode(newNode));
	}
}