package org.infinispan.server.hotrod;

import static org.infinispan.server.hotrod.transport.ExtendedByteBuf.readMaybeByte;
import static org.infinispan.server.hotrod.transport.ExtendedByteBuf.readMaybeLong;
import static org.infinispan.server.hotrod.transport.ExtendedByteBuf.readMaybeRangedBytes;
import static org.infinispan.server.hotrod.transport.ExtendedByteBuf.readMaybeString;
import static org.infinispan.server.hotrod.transport.ExtendedByteBuf.readMaybeVInt;

import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;

import org.infinispan.AdvancedCache;
import org.infinispan.commons.logging.LogFactory;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.container.entries.CacheEntry;
import org.infinispan.container.versioning.NumericVersion;
import org.infinispan.context.Flag;
import org.infinispan.server.core.ServerConstants;
import org.infinispan.server.core.transport.NettyTransport;
import org.infinispan.server.hotrod.logging.Log;
import org.infinispan.stats.Stats;
import org.infinispan.util.concurrent.TimeoutException;

import io.netty.buffer.ByteBuf;

;

/**
 * HotRod protocol decoder specific for specification version 1.0.
 *
 * @author Galder Zamarreño
 * @since 4.1
 */
public class Decoder10 implements VersionedDecoder {
   private final static Log log = LogFactory.getLog(Decoder10.class, Log.class);
   private final static boolean isTrace = log.isTraceEnabled();

   @Override
   public boolean readHeader(ByteBuf buffer, byte version, long messageId, HotRodHeader header) throws Exception {
      if (header.op == null) {
         Optional<Byte> maybeByte = readMaybeByte(buffer);
         if (!maybeByte.flatMap(streamOp -> readMaybeString(buffer).map(cacheName -> {
            header.op = HotRodOperation.fromRequestOpCode(streamOp);
            if (isTrace) log.tracef("Operation code: %d has been matched to %s", streamOp, header.op);
            header.cacheName = cacheName;
            buffer.markReaderIndex();
            return streamOp;
         })).isPresent()) {
            return false;
         } else if (header.op == null) {
            throw new HotRodUnknownOperationException("Unknown operation: " + maybeByte.get(), version, messageId);
         }
      }

      return readMaybeVInt(buffer).flatMap(flag -> readMaybeByte(buffer).flatMap(clientIntelligence ->
            readMaybeVInt(buffer).flatMap(topologyId -> readMaybeByte(buffer).map(txId -> {
               if (txId != 0) {
                  throw new UnsupportedOperationException("Transaction types other than 0 (NO_TX) is not supported " +
                        "at this stage.  Saw TX_ID of " + txId);
               }
               header.flag = flag;
               header.clientIntel = clientIntelligence;
               header.topologyId = topologyId;
               buffer.markReaderIndex();
               return txId;
            })))).isPresent();
   }

   @Override
   public CacheDecodeContext.RequestParameters readParameters(HotRodHeader header, ByteBuf buffer) {
      switch (header.op) {
         case REMOVE_IF_UNMODIFIED:
            return readMaybeLong(buffer).map(l -> new CacheDecodeContext.RequestParameters(-1,
                  new CacheDecodeContext.ExpirationParam(-1, TimeUnitValue.SECONDS),
                  new CacheDecodeContext.ExpirationParam(-1, TimeUnitValue.SECONDS), l)
            ).orElse(null);
         case REPLACE_IF_UNMODIFIED:
            return readLifespanOrMaxIdle(buffer, hasFlag(header, ProtocolFlag.DefaultLifespan)).flatMap(lifespan ->
                  readLifespanOrMaxIdle(buffer, hasFlag(header, ProtocolFlag.DefaultMaxIdle)).flatMap(maxIdle ->
                        readMaybeLong(buffer).flatMap(version -> readMaybeVInt(buffer).map(valueLength ->
                              new CacheDecodeContext.RequestParameters(valueLength,
                                    new CacheDecodeContext.ExpirationParam(lifespan, TimeUnitValue.SECONDS),
                                    new CacheDecodeContext.ExpirationParam(maxIdle, TimeUnitValue.SECONDS), version)
                        ))
                  )
            ).orElse(null);
         default:
            return readLifespanOrMaxIdle(buffer, hasFlag(header, ProtocolFlag.DefaultLifespan)).flatMap(lifespan ->
                  readLifespanOrMaxIdle(buffer, hasFlag(header, ProtocolFlag.DefaultMaxIdle)).flatMap(maxIdle ->
                        readMaybeVInt(buffer).map(valueLength ->
                              new CacheDecodeContext.RequestParameters(valueLength,
                                    new CacheDecodeContext.ExpirationParam(lifespan, TimeUnitValue.SECONDS),
                                    new CacheDecodeContext.ExpirationParam(maxIdle, TimeUnitValue.SECONDS), -1)
                        )
                  )
            ).orElse(null);
      }
   }

   private boolean hasFlag(HotRodHeader h, ProtocolFlag f) {
      return (h.flag & f.getValue()) == f.getValue();
   }

   private Optional<Integer> readLifespanOrMaxIdle(ByteBuf buffer, boolean useDefault) {
      return readMaybeVInt(buffer).map(stream -> {
         if (stream <= 0) {
            if (useDefault)
               return ServerConstants.EXPIRATION_DEFAULT;
            else
               return ServerConstants.EXPIRATION_NONE;
         } else return stream;
      });
   }

   @Override
   public Response createSuccessResponse(HotRodHeader header, byte[] prev) {
      return createResponse(header, OperationStatus.Success, prev);
   }

   @Override
   public Response createNotExecutedResponse(HotRodHeader header, byte[] prev) {
      return createResponse(header, OperationStatus.OperationNotExecuted, prev);
   }

   @Override
   public Response createNotExistResponse(HotRodHeader header) {
      return createResponse(header, OperationStatus.KeyDoesNotExist, null);
   }

   private Response createResponse(HotRodHeader h, OperationStatus st, byte[] prev) {
      if (hasFlag(h, ProtocolFlag.ForceReturnPreviousValue))
         return new ResponseWithPrevious(h.version, h.messageId, h.cacheName,
               h.clientIntel, h.op, st, h.topologyId, Optional.ofNullable(prev));
      else
         return new EmptyResponse(h.version, h.messageId, h.cacheName, h.clientIntel, h.op, st, h.topologyId);
   }

   @Override
   public Response createGetResponse(HotRodHeader h, CacheEntry<byte[], byte[]> entry) {
      HotRodOperation op = h.op;
      if (entry != null && op == HotRodOperation.GET)
         return new GetResponse(h.version, h.messageId, h.cacheName, h.clientIntel,
               op, OperationStatus.Success, h.topologyId,
               entry.getValue());
      else if (entry != null && op == HotRodOperation.GET_WITH_VERSION) {
         long version = ((NumericVersion) entry.getMetadata().version()).getVersion();
         return new GetWithVersionResponse(h.version, h.messageId, h.cacheName,
               h.clientIntel, op, OperationStatus.Success, h.topologyId,
               entry.getValue(), version);
      } else if (op == HotRodOperation.GET)
         return new GetResponse(h.version, h.messageId, h.cacheName, h.clientIntel,
               op, OperationStatus.KeyDoesNotExist, h.topologyId, null);
      else
         return new GetWithVersionResponse(h.version, h.messageId, h.cacheName,
               h.clientIntel, op, OperationStatus.KeyDoesNotExist,
               h.topologyId, null, 0);
   }

   @Override
   public void customReadHeader(HotRodHeader header, ByteBuf buffer, CacheDecodeContext hrCtx, List<Object> out) {
      // Do nothing
   }

   @Override
   public void customReadKey(HotRodHeader h, ByteBuf buffer, CacheDecodeContext hrCtx, List<Object> out) {
      switch (h.op) {
         case BULK_GET:
         case BULK_GET_KEYS:
            Optional<Integer> number = readMaybeVInt(buffer);
            number.ifPresent(n -> {
               hrCtx.operationDecodeContext = n;
               buffer.markReaderIndex();
               out.add(hrCtx);
            });
            break;
         case QUERY:
            Optional<byte[]> bytes = readMaybeRangedBytes(buffer);
            bytes.ifPresent(b -> {
               hrCtx.operationDecodeContext = b;
               buffer.markReaderIndex();
               out.add(hrCtx);
            });
            break;
      }
   }

   @Override
   public void customReadValue(HotRodHeader header, ByteBuf buffer, CacheDecodeContext hrCtx, List<Object> out) {
      // Do nothing
   }

   @Override
   public StatsResponse createStatsResponse(CacheDecodeContext hrCtx, NettyTransport t) {
      HotRodHeader h = hrCtx.header;
      Stats cacheStats = hrCtx.cache.getStats();
      Map<String, String> stats = new HashMap<>();
      stats.put("timeSinceStart", String.valueOf(cacheStats.getTimeSinceStart()));
      stats.put("currentNumberOfEntries", String.valueOf(cacheStats.getCurrentNumberOfEntries()));
      stats.put("totalNumberOfEntries", String.valueOf(cacheStats.getTotalNumberOfEntries()));
      stats.put("stores", String.valueOf(cacheStats.getStores()));
      stats.put("retrievals", String.valueOf(cacheStats.getRetrievals()));
      stats.put("hits", String.valueOf(cacheStats.getHits()));
      stats.put("misses", String.valueOf(cacheStats.getMisses()));
      stats.put("removeHits", String.valueOf(cacheStats.getRemoveHits()));
      stats.put("removeMisses", String.valueOf(cacheStats.getRemoveMisses()));
      stats.put("totalBytesRead", t.getTotalBytesRead());
      stats.put("totalBytesWritten", t.getTotalBytesWritten());
      return new StatsResponse(h.version, h.messageId, h.cacheName, h.clientIntel, stats, h.topologyId);
   }

   @Override
   public ErrorResponse createErrorResponse(HotRodHeader header, Throwable t) {
      if (t instanceof IOException) {
         return new ErrorResponse(header.version, header.messageId, header.cacheName, header.clientIntel,
               OperationStatus.ParseError, header.topologyId, t.toString());
      } else if (t instanceof TimeoutException) {
         return new ErrorResponse(header.version, header.messageId, header.cacheName, header.clientIntel,
               OperationStatus.OperationTimedOut, header.topologyId, t.toString());
      } else {
         return new ErrorResponse(header.version, header.messageId, header.cacheName, header.clientIntel,
               OperationStatus.ServerError, header.topologyId, t.toString());
      }
   }

   @Override
   public AdvancedCache<byte[], byte[]> getOptimizedCache(HotRodHeader h, AdvancedCache<byte[], byte[]> c, Configuration cacheCfg) {
      if (!hasFlag(h, ProtocolFlag.ForceReturnPreviousValue)) {
         switch (h.op) {
            case PUT:
            case PUT_IF_ABSENT:
               return c.withFlags(Flag.IGNORE_RETURN_VALUES);
         }
      }
      return c;
   }
}
