/*
 * Copyright 2014 Higher Frequency Trading
 *
 * http://www.higherfrequencytrading.com
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package net.openhft.chronicle.map;

import net.openhft.chronicle.hash.function.SerializableFunction;
import net.openhft.chronicle.map.MapWireHandlerBuilder.Fields;
import net.openhft.chronicle.wire.Marshallable;
import net.openhft.chronicle.wire.Wire;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.IOException;
import java.util.*;
import java.util.function.Consumer;
import java.util.function.Predicate;

import static java.util.Collections.emptyList;
import static net.openhft.chronicle.map.ClientWiredStatelessChronicleMap.EventId.*;


/**
 * @author Rob Austin.
 */
class ClientWiredStatelessChronicleMap<K, V> implements ChronicleMap<K, V>, Cloneable, ChannelFactory {

    private static final Logger LOG = LoggerFactory.getLogger(ClientWiredStatelessChronicleMap.class);

    private final ClientWiredStatelessTcpConnectionHub hub;

    protected Class<K> kClass;
    protected Class<V> vClass;

    private boolean putReturnsNull;
    private boolean removeReturnsNull;
    private short channelID;

    public ClientWiredStatelessChronicleMap(@NotNull final ClientWiredChronicleMapStatelessBuilder config,
                                            @NotNull final Class kClass,
                                            @NotNull final Class vClass,
                                            short channelID) {
        this.channelID = channelID;
        hub = config.hub;
        this.putReturnsNull = config.putReturnsNull();
        this.removeReturnsNull = config.removeReturnsNull();
        this.kClass = kClass;
        this.vClass = vClass;
    }


    @SuppressWarnings("UnusedDeclaration")
    void identifier(int localIdentifier) {
        hub.localIdentifier = localIdentifier;
    }

    @Override
    public void getAll(File toFile) throws IOException {
        JsonSerializer.getAll(toFile, this, emptyList());
    }

    @Override
    public void putAll(File fromFile) throws IOException {
        JsonSerializer.putAll(fromFile, this, emptyList());
    }

    @Override
    public V newValueInstance() {
        return VanillaChronicleMap.newInstance(vClass, false);
    }

    @Override
    public K newKeyInstance() {
        return VanillaChronicleMap.newInstance(kClass, true);
    }

    @Override
    public Class<K> keyClass() {
        return kClass;
    }

    @Override
    public boolean forEachEntryWhile(Predicate<? super MapKeyContext<K, V>> predicate) {
        // TODO implement!
        throw new UnsupportedOperationException();
    }

    @Override
    public void forEachEntry(Consumer<? super MapKeyContext<K, V>> action) {
        // TODO implement!
        throw new UnsupportedOperationException();
    }


    public String serverApplicationVersion() {
        return hub.serverApplicationVersion(channelID);
    }

    @Override
    public void close() {
        // todo add ref count
    }

    @Override
    public Class<V> valueClass() {
        return vClass;
    }


    @NotNull
    public File file() {
        throw new UnsupportedOperationException();
    }

    @SuppressWarnings("NullableProblems")
    public V putIfAbsent(K key, V value) {

        if (key == null || value == null)
            throw new NullPointerException();

        return proxyReturnObject(PUT_IF_ABSENT.toString(), key, value, vClass);
    }

    @SuppressWarnings("NullableProblems")
    public boolean remove(Object key, Object value) {

        if (key == null)
            throw new NullPointerException();

        return value != null && proxyReturnBoolean(REMOVE_WITH_VALUE.toString(), (K) key, (V) value);

    }

    @SuppressWarnings("NullableProblems")
    public boolean replace(K key, V oldValue, V newValue) {
        if (key == null || oldValue == null || newValue == null)
            throw new NullPointerException();
        return proxyReturnBoolean(REPLACE_WITH_OLD_AND_NEW_VALUE.toString(), key, oldValue, newValue);
    }

    @SuppressWarnings("NullableProblems")
    public V replace(K key, V value) {
        if (key == null || value == null)
            throw new NullPointerException();
        return proxyReturnObject(REPLACE.toString(), key, value, vClass);
    }

    public int size() {
        return (int) longSize();
    }

    /**
     * calling this method should be avoided at all cost, as the entire {@code object} is
     * serialized. This equals can be used to compare map that extends ChronicleMap.  So two
     * Chronicle Maps that contain the same data are considered equal, even if the instances of the
     * chronicle maps were of different types
     *
     * @param object the object that you are comparing against
     * @return true if the contain the same data
     */
    @Override
    public boolean equals(@Nullable Object object) {
        if (this == object) return true;
        if (object == null || object.getClass().isAssignableFrom(Map.class))
            return false;

        final Map<? extends K, ? extends V> that = (Map<? extends K, ? extends V>) object;

        final int size = size();

        if (that.size() != size)
            return false;

        final Set<Map.Entry<K, V>> entries = entrySet();
        return that.entrySet().equals(entries);
    }

    @Override
    public int hashCode() {
        return proxyReturnInt(HASH_CODE.toString());
    }

    @NotNull
    public String toString() {
        return toMap().toString();
    }

    @NotNull
    public String serverPersistedDataVersion() {
        return hub.proxyReturnString(PERSISTED_DATA_VERSION.toString(), channelID);
    }

    public boolean isEmpty() {
        return proxyReturnBoolean(IS_EMPTY.toString());
    }

    public boolean containsKey(Object key) {
        return proxyReturnBooleanK(CONTAINS_KEY.toString(), (K) key);
    }

    @NotNull
    private NullPointerException keyNotNullNPE() {
        return new NullPointerException("key can not be null");
    }

    public boolean containsValue(Object value) {
        return proxyReturnBooleanV(CONTAINS_VALUE.toString(), (V) value);
    }

    public long longSize() {
        return proxyReturnLong(LONG_SIZE.toString());
    }

    @Override
    public MapKeyContext<K, V> context(K key) {
        throw new UnsupportedOperationException("Contexts are not supported by stateless clients");
    }

    public V get(Object key) {
        return proxyReturnObject(vClass, GET.toString(), (K) key);
    }

    @Nullable
    public V getUsing(K key, V usingValue) {
        throw new UnsupportedOperationException();
    }

    @NotNull
    public V acquireUsing(@NotNull K key, V usingValue) {
        throw new UnsupportedOperationException(
                "acquireUsing() is not supported for stateless clients");
    }

    @NotNull
    @Override
    public MapKeyContext<K, V> acquireContext(@NotNull K key, @NotNull V usingValue) {
        throw new UnsupportedOperationException("Contexts are not supported by stateless clients");
    }

    public V remove(Object key) {
        if (key == null)
            throw keyNotNullNPE();
        return proxyReturnObject(vClass, removeReturnsNull ? REMOVE_WITHOUT_ACC.toString() : REMOVE.toString(), (K) key);
    }

    @Override
    public void createChannel(short channelID) {
        proxyReturnVoid(
                () -> {
                    writeField(Fields.METHOD_NAME, "CREATE_CHANNEL");
                    hub.outWire().write(Fields.ARG_1).int16(channelID);
                });
    }

    public void putAll(@NotNull Map<? extends K, ? extends V> map) {

        final long startTime = System.currentTimeMillis();
        long transactionId = hub.nextUniqueTransaction(startTime);


        Set<? extends Map.Entry<? extends K, ? extends V>> entries = map.entrySet();
        Iterator<? extends Map.Entry<? extends K, ? extends V>> iterator = entries.iterator();

        boolean hasNext;

        do {

            hasNext = iterator.hasNext();

            hub.outBytesLock().lock();
            try {
                assert hub.outBytesLock().isHeldByCurrentThread();
                assert !hub.inBytesLock().isHeldByCurrentThread();

                Wire wire = hub.outWire();

                assert hub.outBytesLock().isHeldByCurrentThread();
                hub.markSize(wire);
                hub.startTime(startTime);

                wire.write(Fields.TRANSACTION_ID).int64(transactionId);
                wire.write(Fields.TIME_STAMP).int64(startTime);
                wire.write(Fields.CHANNEL_ID).int16(channelID);

                writeField(Fields.METHOD_NAME, "PUT_ALL");

                hub.outWire().write(Fields.HAS_NEXT).bool(hasNext);

                if (hasNext) {
                    Map.Entry<? extends K, ? extends V> e = iterator.next();
                    writeField(Fields.ARG_1, e.getKey());
                    writeField(Fields.ARG_2, e.getValue());
                }

                hub.writeSocket(hub.outWire());

            } finally {
                hub.outBytesLock().unlock();
            }

        } while (hasNext);

        // wait for the transaction id to be received, this will only be received once the
        // last chunk has been processed
        readVoid(transactionId, startTime);
    }


    public V put(K key, V value) {
        if (key == null || value == null)
            throw new NullPointerException();
        return proxyReturnObject(putReturnsNull ? PUT_WITHOUT_ACC.toString() : PUT.toString(), key, value, vClass);
    }

    @Nullable
    public <R> R getMapped(@Nullable K key, @NotNull SerializableFunction<? super V, R> function) {
        throw new UnsupportedOperationException();
    }

    @Nullable
    @Override
    public V putMapped(@Nullable K key, @NotNull UnaryOperator<V> unaryOperator) {
        throw new UnsupportedOperationException();
    }

    public void clear() {
        proxyReturnVoid(() -> writeField(Fields.METHOD_NAME, CLEAR.toString()));
    }


    @NotNull
    public Set<K> keySet() {
        final Set<K> usingCollection = new HashSet<K>();
        readChunked(kClass, "KEY_SET", usingCollection);
        return usingCollection;
    }


    @NotNull
    public Collection<V> values() {
        final List<V> usingCollection = new ArrayList<>();
        return readChunked(vClass, "VALUES", usingCollection);
    }

    private <E, A extends Collection<E>> Collection<E> readChunked(Class<E> vClass1, String values, A usingCollection) {
        final long startTime = System.currentTimeMillis();

        // send
        final long transactionId = proxySend(values, startTime);
        assert !hub.outBytesLock().isHeldByCurrentThread();
        final long timeoutTime = startTime + hub.timeoutMs;

        OUTER:
        for (; ; ) {

            // receive
            hub.inBytesLock().lock();
            try {
                final Wire wireIn = hub.proxyReply(timeoutTime, transactionId);

                while (wireIn.bytes().remaining() > 0) {
                    boolean bool = wireIn.read(Fields.HAS_NEXT).bool();
                    if (bool) {
                        usingCollection.add(readObject(Fields.RESULT, wireIn, null, vClass1));
                    } else
                        break OUTER;

                    // todo process the exception
                    boolean isException = wireIn.read(Fields.IS_EXCEPTION).bool();
                }

            } finally {
                hub.inBytesLock().unlock();
            }
        }
        return usingCollection;
    }

    @NotNull
    public Set<Map.Entry<K, V>> entrySet() {
        return toMap().entrySet();
    }

    private Map<K, V> toMap() {
        final Map<K, V> result = new HashMap<K, V>();
        final long startTime = System.currentTimeMillis();
        // send
        final long transactionId = proxySend("ENTRY_SET", startTime);
        assert !hub.outBytesLock().isHeldByCurrentThread();
        final long timeoutTime = startTime + hub.timeoutMs;

        OUTER:
        for (; ; ) {

            // receive
            hub.inBytesLock().lock();
            try {
                final Wire wireIn = hub.proxyReply(timeoutTime, transactionId);

                while (wireIn.bytes().remaining() > 0) {
                    boolean bool = wireIn.read(Fields.HAS_NEXT).bool();
                    if (bool) {
                        result.put(
                                readK(Fields.RESULT_KEY, wireIn, null),
                                readV(Fields.RESULT_VALUE, wireIn, null));
                    } else
                        break OUTER;


                    if (wireIn.bytes().remaining() > 0) {
                        // todo process the exception
                        boolean isException = wireIn.read(Fields.IS_EXCEPTION).bool();
                    }
                }

            } finally {
                hub.inBytesLock().unlock();
            }
        }
        return result;
    }

    /**
     * @param callback each entry is passed to the callback
     */
    void entrySet(@NotNull MapEntryCallback<K, V> callback) {
        throw new UnsupportedOperationException();
    }


    private long readLong(long transactionId, long startTime) {
        assert !hub.outBytesLock().isHeldByCurrentThread();
        final long timeoutTime = startTime + hub.timeoutMs;

        // receive
        hub.inBytesLock().lock();
        try {
            return hub.proxyReply(timeoutTime, transactionId).read(Fields.RESULT).int64();
        } finally {
            hub.inBytesLock().unlock();
        }
    }


    private void writeField(Fields fieldName, Object value) {
        writeField(fieldName, value, hub.outWire());
    }


    private void writeField(Fields fieldName, Object value, Wire wire) {

        assert hub.outBytesLock().isHeldByCurrentThread();
        assert !hub.inBytesLock().isHeldByCurrentThread();

        if (value instanceof Byte)
            wire.write(fieldName).int8((Byte) value);
        else if (value instanceof Character)
            wire.write(fieldName).text(value.toString());
        else if (value instanceof Short)
            wire.write(fieldName).int16((Short) value);
        else if (value instanceof Integer)
            wire.write(fieldName).int32((Integer) value);
        else if (value instanceof Long)
            wire.write(fieldName).int64((Long) value);
        else if (value instanceof CharSequence) {
            wire.write(fieldName).text((CharSequence) value);
        } else if (value instanceof Marshallable) {
            wire.write(fieldName).marshallable((Marshallable) value);
        } else {
            throw new IllegalStateException("type=" + value.getClass() + " is unsupported, it must either be of type Marshallable or CharSequence");
        }
    }


    private V readValue(Fields argName, long transactionId, long startTime, final V usingValue) {
        assert !hub.outBytesLock().isHeldByCurrentThread();
        long timeoutTime = startTime + hub.timeoutMs;

        hub.inBytesLock().lock();
        try {

            final Wire wireIn = hub.proxyReply(timeoutTime, transactionId);

            if (wireIn.read(Fields.RESULT_IS_NULL).bool())
                return null;

            return readV(argName, wireIn, usingValue);

        } finally {
            hub.inBytesLock().unlock();
        }
    }

    private V readV(Fields argName, Wire wireIn, V usingValue) {
        return readObject(argName, wireIn, usingValue, vClass);
    }

    private K readK(Fields argName, Wire wireIn, K usingValue) {
        return readObject(argName, wireIn, usingValue, kClass);
    }

    private <E> E readObject(Fields argName, Wire wireIn, E usingValue, Class<E> clazz) {
        if (StringBuilder.class.isAssignableFrom(clazz)) {
            wireIn.read(argName).text((StringBuilder) usingValue);
            return usingValue;
        } else if (Marshallable.class.isAssignableFrom(clazz)) {

            if (usingValue == null)
                try {
                    E v = clazz.newInstance();
                    wireIn.read(argName).marshallable((Marshallable) v);
                    return v;
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }

            wireIn.read(argName).marshallable((Marshallable) usingValue);
            return usingValue;

        } else if (String.class.isAssignableFrom(clazz)) {
            //noinspection unchecked
            return (E) wireIn.read(argName).text();

        } else if (Long.class.isAssignableFrom(clazz)) {
            //noinspection unchecked
            return (E) (Long) wireIn.read(argName).int64();
        } else if (Double.class.isAssignableFrom(clazz)) {
            //noinspection unchecked
            return (E) (Double) wireIn.read(argName).float64();

        } else if (Integer.class.isAssignableFrom(clazz)) {
            //noinspection unchecked
            return (E) (Integer) wireIn.read(argName).int32();

        } else if (Float.class.isAssignableFrom(clazz)) {
            //noinspection unchecked
            return (E) (Float) wireIn.read(argName).float32();

        } else if (Short.class.isAssignableFrom(clazz)) {
            //noinspection unchecked
            return (E) (Short) wireIn.read(argName).int16();

        } else if (Character.class.isAssignableFrom(clazz)) {
            //noinspection unchecked
            final String text = wireIn.read(argName).text();
            if (text == null || text.length() == 0)
                return null;
            return (E) (Character) text.charAt(0);

        } else if (Byte.class.isAssignableFrom(clazz)) {
            //noinspection unchecked
            return (E) (Byte) wireIn.read(argName).int8();


        } else {
            throw new IllegalStateException("unsupported type");
        }
    }


    private boolean readBoolean(long transactionId, long startTime) {
        assert !hub.outBytesLock().isHeldByCurrentThread();

        long timeoutTime = startTime + hub.timeoutMs;

        // receive
        hub.inBytesLock().lock();
        try {
            final Wire wireIn = hub.proxyReply(timeoutTime, transactionId);
            return wireIn.read(Fields.RESULT).bool();
        } finally {
            hub.inBytesLock().unlock();
        }
    }

    private int readInt(long transactionId, long startTime) {
        assert !hub.outBytesLock().isHeldByCurrentThread();

        long timeoutTime = startTime + hub.timeoutMs;

        // receive
        hub.inBytesLock().lock();
        try {
            final Wire wireIn = hub.proxyReply(timeoutTime, transactionId);
            return wireIn.read(Fields.RESULT).int32();
        } finally {
            hub.inBytesLock().unlock();
        }
    }

    @SuppressWarnings("SameParameterValue")
    private boolean proxyReturnBoolean(@NotNull final String methodName, K key, V value) {
        final long startTime = System.currentTimeMillis();

        long transactionId;

        hub.outBytesLock().lock();
        try {
            transactionId = hub.writeHeader(startTime, channelID, hub.outWire());
            writeField(Fields.METHOD_NAME, methodName);
            writeField(Fields.ARG_1, key);
            writeField(Fields.ARG_2, value);

            hub.writeSocket(hub.outWire());
        } finally {
            hub.outBytesLock().unlock();
        }

        return readBoolean(transactionId, startTime);

    }

    @SuppressWarnings("SameParameterValue")
    private boolean proxyReturnBoolean(@NotNull final String methodName, K key, V value1, V value2) {
        final long startTime = System.currentTimeMillis();

        long transactionId;
        hub.outBytesLock().lock();
        try {
            transactionId = hub.writeHeader(startTime, channelID, hub.outWire());
            writeField(Fields.METHOD_NAME, methodName);
            writeField(Fields.ARG_1, key);
            writeField(Fields.ARG_2, value1);
            writeField(Fields.ARG_3, value2);
            hub.writeSocket(hub.outWire());
        } finally {
            hub.outBytesLock().unlock();
        }

        return readBoolean(transactionId, startTime);

    }

    @SuppressWarnings("SameParameterValue")
    private boolean proxyReturnBooleanV(@NotNull final String methodName, V value) {
        final long startTime = System.currentTimeMillis();
        return readBoolean(proxySend(methodName, startTime, value), startTime);
    }

    @SuppressWarnings("SameParameterValue")
    private boolean proxyReturnBooleanK(@NotNull final String methodName, K key) {
        final long startTime = System.currentTimeMillis();

        return readBoolean(proxySend(methodName, startTime, key), startTime);
    }

    @SuppressWarnings("SameParameterValue")
    private long proxyReturnLong(@NotNull final String methodName) {
        final long startTime = System.currentTimeMillis();

        long transactionId;

        hub.outBytesLock().lock();
        try {
            transactionId = hub.writeHeader(startTime, channelID, hub.outWire());
            writeField(Fields.METHOD_NAME, methodName);
            hub.writeSocket(hub.outWire());
        } finally {
            hub.outBytesLock().unlock();
        }

        return readLong(transactionId, startTime);
    }

    @SuppressWarnings("SameParameterValue")
    private boolean proxyReturnBoolean(@NotNull final String methodName) {
        final long startTime = System.currentTimeMillis();

        long transactionId;

        hub.outBytesLock().lock();
        try {
            transactionId = hub.writeHeader(startTime, channelID, hub.outWire());
            writeField(Fields.METHOD_NAME, methodName);
            hub.writeSocket(hub.outWire());
        } finally {
            hub.outBytesLock().unlock();
        }

        return readBoolean(transactionId, startTime);
    }

    @SuppressWarnings("SameParameterValue")
    private void proxyReturnVoid(Runnable r) {


        final long startTime = System.currentTimeMillis();
        long transactionId;

        hub.outBytesLock().lock();
        try {
            transactionId = hub.writeHeader(startTime, channelID, hub.outWire());
            r.run();
            hub.writeSocket(hub.outWire());
        } finally {
            hub.outBytesLock().unlock();
        }

        readVoid(transactionId, startTime);
    }


    @SuppressWarnings("SameParameterValue")
    private int proxyReturnInt(@NotNull final String methodName) {
        final long startTime = System.currentTimeMillis();

        long transactionId;

        hub.outBytesLock().lock();
        try {
            transactionId = hub.writeHeader(startTime, channelID, hub.outWire());
            writeField(Fields.METHOD_NAME, methodName);
            hub.writeSocket(hub.outWire());
        } finally {
            hub.outBytesLock().unlock();
        }

        return readInt(transactionId, startTime);
    }


    @Nullable
    private <R> R proxyReturnObject(@NotNull final String methodName, K key, V value, Class<V> resultType) {

        final long startTime = System.currentTimeMillis();
        long transactionId;

        hub.outBytesLock().lock();
        try {
            assert hub.outBytesLock().isHeldByCurrentThread();
            assert !hub.inBytesLock().isHeldByCurrentThread();

            transactionId = hub.writeHeader(startTime, channelID, hub.outWire());
            writeField(Fields.METHOD_NAME, methodName);
            writeField(Fields.ARG_1, key);
            writeField(Fields.ARG_2, value);
            hub.writeSocket(hub.outWire());

        } finally {
            hub.outBytesLock().unlock();
        }

        if (eventReturnsNull(methodName))
            return null;

        if (resultType == vClass)
            return (R) readValue(Fields.RESULT, transactionId, startTime, null);

        else
            throw new UnsupportedOperationException("class of type class=" + resultType + " is not " +
                    "supported");
    }

    @Nullable
    private <R> R proxyReturnObject(Class<R> rClass, @NotNull final String methodName, Object key) {
        final long startTime = System.currentTimeMillis();

        long transactionId;

        transactionId = proxySend(methodName, startTime, key);

        if (eventReturnsNull(methodName))
            return null;

        if (rClass == vClass)
            return (R) readValue(Fields.RESULT, transactionId, startTime, null);
        else
            throw new UnsupportedOperationException("class of type class=" + rClass + " is not " +
                    "supported");
    }

    private long proxySend(String methodName, long startTime, Object arg1) {
        long transactionId;
        hub.outBytesLock().lock();
        try {
            transactionId = hub.writeHeader(startTime, channelID, hub.outWire());
            writeField(Fields.METHOD_NAME, methodName);
            writeField(Fields.ARG_1, arg1);
            hub.writeSocket(hub.outWire());
        } finally {
            hub.outBytesLock().unlock();
        }
        return transactionId;
    }


    private long proxySend(String methodName, long startTime) {
        long transactionId;
        hub.outBytesLock().lock();
        try {
            transactionId = hub.writeHeader(startTime, channelID, hub.outWire());
            writeField(Fields.METHOD_NAME, methodName);
            hub.writeSocket(hub.outWire());
        } finally {
            hub.outBytesLock().unlock();
        }
        return transactionId;
    }

    private boolean eventReturnsNull(@NotNull String methodName) {

        switch (methodName) {
            case "PUT_ALL_WITHOUT_ACC":
            case "PUT_WITHOUT_ACC":
            case "REMOVE_WITHOUT_ACC":
                return true;
            default:
                return false;
        }

    }

    private void readVoid(long transactionId, long startTime) {
        long timeoutTime = startTime + hub.timeoutMs;

        // receive
        hub.inBytesLock().lock();
        try {
            hub.proxyReply(timeoutTime, transactionId);
        } finally {
            hub.inBytesLock().unlock();
        }
    }


    static enum EventId {
        HEARTBEAT,
        STATEFUL_UPDATE,
        LONG_SIZE,
        SIZE,
        IS_EMPTY,
        CONTAINS_KEY,
        CONTAINS_VALUE,
        GET,
        PUT,
        PUT_WITHOUT_ACC,
        REMOVE,
        REMOVE_WITHOUT_ACC,
        CLEAR,
        KEY_SET,
        VALUES,
        ENTRY_SET,
        REPLACE,
        REPLACE_WITH_OLD_AND_NEW_VALUE,
        PUT_IF_ABSENT,
        REMOVE_WITH_VALUE,
        TO_STRING,
        APPLICATION_VERSION,
        PERSISTED_DATA_VERSION,
        PUT_ALL,
        PUT_ALL_WITHOUT_ACC,
        HASH_CODE,
        MAP_FOR_KEY,
        PUT_MAPPED,
        KEY_BUILDER,
        VALUE_BUILDER
    }

    class Entry implements Map.Entry<K, V> {

        final K key;
        final V value;

        /**
         * Creates new entry.
         */
        Entry(K k1, V v) {
            value = v;
            key = k1;
        }

        public final K getKey() {
            return key;
        }

        public final V getValue() {
            return value;
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            ClientWiredStatelessChronicleMap.this.put(getKey(), newValue);
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            final Map.Entry e = (Map.Entry) o;
            final Object k1 = getKey();
            final Object k2 = e.getKey();
            if (k1 == k2 || (k1 != null && k1.equals(k2))) {
                Object v1 = getValue();
                Object v2 = e.getValue();
                if (v1 == v2 || (v1 != null && v1.equals(v2)))
                    return true;
            }
            return false;
        }

        public final int hashCode() {
            return (key == null ? 0 : key.hashCode()) ^
                    (value == null ? 0 : value.hashCode());
        }

        @NotNull
        public final String toString() {
            return getKey() + "=" + getValue();
        }
    }
}