package jp.ac.u_ryukyu.ie.cr.jungle.transaction.editor.jungleTreeEditor;

import jp.ac.u_ryukyu.ie.cr.jungle.transaction.node.TreeNode;
import jp.ac.u_ryukyu.ie.cr.jungle.store.logger.DefaultTreeOperationLog;
import jp.ac.u_ryukyu.ie.cr.jungle.store.logger.LoggingNode;
import jp.ac.u_ryukyu.ie.cr.jungle.store.logger.OperationLog;
import jp.ac.u_ryukyu.ie.cr.jungle.store.logger.TreeOperationLog;
import jp.ac.u_ryukyu.ie.cr.jungle.store.nodepath.NodePath;
import jp.ac.u_ryukyu.ie.cr.jungle.store.operations.DefaultTreeOperation;
import jp.ac.u_ryukyu.ie.cr.jungle.store.operations.NodeOperation;
import jp.ac.u_ryukyu.ie.cr.jungle.store.operations.TreeOperation;
import jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer.AppendChildAt;
import jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer.NodeEditor;
import jp.ac.u_ryukyu.ie.cr.jungle.transaction.TransactionManager;
import jp.ac.u_ryukyu.ie.cr.jungle.transaction.editor.treeEditor.TreeEditor;
import jp.ac.u_ryukyu.ie.cr.jungle.util.DefaultEither;
import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
import jp.ac.u_ryukyu.ie.cr.jungle.util.IterableConverter;

import java.nio.ByteBuffer;

import static jp.ac.u_ryukyu.ie.cr.jungle.transaction.editor.Error.TreeEditorError.NOT_USE_METHOD;

/**
 * Created by e115731 on 2016/12/11.
 */
public class DefaultDifferenceJungleTreeEditor implements JungleTreeEditor {

    private final TransactionManager txManager;
    private final TreeNode root;
    private final TreeEditor editor;
    private final TreeOperationLog log;

    public DefaultDifferenceJungleTreeEditor(TreeNode _root, TransactionManager _txManager, TreeEditor _editor) {
        this(_root, _txManager, _editor, new DefaultTreeOperationLog());
    }


    public DefaultDifferenceJungleTreeEditor(TreeNode newNode, TransactionManager _txManager, TreeEditor _editor, TreeOperationLog _log) {
        this.root = newNode;
        this.txManager = _txManager;
        this.editor = _editor;
        this.log = _log;
    }

    private Either<Error, JungleTreeEditor> _edit(final NodePath _path, NodeEditor _e) {
        Either<Error, LoggingNode> either = editor.edit(root, _path, _e);
        if(either.isA()){
            return DefaultEither.newA(either.a());
        }

        LoggingNode newLogging = either.b();
        OperationLog newLog = newLogging.getOperationLog();
        TreeNode newNode = newLogging.getWrap();

        IterableConverter.Converter<TreeOperation,NodeOperation> converter = new IterableConverter.Converter<TreeOperation,NodeOperation>(){
            @Override
            public TreeOperation conv(NodeOperation _b){
                return new DefaultTreeOperation(_path,_b);
            }
        };

        Iterable<TreeOperation> iterable = new IterableConverter<>(newLog,converter);
        DefaultTreeOperationLog treeOperationLog = new DefaultTreeOperationLog(iterable,newLog.length());
        TreeOperationLog newTreeOpLog = log.append(treeOperationLog);

        JungleTreeEditor newEditor = new DefaultDifferenceJungleTreeEditor(newNode,txManager,editor,newTreeOpLog);
        return DefaultEither.newB(newEditor);
    }


    @Override
    public Either<Error, JungleTreeEditor> addNewChildAt(NodePath path, int pos) {
        AppendChildAt appendChildAt = new AppendChildAt(pos);
        return _edit(path,appendChildAt);
    }

    @Override
    public Either<Error, JungleTreeEditor> deleteChildAt(NodePath path, int pos) {
        return null;
    }

    @Override
    public Either<Error, JungleTreeEditor> putAttribute(NodePath path, String key, ByteBuffer value) {
        return null;
    }

    @Override
    public Either<Error, JungleTreeEditor> deleteAttribute(NodePath path, String key) {
        return null;
    }

    @Override
    public Either<Error, JungleTreeEditor> replaceNewRootNode() {
        return null;
    }

    @Override
    public Either<Error, JungleTreeEditor> edit(NodePath path, NodeEditor editor) {
        return null;
    }

    @Override
    public Either<Error, JungleTreeEditor> success() {
        return null;
    }

    @Override
    public Either<Error, JungleTreeEditor> flushSuccess() {
        return null;
    }

    @Override
    public Either<Error, JungleTreeEditor> moveChild(NodePath path, int childNum, String move) {
        return DefaultEither.newA(NOT_USE_METHOD);
    }
}