package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl;

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

import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.Node;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.EditableAttributes;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.EditableChildren;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.trasnformer.EditableNode;
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 EditableNodeWrapper<T extends TreeNode<T>> implements EditableNode<EditableNodeWrapper<T>>
{
	private final T wrap;
	
	public EditableNodeWrapper(T _wrap)
	{
		wrap = _wrap;
	}

	@Override
	public EditableAttributes<EditableNodeWrapper<T>> getAttributes()
	{
		return new EditableAttributesWrapper<T>(wrap);
	}

	@Override
	public EditableChildren<EditableNodeWrapper<T>> getChildren()
	{
		return new EditableChildrenWrapper<T>(wrap);
	}
	
	public T getWrap()
	{
		return wrap;
	}

	private static class EditableAttributesWrapper<T extends TreeNode<T>> implements EditableAttributes<EditableNodeWrapper<T>>
	{
		private final TreeNodeAttributes<T> attributes;
		
		public EditableAttributesWrapper(T _wrap)
		{
			attributes = _wrap.getAttributes();
		}
		
		@Override
		public ByteBuffer get(String _key)
		{
			return attributes.get(_key);
		}

		@Override
		public Either<Error, EditableNodeWrapper<T>> delete(String _key)
		{
			Either<Error,T> either = attributes.delete(_key);
			if(either.isA()){
				return DefaultEither.newA(either.a());
			}
			
			T newWrap = either.b();
			EditableNodeWrapper<T> newWrapper = new EditableNodeWrapper<T>(newWrap);
			return DefaultEither.newB(newWrapper);
		}

		@Override
		public Either<Error, EditableNodeWrapper<T>> put(String _key,ByteBuffer _value)
		{
			Either<Error,T> either = attributes.put(_key,_value);
			if(either.isA()){
				return DefaultEither.newA(either.a());
			}
			
			T newWrap = either.b();
			EditableNodeWrapper<T> newWrapper = new EditableNodeWrapper<T>(newWrap);
			return DefaultEither.newB(newWrapper);
		}
	}
	
	public static class EditableChildrenWrapper<T extends TreeNode<T>> implements EditableChildren<EditableNodeWrapper<T>>
	{
		private final TreeNodeChildren<T> children;
		
		public EditableChildrenWrapper(T _wrap)
		{
			children = _wrap.getChildren();
		}

		@Override
		public Either<Error,Node> at(int _pos)
		{
			Either<Error,T> either = children.at(_pos);
			if(either.isA()){
				return DefaultEither.newA(either.a());
			}
			
			T target = either.b();
			Node newWrapper = new NodeWrapper<T>(target);
			return DefaultEither.newB(newWrapper);
		}

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

		@Override
		public Iterator<Node> iterator()
		{
			IterableConverter.Converter<Node,T> converter = new IterableConverter.Converter<Node,T>(){
				@Override
				public Node conv(T _b){
					return new NodeWrapper<T>(_b);
				}
			};
			
			
			return new IterableConverter<Node,T>(children,converter).iterator();
		}

		@Override
		public Either<Error,EditableNodeWrapper<T>> addNewChildAt(int _pos)
		{
			Either<Error,T> either = children.addNewChildAt(_pos);
			if(either.isA()){
				return DefaultEither.newA(either.a());
			}
			T newWrap = either.b();
			EditableNodeWrapper<T> newWrapper = new EditableNodeWrapper<T>(newWrap);
			
			return DefaultEither.newB(newWrapper);
		}

		@Override
		public Either<Error,EditableNodeWrapper<T>> deleteChildAt(int _pos)
		{
			Either<Error,T> either = children.deleteChildAt(_pos);
			if(either.isA()){
				return DefaultEither.newA(either.a());
			}
			T newWrap = either.b();
			EditableNodeWrapper<T> newWrapper = new EditableNodeWrapper<T>(newWrap);
			
			return DefaultEither.newB(newWrapper);
		}
	}
}