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.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.Error.DefaultError;
import jp.ac.u_ryukyu.ie.cr.jungle.util.Error.Error;

import java.util.Iterator;
import java.util.List;

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 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> 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);
    }
}