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.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;


public class DefaultJungleTreeEditor implements JungleTreeEditor {
    private final TransactionManager txManager;
    private final TreeNode root;
    private final TreeEditor editor;
    private final TreeOperationLog log;
    private final List<TreeNode> editedNodeList;

    public DefaultJungleTreeEditor(TreeNode _root, TransactionManager _txManager, TreeEditor _editor) {
        this(_root, _txManager, _editor, new DefaultTreeOperationLog(), new List<>());
    }


    public DefaultJungleTreeEditor(TreeNode newNode, TransactionManager _txManager, TreeEditor _editor, TreeOperationLog _log, List<TreeNode> editedNodeList) {
        this.root = newNode;
        this.txManager = _txManager;
        this.editor = _editor;
        this.log = _log;
        this.editedNodeList = editedNodeList;
    }

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

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

        LoggingNode newLogging = editEither.b();
        OperationLog newLog = newLogging.getOperationLog();
        TreeNode newNode = newLogging.getWrap();
        TreeNode editedNode = newLogging.getEditedNode();
        List<TreeNode> newEditendNodeList = editedNodeList.add(0, editedNode);
        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 DefaultJungleTreeEditor(newNode, txManager, editor, newTreeOpLog, newEditendNodeList);
        return DefaultEither.newB(newEditor);
    }

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

    @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() {
        Either<Error, TransactionManager> either = txManager.commit(root, log, editedNodeList);
        if (either.isA()) {
            return DefaultEither.newA(either.a());
        }

        TransactionManager newTxManager = either.b();
        JungleTreeEditor newTreeEditor = new DefaultJungleTreeEditor(root, newTxManager, editor);

        return DefaultEither.newB(newTreeEditor);
    }

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

}