package jp.ac.u_ryukyu.ie.cr.jungleNetwork.persistent;

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.jungleTreeEditor.JungleTreeEditor;
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 PersistentJungleTreeEditor implements JungleTreeEditor {
    private final TransactionManager txManager;
    private final TreeNode root;
    private final TreeEditor editor;
    private final TreeOperationLog log;
    private final List<TreeNode> editedNodeList = new List<>();

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


    public PersistentJungleTreeEditor(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> 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();

        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 PersistentJungleTreeEditor(newNode, 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> moveChild(NodePath path,int childNum, String move) {
        MoveChild movechild = new MoveChild(move, childNum);
        return _edit(path,movechild);
    }

    @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> 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;
        newTreeEditor = new PersistentJungleTreeEditor(root, newTxManager, editor, log);
        return DefaultEither.newB(newTreeEditor);
    }

    @Override
    public Either<Error, JungleTreeEditor> flushSuccess() {
        Either<Error, TransactionManager> either = txManager.flashCommit(root, log);
        if (either.isA()) {
            return DefaultEither.newA(either.a());
        }

        TransactionManager newTxManager = either.b();

        JungleTreeEditor newTreeEditor;
        newTreeEditor = new PersistentJungleTreeEditor(root, newTxManager, editor, log);
        return DefaultEither.newB(newTreeEditor);
    }


}