/*
      Copyright 2007 Ramon Servadei
   
      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 fulmine.model.field.containerdefinition;
  
  import static fulmine.util.Utils.CLOSE_SQUARE;
  import static fulmine.util.Utils.COMMA_SPACE;
  import fulmine.IType;
  import fulmine.Type;
  import fulmine.context.IPermissionProfile;
  import fulmine.model.field.AbstractField;
  import fulmine.model.field.BooleanField;
  import fulmine.model.field.DoubleField;
  import fulmine.model.field.FloatField;
  import fulmine.model.field.IField;
  import fulmine.model.field.IntegerField;
  import fulmine.model.field.LongField;
  import fulmine.model.field.StringField;
  import fulmine.protocol.specification.ByteReader;
  import fulmine.protocol.specification.FieldWriter;
  import fulmine.protocol.wire.IWireIdentity;
  import fulmine.protocol.wire.operation.IOperationScope;
  import fulmine.util.log.AsyncLog;
  import fulmine.util.reference.is;
  
  /**
   * A field that holds the description of the structure of a single
   * {@link IField} in a container. The description contains the identity, IWF
   * wire code, data type, application code and permission code of the target
   * field. The identity of this field is the identity of the field it describes.
   * <p>
   * The descriptor writes the field attributes as follows:
   * 
   * <pre>
   * -------------------------------------------------------------------------------------------------------------------------
   * |   8th byte   |   7th byte   |   6th byte   |   5th byte   |   4th byte   |   3rd byte   |   2nd byte   |   1st byte   |
   * -------------------------------------------------------------------------------------------------------------------------
   * |                         wire code                         |         permission          |     type     | application  |
   * -------------------------------------------------------------------------------------------------------------------------
   * </pre>
   * 
   * @author Ramon Servadei
   */
  public final class DescriptorField extends AbstractField
  {
      private final static AsyncLog LOG = new AsyncLog(DescriptorField.class);
  
      @Override
      protected AsyncLog getLog()
      {
          return LOG;
      }
  
      /** The wire code for the field */
      private int wireCode;
  
      /**
       * The data type of the field.
       * 
       * @see Type Type for the possible values
       */
      private byte dataType;
  
      /**
       * Standard constructor
       * 
       * @param identity
       *            the identity of this field AND the identity of the field this
       *            describes
       */
      public DescriptorField(String identity)
      {
          super(identity, Type.DESCRIPTOR_FIELD,
              IPermissionProfile.DEFAULT_APPLICATION,
              IPermissionProfile.DEFAULT_PERMISSION);
      }
  
      public IField createField()
      {
          final IType type = Type.get(getDataType());
          if (type.equals(Type.BOOLEAN_FIELD))
          {
              return new BooleanField(getFieldIdentity(), getApplication(),
                  getPermission());
          }
          if (type.equals(Type.INTEGER_FIELD))
          {
             return new IntegerField(getFieldIdentity(), getApplication(),
                 getPermission());
         }
         if (type.equals(Type.LONG_FIELD))
         {
             return new LongField(getFieldIdentity(), getApplication(),
                 getPermission());
         }
         if (type.equals(Type.FLOAT_FIELD))
         {
             return new FloatField(getFieldIdentity(), getApplication(),
                 getPermission());
         }
         if (type.equals(Type.DOUBLE_FIELD))
         {
             return new DoubleField(getFieldIdentity(), getApplication(),
                 getPermission());
         }
         if (type.equals(Type.STRING_FIELD))
         {
             return new StringField(getFieldIdentity(), getApplication(),
                 getPermission());
         }
         throw new IllegalArgumentException("Unhandled field type: " + type);
     }
 
     public void setWireCode(int wireCode)
     {
         this.wireCode = wireCode;
     }
 
     public void setDataType(byte type)
     {
         this.dataType = type;
     }
 
     String getFieldIdentity()
     {
         return getIdentity();
     }
 
     public int getWireCode()
     {
         return this.wireCode;
     }
 
     public byte getDataType()
     {
         return this.dataType;
     }
 
     @Override
     protected boolean doReadState(IOperationScope scope, byte[] buffer,
         int start, int numberOfBytes) throws Exception
     {
         long state = ByteReader.readLong(buffer, start, numberOfBytes);
         setWireCode((int) (state >> 32));
         setPermission((short) ((state >> 16) & 0xFFFF));
         setDataType((byte) ((state >> 8) & 0xFF));
         setApplication((byte) (state & 0xFF));
         return true;
     }
 
     @Override
     protected boolean doWriteState(IOperationScope scope, IWireIdentity wireId,
         byte[][] headerBuffer, int[] headerBufferPosition, byte[][] dataBuffer,
         int[] dataBufferPosition, boolean completeState) throws Exception
     {
         long state = (long) getWireCode() << 32;
         state |= (getPermission() << 16) & 0x00000000FFFF0000L;
         state |= (getDataType() << 8) & 0xFF00;
         state |= (getApplication() & 0xFF);
         FieldWriter.writeLongField(wireId, state, headerBuffer,
             headerBufferPosition, dataBuffer, dataBufferPosition);
         return true;
     }
 
     public String getValueAsString()
     {
         return toString();
     }
 
     public Object getValue()
     {
         return getValueAsString();
     }
 
     @Override
     public String toString()
     {
         return "[DescriptorField " + getIdentity() + COMMA_SPACE
             + Type.get(getDataType()) + COMMA_SPACE + getWireCode()
             + COMMA_SPACE + getApplication() + COMMA_SPACE + getPermission()
             + CLOSE_SQUARE;
     }
 
     @Override
     public int hashCode()
     {
         final int prime = 31;
         int result = super.hashCode();
         result = prime * result + getWireCode();
         result = prime * result + getDataType();
         return result;
     }
 
     @Override
     public boolean equals(Object obj)
     {
         if (is.same(this, obj))
         {
             return true;
         }
         if (is.differentClass(this, obj))
         {
             return false;
         }
         if (super.equals(obj))
         {
             final DescriptorField other = (DescriptorField) obj;
             return is.eq(getDataType(), other.getDataType())
                 && is.eq(getWireCode(), other.getWireCode());
         }
         return false;
     }
 }