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

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


public class DifferencialTreeNodeAttribute implements TreeNodeAttributes {

    private TreeMap<String, ByteBuffer> attrs;
    private TreeNode node;

    public DifferencialTreeNodeAttribute(TreeNode node, TreeMap<String, ByteBuffer> _attrs) {
        attrs = _attrs;
        this.node = node;
    }

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

        attrs.remove(_key);
        return DefaultEither.newB(node);
    }

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

        attrs.put(_key, _value);
        return DefaultEither.newB(node);
    }

    @Override
    public ByteBuffer get(String _key) {
        if (_key == null) {
            return null;
        }

        return attrs.get(_key);
    }

    @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.keySet().iterator();
    }

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

        return new Iterator<String>() {
            private Iterator<String> keys = attrs.keySet().iterator();
            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.containsKey(key);
    }
}