package alice.jungle.transaction;


import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.DefaultJungleTree;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTreeEditor;
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.NodePath;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeEditor;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.AtomicReservableReference;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTreeContext;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.TreeContext;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.InterfaceTraverser;
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.GetOldTreeError;
import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.Index;
import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.IndexManager;
import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex;

public class NetworkDefaultJungleTree implements JungleTree {
	private final AtomicReservableReference<TreeContext> repository;
	private final String uuid;
	private final String treeName;
	private final ChangeListWriter writer;
	private final TreeEditor editor;
	
	public NetworkDefaultJungleTree(String _treeName, TreeContext _tc,String _uuid,ChangeListWriter _writer,TreeEditor _editor)
	{
		treeName = _treeName;
		repository = new AtomicReservableReference<TreeContext>(_tc);
		uuid = _uuid;
		writer = _writer;
		editor = _editor;
	}

	@Override
	public JungleTreeEditor getTreeEditor()
	{
		TreeContext tc = repository.get();
		NetworkTransactionManager txManager = new NetworkTransactionManager(treeName, writer,tc,repository,uuid);
		TreeNode root = tc.getTreeNode();
		return new NetworkDefaultJungleTreeEditor(treeName, root,txManager,editor);
	}
	
	@Override
	public JungleTreeEditor getLocalTreeEditor()
	{
		TreeContext tc = repository.get();
		NetworkTransactionManager txManager = new NetworkTransactionManager(treeName, writer,tc,repository,uuid);
		TreeNode root = tc.getTreeNode();
		return NetworkDefaultJungleTreeEditor.NewLocalJungleTreeEditor(treeName,root,txManager, editor);
	}
	
	@Override
	public TreeNode getRootNode()
	{
		TreeContext tc = repository.get();
		ChangeSet cs = tc.getChangeSet();
		return cs.getRoot();
	}

  @Override
  public long revision() {
    TreeContext tc = repository.get();
    ChangeSet cs = tc.getChangeSet();
    return cs.revision();
  }

  @Override
  public Either<Error, JungleTree> getOldTree(long revision) {
    TreeContext tc = repository.get();
    ChangeSet cs = tc.getChangeSet();

    for (; cs.revision() != revision;) {
      cs = cs.prev();
      if (cs == null)
        return DefaultEither.newA(GetOldTreeError.OLD_TREE_NOT_FOUND);
    }

    TreeNode root = cs.getRoot();

    TreeContext oldTc = new DefaultTreeContext(root, cs);
    String oldTreeUuid = uuid + revision;
    JungleTree oldTree = new DefaultJungleTree(oldTc, oldTreeUuid, writer, editor);
    return DefaultEither.newB(oldTree);
  }

  @Override
  public ParentIndex getParentIndex() {
    TreeContext tc = repository.get();
    ChangeSet cs = tc.getChangeSet();
    return cs.getParentIndex();
  }

  @Override
  public Index getIndex() {
    TreeContext tc = repository.get();
    ChangeSet cs = tc.getChangeSet();
    return cs.getIndex();
  }
  

  @Override
  public InterfaceTraverser getTraverser(boolean useIndex) {
    AtomicReservableReference<TreeContext>.Reservation reservation = repository.getReservation();
    IndexManager indexManager = new IndexManager(reservation);
    Index index = getIndex();
    ParentIndex parentIndex = getParentIndex();
    return new InterfaceTraverser(getRootNode(), index, parentIndex, indexManager, useIndex);
  }
  

  @Override
  public Either<Error, TreeNode> getNodeOfPath(NodePath path) {
    TreeNode node = repository.get().getTreeNode();
    for (int num : path) {
      if (num == -1)
        continue;
      Either<Error, TreeNode> either = node.getChildren().at(num);
      if (either.isA())
        return either;
      node = either.b();
    }
    return DefaultEither.newB(node);
  }


}