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.impl.ClonableChildren;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.ClonableNode;
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.Operation;
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 ClonableNode<T>> implements ClonableChildren<LoggingNode<T>>
{
	private final ClonableChildren<T> wrap;
	private final Logger log;
	
	public LoggingChildren(ClonableChildren<T> _wrap,Logger _log)
	{
		wrap = _wrap;
		log = _log;
	}

	@Override
	public int size()
	{
		return wrap.size();
	}
	
	@Override
	public Iterator<LoggingNode<T>> iterator()
	{
		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>(wrap,converter);
		return iterable.iterator();
	}
	
	@Override
	public Either<Error,LoggingNode<T>> addNewChildAt(final int _pos)
	{
		Either<Error,T> either = wrap.addNewChildAt(_pos);
		if(either.isA()){
			return DefaultEither.newA(either.a());
		}
		
		Operation opAddChild = new AppendChildAtOperation(){
			@Override
			public int position(){
				return _pos;
			}
		};
		
		Logger newLog = log.add(opAddChild);
		T newWrap = either.b();
		LoggingNode<T> newLoggingNode = new LoggingNode<T>(newWrap,newLog);
		
		return DefaultEither.newB(newLoggingNode);
	}

	@Override
	public Either<Error,LoggingNode<T>> deleteChildAt(final int _pos)
	{
		Either<Error,T> either = wrap.deleteChildAt(_pos);
		if(either.isA()){
			return DefaultEither.newA(either.a());
		}
		
		Operation opDeleteChild = new DeleteChildAtOperation(){
			@Override
			public int position(){
				return _pos;
			}
		};
		
		Logger newLog = log.add(opDeleteChild);
		LoggingNode<T> newLoggingNode = new LoggingNode<T>(either.b(),newLog);
		
		return DefaultEither.newB(newLoggingNode);
	}

	@Override
	public Either<Error,LoggingNode<T>> replaceNode(int _pos,LoggingNode<T> _replacement)
	{
		T target = _replacement.getWrapper();
		Either<Error,T> e = wrap.replaceNode(_pos,target);
		if(e.isA()){
			return DefaultEither.newA(e.a());
		}
			
		T newWrap = e.b();
		return DefaultEither.newB(new LoggingNode<T>(newWrap,log));
	}

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

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