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

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.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.Optional;

/**
 * Created by e115731 on 2017/01/03.
 */
public class RedBlackTreeNodeAttribute implements TreeNodeAttributes {

    private final TreeMap<String, ByteBuffer> attrs;
    private final String balanceKey;
    private final ByteBuffer value;
    private final ColorlessTreeNode node;


    public RedBlackTreeNodeAttribute(ColorlessTreeNode node, TreeMap<String, ByteBuffer> attrs, String balanceKey, ByteBuffer value) {
        this.attrs = attrs;
        this.balanceKey = balanceKey;
        this.value = value;
        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);
        }

        TreeMap<String, ByteBuffer> newMap = attrs.delete(key);
        ColorlessTreeNode newNode = node.createNode(newMap, balanceKey, value, node.left(), node.right());
        return DefaultEither.newB(newNode);
    }

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

        TreeMap<String, ByteBuffer> newMap = attrs.put(key, insertValue);
        TreeNode newNode = node.createNode(newMap, balanceKey, value, node.left(), node.right());
        return DefaultEither.newB(newNode);
    }

    @Override
    public ByteBuffer get(String key) {
        if (key == null || balanceKey == null) {
            return null;
        }
        if (key.equals(balanceKey))
            return value;

        Optional<ByteBuffer> op = attrs.get(key);
        if (op.isPresent()) {
            return op.get();
        }
        return null;
    }

    @Override
    public String getString(String key) {
        ByteBuffer value = get(key);
        return new String(value.array());
    }

    @Override
    public Iterator<String> getKeys() {
        return new Iterator<String>() {
            String next = balanceKey;
            Iterator<String> keys = attrs.keys();

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

            @Override
            public String next() {
                String key = next;
                if (keys.hasNext())
                    next = keys.next();
                else
                    next = null;
                return key;
            }
        };
    }

    @Override
    public boolean contain(String key) {
        if (key.equals(balanceKey))
            return true;
        return attrs.contain(key);
    }

    @Override
    public Iterator<String> getFilteringKey(List<String> filter) {
        return new Iterator<String>() {
            Iterator<String> keys = attrs.keys();
            String next = filter.contains(balanceKey) ? init() : balanceKey;

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

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

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

}