/*
 * Copyright 2016-present Open Networking Laboratory
 *
 * 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 org.onosproject.store.primitives.resources.impl;

import com.google.common.base.MoreObjects;
import io.atomix.catalyst.buffer.BufferInput;
import io.atomix.catalyst.buffer.BufferOutput;
import io.atomix.catalyst.serializer.CatalystSerializable;
import io.atomix.catalyst.serializer.SerializableTypeResolver;
import io.atomix.catalyst.serializer.Serializer;
import io.atomix.catalyst.serializer.SerializerRegistry;
import io.atomix.catalyst.util.Assert;
import io.atomix.copycat.Command;
import io.atomix.copycat.Query;
import org.onlab.util.Match;
import org.onosproject.store.service.Versioned;

import java.util.Collection;
import java.util.Map;
import java.util.NavigableMap;
import java.util.NavigableSet;
import java.util.Set;

/**
 * {@link org.onosproject.store.service.AsyncConsistentTreeMap} Resource
 * state machine operations.
 */
public final class AtomixConsistentTreeMapCommands {

    private AtomixConsistentTreeMapCommands() {
    }

    /**
     * Abstract treeMap command.
     */
    @SuppressWarnings("serial")
    public abstract static class TreeCommand<V>
            implements Command<V>, CatalystSerializable {

        @Override
        public String toString() {
            return MoreObjects.toStringHelper(getClass())
                    .toString();
        }

        @Override
        public void writeObject(BufferOutput<?> buffer,
                                Serializer serializer) {
        }

        @Override
        public void readObject(BufferInput<?> buffer, Serializer serializer) {
        }
    }

    /**
     * Abstract treeMap query.
     */
    @SuppressWarnings("serial")
    public abstract static class TreeQuery<V>
            implements Query<V>, CatalystSerializable {
        @Override
        public ConsistencyLevel consistency() {
            return ConsistencyLevel.LINEARIZABLE_LEASE;
        }

        @Override
        public String toString() {
            return MoreObjects.toStringHelper(getClass())
                    .toString();
        }

        @Override
        public void writeObject(BufferOutput<?> bufferOutput,
                                Serializer serializer) {

        }

        @Override
        public void readObject(BufferInput<?> bufferInput,
                               Serializer serializer) {

        }
    }
    /**
     * Abstract key-based query.
     */
    @SuppressWarnings("serial")
    public abstract static class KeyQuery<K> extends TreeQuery<K> {
        protected String key;

        public KeyQuery(String key) {
            this.key = Assert.notNull(key, "key");
        }

        public KeyQuery() {
        }

        public String key() {
            return key;
        }

        @Override
        public String toString() {
            return MoreObjects.toStringHelper(getClass())
                    .add("key", key)
                    .toString();
        }

        @Override
        public void writeObject(BufferOutput<?> bufferOutput,
                                Serializer serializer) {
            super.writeObject(bufferOutput, serializer);
            serializer.writeObject(key, bufferOutput);
        }

        @Override
        public void readObject(BufferInput<?> bufferInput,
                               Serializer serializer) {
            super.readObject(bufferInput, serializer);
            key = serializer.readObject(bufferInput);
        }
    }

    /**
     * Abstract value-based query.
     */
    @SuppressWarnings("serial")
    public abstract static class ValueQuery<V> extends TreeQuery<V> {
        protected byte[] value;

        public ValueQuery() {}

        public ValueQuery(byte[] value) {
            this.value = Assert.notNull(value, "value");
        }

        public byte[] value() {
            return value;
        }

        @Override
        public void writeObject(BufferOutput<?> bufferOutput,
                                Serializer serializer) {
            super.writeObject(bufferOutput, serializer);
            serializer.writeObject(value, bufferOutput);
        }

        @Override
        public void readObject(BufferInput<?> bufferInput,
                               Serializer serializer) {
            super.readObject(bufferInput, serializer);
            value = serializer.readObject(bufferInput);
        }

        @Override
        public String toString() {
            return MoreObjects.toStringHelper(getClass())
                    .add("value", value)
                    .toString();
        }
    }

    /**
     * Contains key command.
     */
    @SuppressWarnings("serial")
    public static class ContainsKey extends KeyQuery<Boolean> {

        public ContainsKey(String key) {
            super(key);
        }

        public ContainsKey() {
        }
    }
    /**
     * Contains value command.
     */
    @SuppressWarnings("serial")
    public static class ContainsValue extends ValueQuery<Boolean> {
        public ContainsValue() {
        }

        public ContainsValue(byte[] value) {
            super(value);
        }

    }

    /**
     * AsyncConsistentTreeMap update command.
     */
    @SuppressWarnings("serial")
    public static class UpdateAndGet
            extends TreeCommand<MapEntryUpdateResult<String, byte[]>> {
        private String key;
        private byte[] value;
        private Match<byte[]> valueMatch;
        private Match<Long> versionMatch;
        public UpdateAndGet() {
        }

        public UpdateAndGet(String key,
                            byte[] value,
                            Match<byte[]> valueMatch,
                            Match<Long> versionMatch) {
            this.key = key;
            this.value = value;
            this.valueMatch = valueMatch;
            this.versionMatch = versionMatch;
        }

        public String key() {
            return this.key;
        }

        public byte[] value() {
            return this.value;
        }

        public Match<byte[]> valueMatch() {
            return this.valueMatch;
        }

        public Match<Long> versionMatch() {
            return this.versionMatch;
        }

        @Override
        public CompactionMode compaction() {
            return value == null ? CompactionMode.FULL : CompactionMode.QUORUM;
        }

        @Override
        public void writeObject(BufferOutput<?> buffer,
                                Serializer serializer) {
            super.writeObject(buffer, serializer);
            serializer.writeObject(key, buffer);
            serializer.writeObject(value, buffer);
            serializer.writeObject(valueMatch, buffer);
            serializer.writeObject(versionMatch, buffer);
        }

        @Override
        public void readObject(BufferInput<?> buffer, Serializer serializer) {
            super.readObject(buffer, serializer);
            key = serializer.readObject(buffer);
            value = serializer.readObject(buffer);
            valueMatch = serializer.readObject(buffer);
            versionMatch = serializer.readObject(buffer);
        }

        @Override
        public String toString() {
            return MoreObjects.toStringHelper(getClass())
                    .add("key", key)
                    .add("value", value)
                    .add("valueMatch", valueMatch)
                    .add("versionMatch", versionMatch)
                    .toString();
        }
    }

    /**
     * Get query command.
     */
    @SuppressWarnings("serial")
    public static class Get extends KeyQuery<Versioned<byte[]>> {
        public Get() {
        }

        public Get(String key) {
            super(key);
        }
    }

    /**
     * Is empty query.
     */
    @SuppressWarnings("serial")
    public static class IsEmpty extends TreeQuery<Boolean> {

    }

    /**
     * Key set query.
     */
    @SuppressWarnings("serial")
    public static class KeySet extends TreeQuery<Set<String>> {
    }

    /**
     * Value set query.
     */
    @SuppressWarnings("serial")
    public static class Values
            extends TreeQuery<Collection<Versioned<byte[]>>> {
    }

    /**
     * Entry set query.
     */
    @SuppressWarnings("serial")
    public static class EntrySet
            extends TreeQuery<Set<Map.Entry<String, Versioned<byte[]>>>> {
    }

    /**
     * Size query.
     */
    @SuppressWarnings("serial")
    public static class Size extends TreeQuery<Integer> {
    }

    /**
     * Clear command.
     */
    @SuppressWarnings("serial")
    public static class Clear
            extends TreeCommand<MapEntryUpdateResult.Status> {
        @Override
        public CompactionMode compaction() {
            return CompactionMode.FULL;
        }
    }

    /**
     * Change listen.
     */
    @SuppressWarnings("serial")
    public static class Listen implements Command<Void>, CatalystSerializable {
        @Override
        public void writeObject(BufferOutput<?> buffer,
                                Serializer serializer) {
        }

        @Override
        public void readObject(BufferInput<?> buffer, Serializer serializer) {
        }

        @Override
        public String toString() {
            return MoreObjects.toStringHelper(getClass())
                    .toString();
        }
    }

    /**
     * Change unlisten.
     */
    @SuppressWarnings("serial")
    public static class Unlisten implements Command<Void>,
            CatalystSerializable {
        @Override
        public void writeObject(BufferOutput<?> buffer,
                                Serializer serializer) {
        }

        @Override
        public void readObject(BufferInput<?> buffer, Serializer serializer) {
        }

        @Override
        public String toString() {
            return MoreObjects.toStringHelper(getClass())
                    .toString();
        }
    }

        /* Tree map specific commands below */

    /**
     * First key query.
     */
    @SuppressWarnings("serial")
    public static class FirstKey<K> extends TreeQuery<K> {
    }

    /**
     * Last key query.
     */
    @SuppressWarnings("serial")
    public static class LastKey<K> extends TreeQuery<K> {
    }

    /**
     * First entry query.
     */
    @SuppressWarnings("serial")
    public static class FirstEntry<K, V> extends TreeQuery<Map.Entry<K, V>> {
    }

    /**
     * Last entry query.
     */
    @SuppressWarnings("serial")
    public static class LastEntry<K, V> extends TreeQuery<Map.Entry<K, V>> {
    }

    /**
     * First entry query, if none exists returns null.
     */
    @SuppressWarnings("serial")
    public static class PollFirstEntry<K, V>
            extends TreeQuery<Map.Entry<K, V>> {
    }

    /**
     * Last entry query, if none exists returns null.
     */
    @SuppressWarnings("serial")
    public static class PollLastEntry<K, V>
            extends TreeQuery<Map.Entry<K, V>> {
    }

    /**
     * Query returns the entry associated with the largest key less than the
     * passed in key.
     */
    @SuppressWarnings("serial")
    public static class LowerEntry<K, V> extends KeyQuery<K> {
        public LowerEntry() {
        }

        public LowerEntry(String key) {
            super(key);
        }
    }

    /**
     * Query returns the largest key less than the specified key.
     */
    @SuppressWarnings("serial")
    public static class LowerKey<K> extends KeyQuery<K> {
        public LowerKey() {
        }

        public LowerKey(String key) {
            super(key);
        }
    }

    /**
     * Query returns the entry associated with the largest key smaller than or
     * equal to the specified key.
     */
    @SuppressWarnings("serial")
    public static class FloorEntry<K, V> extends KeyQuery<Map.Entry<K, V>> {
        public FloorEntry() {
        }

        public FloorEntry(String key) {
            super(key);
        }
    }

    /**
     * Query returns the largest key smaller than or equal to the passed in
     * key.
     */
    @SuppressWarnings("serial")
    public static class FloorKey<K> extends KeyQuery<K> {
        public FloorKey() {
        }

        public FloorKey(String key) {
            super(key);
        }
    }

    /**
     * Returns the entry associated with the smallest key larger than or equal
     * to the specified key.
     */
    @SuppressWarnings("serial")
    public static class CeilingEntry<K, V> extends KeyQuery<Map.Entry<K, V>> {
        public CeilingEntry() {
        }

        public CeilingEntry(String key) {
            super(key);
        }
    }

    /**
     * Returns the smallest key larger than or equal to the specified key.
     * @param <K>
     */
    @SuppressWarnings("serial")
    public static class CeilingKey<K> extends KeyQuery<K> {
        public CeilingKey() {
        }

        public CeilingKey(String key) {
            super(key);
        }
    }

    /**
     * Returns the entry associated with the smallest key larger than the
     * specified key.
     */
    @SuppressWarnings("serial")
    public static class HigherEntry<K, V> extends KeyQuery<Map.Entry<K, V>> {
        public HigherEntry() {
        }

        public HigherEntry(String key) {
            super(key);
        }
    }

    /**
     * Returns the smallest key larger than the specified key.
     */
    @SuppressWarnings("serial")
    public static class HigherKey<K> extends KeyQuery<K> {
        public HigherKey() {
        }

        public HigherKey(String key) {
            super(key);
        }
    }

    @SuppressWarnings("serial")
    public static class NavigableKeySet<K, V>
            extends TreeQuery<NavigableSet<K>> {
    }

    @SuppressWarnings("serial")
    public static class SubMap<K, V> extends TreeQuery<NavigableMap<K, V>> {
        private K fromKey;
        private K toKey;
        private boolean inclusiveFrom;
        private boolean inclusiveTo;

        public SubMap() {
        }

        public SubMap(K fromKey, K toKey, boolean inclusiveFrom,
                      boolean inclusiveTo) {
            this.fromKey = fromKey;
            this.toKey = toKey;
            this.inclusiveFrom = inclusiveFrom;
            this.inclusiveTo = inclusiveTo;
        }

        @Override
        public String toString() {
            return MoreObjects.toStringHelper(getClass())
                    .add("getFromKey", fromKey)
                    .add("getToKey", toKey)
                    .add("inclusiveFrotBound", inclusiveFrom)
                    .add("inclusiveToBound", inclusiveTo)
                    .toString();
        }

        @Override
        public void writeObject(BufferOutput<?> bufferOutput,
                                Serializer serializer) {
            super.writeObject(bufferOutput, serializer);
            serializer.writeObject(fromKey, bufferOutput);
            serializer.writeObject(toKey, bufferOutput);
            serializer.writeObject(inclusiveFrom, bufferOutput);
            serializer.writeObject(inclusiveTo, bufferOutput);
        }

        @Override
        public void readObject(BufferInput<?> bufferInput,
                               Serializer serializer) {
            super.readObject(bufferInput, serializer);
            fromKey = serializer.readObject(bufferInput);
            toKey = serializer.readObject(bufferInput);
            inclusiveFrom = serializer.readObject(bufferInput);
            inclusiveTo = serializer.readObject(bufferInput);
        }

        public K fromKey() {
            return fromKey;
        }

        public K toKey() {
            return toKey;
        }

        public boolean isInclusiveFrom() {
            return inclusiveFrom;
        }

        public boolean isInclusiveTo() {
            return inclusiveTo;
        }
    }

    /**
     * Tree map command type resolver.
     */
    public static class TypeResolver implements SerializableTypeResolver {
        @Override
        public void resolve(SerializerRegistry registry) {
            //NOTE the registration values must be unique throughout the
            // project.
            registry.register(ContainsKey.class, -1161);
            registry.register(ContainsValue.class, -1162);
            registry.register(Get.class, -1163);
            registry.register(EntrySet.class, -1164);
            registry.register(Values.class, -1165);
            registry.register(KeySet.class, -1166);
            registry.register(Clear.class, -1167);
            registry.register(IsEmpty.class, -1168);
            registry.register(Size.class, -1169);
            registry.register(Listen.class, -1170);
            registry.register(Unlisten.class, -1171);
            //Transaction related commands will be added here with numbers
            // -1172 to -1174
            registry.register(UpdateAndGet.class, -1175);
            registry.register(FirstKey.class, -1176);
            registry.register(LastKey.class, -1177);
            registry.register(FirstEntry.class, -1178);
            registry.register(LastEntry.class, -1179);
            registry.register(PollFirstEntry.class, -1180);
            registry.register(PollLastEntry.class, -1181);
            registry.register(LowerEntry.class, -1182);
            registry.register(LowerKey.class, -1183);
            registry.register(FloorEntry.class, -1184);
            registry.register(FloorKey.class, -1185);
            registry.register(CeilingEntry.class, -1186);
            registry.register(CeilingKey.class, -1187);
            registry.register(HigherEntry.class, -1188);
            registry.register(HigherKey.class, -1189);
            registry.register(SubMap.class, -1190);
            registry.register(NavigableKeySet.class, -1191);
        }
    }
}