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

import java.util.Iterator;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.Attributes;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.AttributesContainer;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.Children;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.Node;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.core.Parent;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeListWriter;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.ChangeSet;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.DefaultNode;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.AtomicReservableReference;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultChangeSet;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultJungleTreeEditor;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTransactionManager;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.DefaultTraverser;
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;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.IterableConverter.Converter;

public class DefaultJungleTree implements JungleTree
{
	private final AtomicReservableReference<DefaultChangeSet> repository;
	private final String uuid;
	private final ChangeListWriter writer;
	
	public DefaultJungleTree(DefaultChangeSet _set,String _uuid,ChangeListWriter _writer)
	{
		repository = new AtomicReservableReference<DefaultChangeSet>(_set);
		uuid = _uuid;
		writer = _writer;
	}

	@Override
	public DefaultJungleTreeEditor getTreeEditor()
	{
		DefaultChangeSet tip = repository.get();
		DefaultTransactionManager txManager = new DefaultTransactionManager(writer,tip,repository,uuid);
		DefaultNode root = tip.getRoot();
		return new DefaultJungleTreeEditor(root,txManager,new DefaultTraverser());
	}

	@Override
	public Node getRootNode()
	{
		ChangeSet set = repository.get();
		return set.getRoot();
	}
	
	public static class NodeWrapper<T extends Parent<T> & AttributesContainer> implements Node
	{
		private final T wrap;
		
		public NodeWrapper(T _wrap)
		{
			wrap = _wrap;
		}

		@Override
		public Attributes getAttributes()
		{
			return wrap.getAttributes();
		}

		@Override
		public Children<Node> getChildren()
		{
			Children<T> children = wrap.getChildren();
			return new ChildrenWrapper<T>(children);
		}
		
		public static class ChildrenWrapper<T extends Parent<T> & AttributesContainer> implements Children<Node>
		{
			private Children<T> wrap;
			
			public ChildrenWrapper(Children<T> _wrap)
			{
				wrap = _wrap;
			}

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

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

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