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

import java.util.Iterator;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.AppendChildAtOperation;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.DeleteChildAtOperation;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.operations.NodeOperation;
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 LoggingChildren<T extends EditableNode<T>> implements EditableChildren<LoggingNode<T>>
{
	private final T wrap;
	private final OperationLog log;
	
	public LoggingChildren(T _wrap,OperationLog _log)
	{
		wrap = _wrap;
		log = _log;
	}

	@Override
	public int size()
	{
		EditableChildren<T> children = wrap.getChildren();
		return children.size();
	}
	
	@Override
	public Iterator<LoggingNode<T>> iterator()
	{
		EditableChildren<T> children = wrap.getChildren();
		
		IterableConverter.Converter<LoggingNode<T>,T> converter = new IterableConverter.Converter<LoggingNode<T>,T>(){
			@Override
			public LoggingNode<T> conv(T _b) {
				return new LoggingNode<T>(_b,log);
			}
		};
		
		IterableConverter<LoggingNode<T>,T> iterable = new IterableConverter<LoggingNode<T>,T>(children,converter);
		return iterable.iterator();
	}
	
	public Either<Error,LoggingNode<T>> edit(NodeOperation _op)
	{
		Either<Error,T> either = _op.invoke(wrap);
		if(either.isA()){
			return DefaultEither.newA(either.a());
		}
		
		T newWrap = either.b();
		OperationLog newLog = log.add(_op);
		LoggingNode<T> newLoggingNode = new LoggingNode<T>(newWrap,newLog);
		return DefaultEither.newB(newLoggingNode);
	}
	
	@Override
	public Either<Error,LoggingNode<T>> addNewChildAt(final int _pos)
	{
		NodeOperation addNewChildAt = new AppendChildAtOperation(_pos);
		return edit(addNewChildAt);
	}

	@Override
	public Either<Error,LoggingNode<T>> deleteChildAt(final int _pos)
	{
		NodeOperation deleteChildAt = new DeleteChildAtOperation(_pos);
		return edit(deleteChildAt);
	}

	@Override
	public Either<Error,LoggingNode<T>> at(int _pos)
	{
		EditableChildren<T> children = wrap.getChildren();
		Either<Error,T> either = children.at(_pos);
		if(either.isA()){
			return DefaultEither.newA(either.a());
		}
		
		T newWrap = either.b();
		return DefaultEither.newB(new LoggingNode<T>(newWrap,log));
	}
}