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


import jp.ac.u_ryukyu.ie.cr.jungle.store.trasnformer.NodeEditorError;
import jp.ac.u_ryukyu.ie.cr.jungle.util.Error;
import jp.ac.u_ryukyu.ie.cr.jungle.data.list.List;
import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.TreeNode;
import jp.ac.u_ryukyu.ie.cr.jungle.store.impl.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.data.treemap.TreeMap;

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

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();
        if (size < _pos) {
            return false;
        }

        return true;
    }

    @Override
    public List<TreeNode> getChildrenAsRawList() {
        return children;
    }

    @Override
    public Either<Error, TreeNode> addNewChildAt(int _pos) {
        if (!boundaryCheck(_pos) || _pos < 0) {
            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<jp.ac.u_ryukyu.ie.cr.jungle.util.Error, TreeNode> deleteChildAt(int _pos) {
        if (!boundaryCheck(_pos) || _pos < 0 || size() == 0) {
            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 int size() {
        return children.length();
    }

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

    @Override
    public Either<Error, TreeNode> replaceNode(int _pos, TreeNode _replacement) {
        int size = children.length();
        if (!(0 <= _pos && _pos < size)) {
            return DefaultEither.newA(NodeEditorError.INDEX_OUT_OF_BOUNDS);
        }
        TreeNode replacement = _replacement;

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

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

        TreeNode Node = children.index(_pos);

        return DefaultEither.newB(Node);
    }

    @Override
    public Either<Error, TreeNode> addNewChildAt(int _pos, TreeNode _newChild) {
        if (!boundaryCheck(_pos) || _pos < 0) {
            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);
    }

}