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.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.util.DefaultEither;
import jp.ac.u_ryukyu.ie.cr.jungle.util.Either;
import jp.ac.u_ryukyu.ie.cr.jungle.util.jungleError.Error;
import jp.ac.u_ryukyu.ie.cr.jungle.data.treemap.TreeMap;

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

public class DefaultTreeNodeAttribute implements TreeNodeAttributes {
    public List<TreeNode> children;
    public TreeMap<String, ByteBuffer> attrs;


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

    @Override
    public Either<Error, TreeNode> delete(String _key) {
        if (_key == null) {
            return DefaultEither.newA(NodeEditorError.NULL_VALUE_NOT_ALLOWED);
        }

        if (null == attrs.get(_key)) {
            return DefaultEither.newA(NodeEditorError.DELETE_KEY_NOT_FOUND);
        }

        TreeMap<String, ByteBuffer> newMap = attrs.delete(_key);
        TreeNode newNode = new DefaultTreeNode(children, newMap);
        return DefaultEither.newB(newNode);
    }

    @Override
    public Either<Error, TreeNode> put(String _key, ByteBuffer _value) {
        if (_key == null || _value == null) {
            return DefaultEither.newA(NodeEditorError.NULL_VALUE_NOT_ALLOWED);
        }

        TreeMap<String, ByteBuffer> newMap = attrs.put(_key, _value);
        TreeNode newNode = new DefaultTreeNode(children, newMap);
        return DefaultEither.newB(newNode);
    }

    @Override
    public ByteBuffer get(String _key) {
        if (_key == null) {
            return null;
        }
        Optional<ByteBuffer> op = attrs.get(_key);
        if (op.isPresent()) {
            return op.get();
        }
        return null;
    }

    @Override
    public String getString(String key) {
        ByteBuffer attribute = get(key);
        if (attribute != null)
            return new String(attribute.array());
        return null;
    }

    @Override
    public Iterator<String> getKeys() {
        return attrs.keys();
    }

    @Override
    public Iterator<String> getFilteringKey(java.util.List<String> filter) {

        return new Iterator<String>() {
            private Iterator<String> keys = attrs.keys();
            private String next = init();

            private String init() {
                while (keys.hasNext()) {
                    String key = keys.next();
                    if (filter.contains(key))
                        continue;
                    return key;
                }
                return null;
            }

            @Override
            public boolean hasNext() {
                return next != null;
            }

            @Override
            public String next() {
                String tmp = next;
                next = init();
                return tmp;
            }
        };
    }


    @Override
    public boolean contain(String key) {
        return attrs.get(key) != null;
    }

}