package jp.ac.u_ryukyu.ie.cr.jungle.transaction.node.Differencial;


import jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer.NodeEditorError;
import jp.ac.u_ryukyu.ie.cr.jungle.transaction.node.TreeNode;
import jp.ac.u_ryukyu.ie.cr.jungle.transaction.node.TreeNodeAttributes;
import jp.ac.u_ryukyu.ie.cr.jungle.transaction.node.TreeNodeChildren;
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.jungleError.DefaultError;
import jp.ac.u_ryukyu.ie.cr.jungle.util.jungleError.Error;

import java.nio.ByteBuffer;
import java.util.Iterator;
import java.util.List;

import static jp.ac.u_ryukyu.ie.cr.jungle.util.jungleError.TreeNodeError.PUT_ATTRIBUTE_ERROR;

public class DifferencialTreeNodeChildren implements TreeNodeChildren {

    private List<TreeNode> children;
    private TreeNode node;

    public DifferencialTreeNodeChildren(TreeNode node, List<TreeNode> _children) {
        this.children = _children;
        this.node = node;
    }

    private boolean boundaryCheck(int _pos) {
        int size = children.size();
        return size >= _pos && _pos >= 0;
    }

    @Override
    public Either<Error, TreeNode> addNewChildAt(int _pos) {
        return addNewChildAt(_pos, new DifferencialTreeNode());
    }

    @Override
    public Either<Error, TreeNode> addNewChildAt(int _pos, TreeNode _newChild) {
        if (!boundaryCheck(_pos)) {
            return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
        }
        children.add(_pos, _newChild);
        return DefaultEither.newB(node);
    }

    @Override
    public Either<Error, TreeNode> deleteChildAt(int _pos) {
        if (!boundaryCheck(_pos)) {
            return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
        }
        children.remove(_pos);
        return DefaultEither.newB(node);
    }


    @Override
    public Either<Error, TreeNode> matchingChildDeleteAt(String key, ByteBuffer value) {
        return null; //未使用
    }

    @Override
    public int size() {
        return children.size();
    }

    @Override
    public Iterator<TreeNode> iterator() {
        return children.iterator();
    }

    @Override
    public Either<Error, TreeNode> replaceNode(int _pos, TreeNode _replacement) {
        if (!boundaryCheck(_pos)) {
            return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
        }
        children.set(_pos, _replacement);
        return DefaultEither.newB(node);
    }

    @Override
    public Either<Error, TreeNode> moveChild(int pos, String move) {
        int size = children.size();
        TreeNode child = children.get(pos);
        if (move.equals("up") && pos != 0) {
            children.remove(pos);
            children.add((pos - 1), child);
        } else
            if (move.equals("down") && pos < size - 1) { //sizeは0から始まるため -1する
                children.remove(pos);
                children.add((pos + 1), child);
            } else {
                return DefaultEither.newA(new DefaultError());
            }
        return DefaultEither.newB(node);
    }

    @Override
    public Either<Error, TreeNode> addNewChildAndPutAttribtue(int pos, String key, ByteBuffer value) {
        if (!boundaryCheck(pos)) {
            return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
        }
        TreeNode node = new DifferencialTreeNode();
        TreeNodeAttributes attribute = node.getAttributes();
        Either<Error, TreeNode> either = attribute.put(key, value);
        if (either.isA())
            return DefaultEither.newA(PUT_ATTRIBUTE_ERROR);
        TreeNode child = either.b();
        return addNewChildAt(pos, child);

    }

    @Override
    public Either<Error, TreeNode> at(int _pos) {
        if (!boundaryCheck(_pos + 1) || _pos < 0) {
            return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
        }
        TreeNode n = children.get(_pos);
        return DefaultEither.newB(n);
    }
}