/*
    * Copyright 2013 The Netty Project
    *
    * The Netty Project licenses this file to you 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:
    *
    *   https://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 io.netty.handler.codec.memcache.binary;
  
  import io.netty.buffer.ByteBuf;
  import io.netty.handler.codec.memcache.AbstractMemcacheObject;
  import io.netty.util.internal.ObjectUtil;
  import io.netty.util.internal.UnstableApi;
  
  /**
   * Default implementation of a {@link BinaryMemcacheMessage}.
   */
  @UnstableApi
  public abstract class AbstractBinaryMemcacheMessage
      extends AbstractMemcacheObject
      implements BinaryMemcacheMessage {
  
      /**
       * Contains the optional key.
       */
      private ByteBuf key;
  
      /**
       * Contains the optional extras.
       */
      private ByteBuf extras;
  
      private byte magic;
      private byte opcode;
      private short keyLength;
      private byte extrasLength;
      private byte dataType;
      private int totalBodyLength;
      private int opaque;
      private long cas;
  
      /**
       * Create a new instance with all properties set.
       *
       * @param key    the message key.
       * @param extras the message extras.
       */
      protected AbstractBinaryMemcacheMessage(ByteBuf key, ByteBuf extras) {
          this.key = key;
          keyLength = (short) checkKeyLength(key);
          this.extras = extras;
          extrasLength = (byte) checkExtrasLength(extras);
          totalBodyLength = (keyLength & 0xFFFF) + (extrasLength & 0xFF);
      }
  
      @Override
      public ByteBuf key() {
          return key;
      }
  
      @Override
      public ByteBuf extras() {
          return extras;
      }
  
      @Override
      public BinaryMemcacheMessage setKey(ByteBuf key) {
          int newKeyLength = checkKeyLength(key);
          if (this.key != null) {
              this.key.release();
          }
          this.key = key;
          int oldKeyLength = keyLength & 0xFFFF;
          keyLength = (short) newKeyLength;
          totalBodyLength = totalBodyLength + newKeyLength - oldKeyLength;
          return this;
      }
  
      @Override
      public BinaryMemcacheMessage setExtras(ByteBuf extras) {
          int newExtrasLength = checkExtrasLength(extras);
          if (this.extras != null) {
              this.extras.release();
          }
          this.extras = extras;
          int oldExtrasLength = extrasLength & 0xFF;
          extrasLength = (byte) newExtrasLength;
          totalBodyLength = totalBodyLength + newExtrasLength - oldExtrasLength;
          return this;
      }
  
     // The key length and extras length are unsigned 16 and 8 bit fields in the header.
     private static int checkKeyLength(ByteBuf key) {
         return key == null ? 0 : ObjectUtil.checkInRange(key.readableBytes(), 0, 0xFFFF, "key length");
     }
 
     private static int checkExtrasLength(ByteBuf extras) {
         return extras == null ? 0 : ObjectUtil.checkInRange(extras.readableBytes(), 0, 0xFF, "extras length");
     }
 
     @Override
     public byte magic() {
         return magic;
     }
 
     @Override
     public BinaryMemcacheMessage setMagic(byte magic) {
         this.magic = magic;
         return this;
     }
 
     @Override
     public long cas() {
         return cas;
     }
 
     @Override
     public BinaryMemcacheMessage setCas(long cas) {
         this.cas = cas;
         return this;
     }
 
     @Override
     public int opaque() {
         return opaque;
     }
 
     @Override
     public BinaryMemcacheMessage setOpaque(int opaque) {
         this.opaque = opaque;
         return this;
     }
 
     @Override
     public int totalBodyLength() {
         return totalBodyLength;
     }
 
     @Override
     public BinaryMemcacheMessage setTotalBodyLength(int totalBodyLength) {
         this.totalBodyLength = totalBodyLength;
         return this;
     }
 
     @Override
     public byte dataType() {
         return dataType;
     }
 
     @Override
     public BinaryMemcacheMessage setDataType(byte dataType) {
         this.dataType = dataType;
         return this;
     }
 
     @Override
     public byte extrasLength() {
         return extrasLength;
     }
 
     /**
      * Set the extras length of the message.
      * <p/>
      * This may be 0, since the extras content is optional.
      *
      * @param extrasLength the extras length.
      */
     BinaryMemcacheMessage setExtrasLength(byte extrasLength) {
         this.extrasLength = extrasLength;
         return this;
     }
 
     @Override
     public short keyLength() {
         return keyLength;
     }
 
     /**
      * Set the key length of the message.
      * <p/>
      * This may be 0, since the key is optional.
      *
      * @param keyLength the key length to use.
      */
     BinaryMemcacheMessage setKeyLength(short keyLength) {
         this.keyLength = keyLength;
         return this;
     }
 
     @Override
     public byte opcode() {
         return opcode;
     }
 
     @Override
     public BinaryMemcacheMessage setOpcode(byte opcode) {
         this.opcode = opcode;
         return this;
     }
 
     @Override
     public BinaryMemcacheMessage retain() {
         super.retain();
         return this;
     }
 
     @Override
     public BinaryMemcacheMessage retain(int increment) {
         super.retain(increment);
         return this;
     }
 
     @Override
     protected void deallocate() {
         if (key != null) {
             key.release();
         }
         if (extras != null) {
             extras.release();
         }
     }
 
     @Override
     public BinaryMemcacheMessage touch() {
         super.touch();
         return this;
     }
 
     @Override
     public BinaryMemcacheMessage touch(Object hint) {
         if (key != null) {
             key.touch(hint);
         }
         if (extras != null) {
             extras.touch(hint);
         }
         return this;
     }
 
     /**
      * Copies special metadata hold by this instance to the provided instance
      *
      * @param dst The instance where to copy the metadata of this instance to
      */
     void copyMeta(AbstractBinaryMemcacheMessage dst) {
         dst.magic = magic;
         dst.opcode = opcode;
         dst.keyLength = keyLength;
         dst.extrasLength = extrasLength;
         dst.dataType = dataType;
         dst.totalBodyLength = totalBodyLength;
         dst.opaque = opaque;
         dst.cas = cas;
     }
 }