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

import fj.data.List;
import fj.data.TreeMap;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.persistent.ChangeListWriter;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.TreeContext;
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.DefaultJungleTreeEditor;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.transaction.DefaultTransactionManager;
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.ParentIndex;

import java.util.concurrent.atomic.AtomicReference;

public class DefaultJungleTree implements JungleTree {

    private final AtomicReference<TreeContext> repository;
    private final String uuid;
    private final ChangeListWriter writer;
    private final TreeEditor treeEditor;

    public DefaultJungleTree(TreeContext tc, String uuid, ChangeListWriter writer, TreeEditor editor) {
        this.repository = new AtomicReference<TreeContext>(tc);
        this.uuid = uuid;
        this.writer = writer;
        this.treeEditor = editor;
    }

    @Override
    public JungleTreeEditor getTreeEditor() {
        TreeContext tc = repository.get();
        DefaultTransactionManager txManager = new DefaultTransactionManager(writer, tc, repository, uuid);
        TreeNode root = tc.getRoot();
        return new DefaultJungleTreeEditor(root, txManager, treeEditor);
    }

    @Override
    public JungleTreeEditor getLocalTreeEditor() {
        return getTreeEditor();
    }

    @Override
    public TreeNode getRootNode() {
        TreeContext tc = repository.get();
        return tc.getRoot();
    }

    @Override
    public InterfaceTraverser getTraverser(boolean useIndex) {
        TreeContext tc = repository.get();
        return tc.getTraverser();
    }

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

    @Override
    public TreeMap<String, TreeMap<String, List<TreeNode>>> getIndex() {
        TreeContext tc = repository.get();
        return tc.getIndex();
    }

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

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

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


        String oldTreeUuid = uuid + revision;
        JungleTree oldTree = new DefaultJungleTree(tc, oldTreeUuid, writer, treeEditor);
        return DefaultEither.newB(oldTree);
    }

    @Override
    public Either<Error, TreeNode> getNodeOfPath(NodePath path) {
        TreeNode node = repository.get().getRoot();
        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);
    }

}