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

import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
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.DefaultNodePath;
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.*;
import jp.ac.u_ryukyu.ie.cr.jungle.transaction.editor.treeEditor.TreeEditor;
import jp.ac.u_ryukyu.ie.cr.jungle.transaction.manager.TransactionManager;
import jp.ac.u_ryukyu.ie.cr.jungle.transaction.node.Differencial.DifferencialTreeNode;
import jp.ac.u_ryukyu.ie.cr.jungle.transaction.node.TreeNode;
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.Error;
import jp.ac.u_ryukyu.ie.cr.jungle.util.IterableConverter;

import java.nio.ByteBuffer;

import static jp.ac.u_ryukyu.ie.cr.jungle.store.Command.APPEND_CHILD;
import static jp.ac.u_ryukyu.ie.cr.jungle.util.Error.TreeEditorError.ADD_NEW_CHILD_ERROR;


public class DifferenceJungleTreeEditor implements JungleTreeEditor {

    private final TransactionManager txManager;
    private final TreeEditor editor;
    private final TreeOperationLog log;
    private final TreeNode subTreeRoot;
    private TreeNode appendedNode;

    public DifferenceJungleTreeEditor(TreeNode subTreeRoot, TransactionManager txManager, TreeEditor editor) {
        this(subTreeRoot, subTreeRoot, txManager, editor, new DefaultTreeOperationLog());
    }


    public DifferenceJungleTreeEditor(TreeNode subTreeRoot, TreeNode appendedNode, TransactionManager txManager, TreeEditor editor, TreeOperationLog log) {
        this.txManager = txManager;
        this.editor = editor;
        this.log = log;
        this.subTreeRoot = subTreeRoot;
        this.appendedNode = appendedNode;
    }

    private Either<Error, JungleTreeEditor> _edit(final NodePath _path, NodeEditor _e) {
        Either<Error, LoggingNode> editEither = editor.edit(subTreeRoot, _path, _e);

        if (editEither.isA()) {
            return DefaultEither.newA(editEither.a());
        }

        LoggingNode newLogging = editEither.b();
        OperationLog newLog = newLogging.getOperationLog();
        NodeOperation op = newLog.getLastLog();
        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;

        if (op.getCommand() == APPEND_CHILD) {
            TreeNode newNode = newLogging.getWrap();
            int position = op.getPosition();
            Either<Error, TreeNode> either = newNode.getChildren().at(position);
            if (either.isA())
                return DefaultEither.newA(ADD_NEW_CHILD_ERROR);
            TreeNode newChild = either.b();
            newEditor = new DifferenceJungleTreeEditor(subTreeRoot, newChild, txManager, editor, newTreeOpLog);
        } else
            newEditor = new DifferenceJungleTreeEditor(subTreeRoot, appendedNode, txManager, editor, newTreeOpLog);
        return DefaultEither.newB(newEditor);
    }


    @Override
    public Either<Error, JungleTreeEditor> replaceNewRootNode() {
        ReplaceRootNodeAt replaceRootNodeAt = new ReplaceRootNodeAt();
        return _edit(new DefaultNodePath(), replaceRootNodeAt);
    }

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

    @Override
    public Either<Error, JungleTreeEditor> addNewChildAndPutAttribute(NodePath path, int pos, String key, ByteBuffer value) {
        AppendChildAndPutAttribute appendChildAndPutAttribute = new AppendChildAndPutAttribute(key, value, pos);
        return _edit(path, appendChildAndPutAttribute);
    }

    @Override
    public Either<Error, JungleTreeEditor> deleteChildAt(NodePath _path, int _pos) {
        DeleteChildAt deleteChildAt = new DeleteChildAt(_pos);
        return _edit(_path, deleteChildAt);
    }


    @Override
    public Either<Error, JungleTreeEditor> putAttribute(NodePath _path, String _key, ByteBuffer _value) {
        PutAttribute putAttribute = new PutAttribute(_key, _value);
        return _edit(_path, putAttribute);
    }

    @Override
    public Either<Error, JungleTreeEditor> deleteAttribute(NodePath _path, String _key) {
        DeleteAttribute deleteAttribute = new DeleteAttribute(_key);
        return _edit(_path, deleteAttribute);
    }

    @Override
    public Either<Error, JungleTreeEditor> moveChild(NodePath path, int childNum, String move) {
        MoveChild movechild = new MoveChild(move, childNum);
        return _edit(path, movechild);
    }


    @Override
    public Either<Error, JungleTreeEditor> edit(NodePath _path, NodeEditor _editor) {
        return _edit(_path, _editor);
    }

    @Override
    public Either<Error, JungleTreeEditor> success() {
        List<TreeNode> endNodeList = new List<TreeNode>().add(0, appendedNode);
        Either<Error, TransactionManager> either = txManager.commit(subTreeRoot, log, endNodeList);
        if (either.isA()) {
            return DefaultEither.newA(either.a());
        }
        TransactionManager newTxManager = either.b();
        JungleTreeEditor newTreeEditor = new DifferenceJungleTreeEditor(new DifferencialTreeNode(), newTxManager, editor);
        return DefaultEither.newB(newTreeEditor);
    }

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