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


import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
import jp.ac.u_ryukyu.ie.cr.jungle.data.treemap.TreeMap;
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 static jp.ac.u_ryukyu.ie.cr.jungle.util.jungleError.TreeNodeError.PUT_ATTRIBUTE_ERROR;

public class DefaultTreeNodeChildren implements TreeNodeChildren {

    public List<TreeNode> children;
    public TreeMap<String, ByteBuffer> attrs;

    public DefaultTreeNodeChildren(List<TreeNode> _children, TreeMap<String, ByteBuffer> _attrs) {
        children = _children;
        attrs = _attrs;
    }

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

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

        List<TreeNode> newChildren = children.add(_pos, new DefaultTreeNode());
        TreeNode newNode = new DefaultTreeNode(newChildren, attrs);
        return DefaultEither.newB(newNode);
    }

    @Override
    public Either<Error, TreeNode> addNewChildAt(int _pos, TreeNode _newChild) {
        if (!boundaryCheck(_pos)) {
            return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
        }
        List<TreeNode> newChildren = children.add(_pos, _newChild);
        TreeNode newNode = new DefaultTreeNode(newChildren, attrs);

        return DefaultEither.newB(newNode);
    }

    @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 DefaultTreeNode();
        TreeNodeAttributes attribute = node.getAttributes();
        Either<Error,TreeNode> either = attribute.put(key, value);
        if (either.isA())
            return DefaultEither.newA(PUT_ATTRIBUTE_ERROR);
        TreeNode newTreeNode = either.b();
        return addNewChildAt(pos,newTreeNode);
    }


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

        List<TreeNode> newChildren = children.delete(_pos);
        TreeNode newNode = new DefaultTreeNode(newChildren, attrs);

        return DefaultEither.newB(newNode);
    }

    //まだ実装していない もともと赤黒木の編集用
    @Override
    public Either<Error, TreeNode> matchingChildDeleteAt(String key, ByteBuffer value) {
        return null;
    }

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

    @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);
        }
        List<TreeNode> newChildren = children.replace(_pos, _replacement);
        TreeNode node = new DefaultTreeNode(newChildren, attrs);
        return DefaultEither.newB(node);
    }

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

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

        TreeNode Node = children.get(_pos);

        return DefaultEither.newB(Node);
    }

}