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.ClonableChildren;
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.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 ClonableDefaultChildren implements ClonableChildren<ClonableDefaultNode>
{
	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 ClonableDefaultChildren(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,ClonableDefaultNode> 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<DefaultNode> raw = children.getChildrenAsRawList();
		
		P2<List<DefaultNode>,List<DefaultNode>> split = raw.splitAt(_pos);
		List<DefaultNode> newChildren = split._1().snoc(new DefaultNode()).append(split._2());
		DefaultNode newNode = new DefaultNode(newChildren,attrs.getAttributesAsRawMap());
		
		return DefaultEither.newB(new ClonableDefaultNode(newNode));
	}

	@Override
	public Either<Error,ClonableDefaultNode> deleteChildAt(int _pos)
	{
		if(!boundaryCheck(_pos) || _pos < 0 || size() == 0){
			return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
		}
		
		DefaultChildren chs = node.getChildren();
		List<DefaultNode> raw = chs.getChildrenAsRawList();
		
		P2<List<DefaultNode>,List<DefaultNode>> split = raw.splitAt(_pos);
		//List<DefaultNode> newChildren = split._1().init().append(split._2());
		List<DefaultNode> 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 ClonableDefaultNode(newNode));
	}

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

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

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

	@Override
	public Either<Error,ClonableDefaultNode> 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 ClonableDefaultNode(ch));
	}

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