/*
      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.logException;
  
  import java.util.Collection;
  import java.util.LinkedHashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  import fulmine.Type;
  import fulmine.context.IPermissionProfile;
  import fulmine.model.container.AbstractDynamicContainer;
  import fulmine.model.container.IContainer;
  import fulmine.model.field.AbstractField;
  import fulmine.model.field.IField;
  import fulmine.protocol.specification.FieldReader;
  import fulmine.protocol.specification.FieldWriter;
  import fulmine.protocol.specification.FrameReader;
  import fulmine.protocol.specification.FrameWriter;
  import fulmine.protocol.wire.IWireIdentity;
  import fulmine.protocol.wire.SWFWireIdentityRegistry;
  import fulmine.protocol.wire.WireIdentity;
  import fulmine.protocol.wire.operation.IOperationScope;
  import fulmine.util.collection.CollectionFactory;
  import fulmine.util.collection.CollectionUtils;
  import fulmine.util.log.AsyncLog;
  import fulmine.util.reference.is;
  
  /**
   * Default implementation of an {@link IContainerDefinitionField}. The
   * definition is made up of {@link DescriptorField} fields. These descriptor
   * fields provide the necessary meta data for a transmitting container to write
   * an {@link IField} using its wire identity and provides the receiving
   * container with the information to construct the correct field type.
   * <p>
   * The fields of this implementation have SWF wire identities. There is no way
   * to send the definition using IWF as, by design, the IWF code maps to a field
   * and this is one of the functions the definition provides.
   * <p>
   * Static definitions are 'singletons'; all containers of the same type share
   * the same static definition. Static definitions are not sent on-the-wire or
   * mutated.
   * 
   * @author Ramon Servadei
   * 
   */
  public final class ContainerDefinitionField extends AbstractField implements
      IContainerDefinitionField
  {
  
      private final static AsyncLog LOG =
          new AsyncLog(ContainerDefinitionField.class);
  
      @Override
      protected AsyncLog getLog()
      {
          return LOG;
      }
  
      /** A special code to indicate a field is to be removed */
      static final byte REMOVE_FIELD = -1;
  
      /**
       * The reader task executed by the {@link FieldReader} when reading a frame
       * containing a container definition. Only dynamic definitions are sent on
       * the wire.
       */
      private final class ReaderTask implements FieldReader.IFieldReaderTask
      {
          public void read(IOperationScope scope, int fieldId, byte[] dataBuffer,
              int dataStart, int dataLen)
          {
              throw new IllegalStateException(
                  "reading IWF fields is invalid for a container definition");
          }
  
          public void read(IOperationScope scope, String fieldId,
              byte[] dataBuffer, int dataStart, int dataLen)
          {
              // create the descriptor field and then read its state
              DescriptorField desc = new DescriptorField(fieldId);
              desc.readState(scope, dataBuffer, dataStart, dataLen);
              if (desc.getDataType() == REMOVE_FIELD)
             {
                 final IField field =
                     ContainerDefinitionField.this.getContainer().get(fieldId);
                 if (field != null)
                 {
                     ContainerDefinitionField.this.getContainer().remove(field);
                 }
                 // always remove the description, even if there was no field
                 // added to the container
                 remove(desc);
             }
             else
             {
                 /*
                  * Fields are actually added in the AbstractContainer's
                  * ReaderTask. This then triggers ContainerFieldAddedEvents with
                  * a fully populated field.
                  */
                 add(desc);
             }
         }
     }
 
     /**
      * The counter for the IWF wire identity integer code (wire code). The
      * container definition has a wire code that is
      * {@link Type#CONTAINER_DEFINITION}.
      */
     // DO NOT CHANGE THIS!!!
     int wireCodeCounter = Type.CONTAINER_DEFINITION.value() + 1;
 
     /**
      * The fields making this definition, must be stored in the same order as
      * added via {@link #add(IField)}.
      */
     private Map<String, DescriptorField> fields =
         new LinkedHashMap<String, DescriptorField>(1);
 
     /** Map the IWF wire identity integer code to the {@link IField} */
     private Map<Integer, DescriptorField> descriptorFields =
         CollectionFactory.newMap(1);
 
     /** The changes to send */
     private List<DescriptorField> changes = CollectionFactory.newList(1);
 
     /** Flag to indicate if the definition is static */
     private boolean dynamic = true;
 
     /**
      * Constructor for a static definition
      * 
      * @param definition
      *            the unique name for the definition
      */
     public ContainerDefinitionField(String definition, IField... fields)
     {
         super(definition, Type.CONTAINER_DEFINITION,
             IPermissionProfile.DEFAULT_APPLICATION,
             IPermissionProfile.DEFAULT_PERMISSION);
         setContainer(null);
         for (IField field : fields)
         {
             try
             {
                 add(field);
             }
             catch (Exception e)
             {
                 logException(LOG, field, e);
             }
         }
         this.dynamic = false;
     }
 
     /**
      * Constructor for a dynamic definition
      * 
      * @param container
      *            a dynamic container (can have new fields added/removed)
      */
     public ContainerDefinitionField(AbstractDynamicContainer container)
     {
         super(container.getIdentity(), Type.CONTAINER_DEFINITION,
             IPermissionProfile.DEFAULT_APPLICATION,
             IPermissionProfile.DEFAULT_PERMISSION);
         setContainer(container);
     }
 
     public boolean isDynamic()
     {
         return this.dynamic;
     }
 
     public void add(IField field)
     {
         if (!this.dynamic)
         {
             throw new IllegalStateException(
                 "Cannot call add on a static container definition");
         }
         /*
          * veto self, this happens during the construction of the
          * AbstractDynamicContainer (it creates itself with a
          * ContainerDefinition) or if the container is a remote reference (it
          * will never write itself in that case)
          */
         if (this.equals(field)
             || (getContainer() != null && !getContainer().isLocal()))
         {
             return;
         }
         /*
          * For a static definition, add() is called during the ctor of the
          * definition (its static). For dynamic definitions, this is called from
          * the add() of the container
          */
         final DescriptorField desc = new DescriptorField(field.getIdentity());
         desc.setWireCode(this.wireCodeCounter++);
         desc.setDataType(field.getType().value());
         desc.setPermission(field.getPermission());
         desc.setApplication(field.getApplication());
         add(desc);
         getChanges().add(desc);
         notifyChange();
     }
 
     private void add(final DescriptorField desc)
     {
         getFields().put(desc.getIdentity(), desc);
         getDescriptorFields().put(Integer.valueOf(desc.getWireCode()), desc);
     }
 
     public void remove(IField field)
     {
         if (!this.dynamic)
         {
             throw new IllegalStateException(
                 "Cannot call remove on a static container definition");
         }
         final DescriptorField remove = getFields().get(field.getIdentity());
         if (remove != null)
         {
             remove.setDataType(REMOVE_FIELD);
             getChanges().add(remove);
             notifyChange();
         }
         else
         {
             if (getLog().isDebugEnabled())
             {
                 getLog().debug("No field descriptor for " + field.getIdentity());
             }
         }
     }
 
     public String getIdentityFor(IWireIdentity wireId)
     {
         if (wireId.isIntegerWireFormat())
         {
             return getIdentityForWireCode(wireId.getAsInteger());
         }
         throw new IllegalArgumentException(
             "Cannot work with an SWF wire identity");
     }
 
     public IWireIdentity getWireIdentityFor(String identity)
     {
         return WireIdentity.get(getWireCodeForIdentity(identity));
     }
 
     public String getIdentityForWireCode(int wireCode)
     {
         final IField field =
             getDescriptorFields().get(Integer.valueOf(wireCode));
         if (field != null)
         {
             return field.getIdentity();
         }
         throw new IllegalArgumentException("No field found for wire code "
             + wireCode + ", codes are: "
             + CollectionUtils.toFormattedString(getDescriptorFields()));
     }
 
     public int getWireCodeForIdentity(String identity)
     {
         if (getIdentity().equals(identity))
         {
             return Type.CONTAINER_DEFINITION.value();
         }
         final IField field = getFields().get(identity);
         if (field != null)
         {
             final int fieldWireCode = ((DescriptorField) field).getWireCode();
             return fieldWireCode;
         }
         throw new IllegalArgumentException("No field found for " + identity);
     }
 
     @Override
     protected boolean doReadState(IOperationScope scope, byte[] buffer,
         int start, int numberOfBytes) throws Exception
     {
         // the fields are read using a string wire format
         FrameReader.readNestedSWF(scope, buffer, start, numberOfBytes,
             this.new ReaderTask());
         return true;
     }
 
     @Override
     protected boolean doWriteState(IOperationScope scope, IWireIdentity wireId,
         byte[][] headerBuffer, int[] headerBufferPosition, byte[][] dataBuffer,
         int[] dataBufferPosition, boolean completeState) throws Exception
     {
         final Collection<DescriptorField> fieldsToWrite =
             (completeState ? getFields().values() : getChanges());
         if (fieldsToWrite.size() == 0)
         {
             if (LOG.isDebugEnabled())
             {
                 LOG.debug("No changes to write for " + this);
             }
             return true;
         }
         if (LOG.isDebugEnabled())
         {
             LOG.debug("Writing " + fieldsToWrite);
         }
         final byte[] frame =
             FrameWriter.writeNested(fieldsToWrite,
                 new SWFWireIdentityRegistry(), scope, completeState);
         FieldWriter.writeRawBytesField(wireId, frame, headerBuffer,
             headerBufferPosition, dataBuffer, dataBufferPosition);
         for (DescriptorField field : getChanges())
         {
             try
             {
                 if (field.getDataType() == REMOVE_FIELD)
                 {
                     remove(field);
                 }
             }
             catch (Exception e)
             {
                 logException(LOG, field, e);
             }
         }
         return true;
     }
 
     private void remove(DescriptorField field)
     {
         try
         {
             getDescriptorFields().remove(
                 Integer.valueOf(getWireCodeForIdentity(field.getIdentity())));
         }
         catch (Exception e)
         {
             logException(getLog(), "Did not find wire code for " + field
                 + " to remove", e);
         }
         try
         {
             getFields().remove(field.getIdentity());
         }
         catch (Exception e)
         {
             logException(getLog(), "Did not find " + field + " to remove", e);
         }
     }
 
     public void populate(IContainer container)
     {
         final Collection<DescriptorField> values = getFields().values();
         for (DescriptorField descriptorField : values)
         {
             try
             {
                 container.add(descriptorField.createField());
             }
             catch (Exception e)
             {
                 logException(LOG, descriptorField, e);
             }
         }
     }
 
     /**
      * Signal the container that this has changed.
      */
     private void notifyChange()
     {
         if (getContainer() != null)
         {
             getContainer().addEvent(this);
         }
     }
 
     public String[] getComponentIdentities()
     {
         final Set<String> keySet = getFields().keySet();
         return keySet.toArray(new String[keySet.size()]);
     }
 
     @Override
     protected void doComponentDestroy()
     {
         super.doComponentDestroy();
         // DO NOT CALL destroy() ON container
         getChanges().clear();
         getFields().clear();
         getDescriptorFields().clear();
     }
 
     public String getValueAsString()
     {
         return (this.dynamic ? "dynamic" : "static") + getFields().values();
     }
 
     public void resetChanges()
     {
         getChanges().clear();
     }
 
     public boolean containsDefinition(int wireCode)
     {
         return getDescriptorFields().containsKey(Integer.valueOf(wireCode));
     }
 
     public IField createField(int wireCode)
     {
         return getDescriptorFields().get(Integer.valueOf(wireCode)).createField();
     }
 
     public Object getValue()
     {
         return getValueAsString();
     }
 
     public byte getApplication(int wireCode)
     {
         return getDescriptorFields().get(Integer.valueOf(wireCode)).getApplication();
     }
 
     public short getPermission(int wireCode)
     {
         return getDescriptorFields().get(Integer.valueOf(wireCode)).getPermission();
     }
 
     void setFields(Map<String, DescriptorField> fields)
     {
         this.fields = fields;
     }
 
     Map<String, DescriptorField> getFields()
     {
         return this.fields;
     }
 
     void setDescriptorFields(Map<Integer, DescriptorField> descriptorFields)
     {
         this.descriptorFields = descriptorFields;
     }
 
     Map<Integer, DescriptorField> getDescriptorFields()
     {
         return this.descriptorFields;
     }
 
     void setChanges(List<DescriptorField> changes)
     {
         this.changes = changes;
     }
 
     List<DescriptorField> getChanges()
     {
         return this.changes;
     }
 
     @Override
     public boolean equals(Object obj)
     {
         if (is.same(this, obj))
         {
             return true;
         }
         if (is.differentClass(this, obj))
         {
             return false;
         }
         return super.equals(obj);
         /*
          * Don't bother testing the fields and wireCodes - removed ones really
          * duff things up.
          */
     }
 
     @Override
     public Object clone() throws CloneNotSupportedException
     {
         final ContainerDefinitionField clone =
             (ContainerDefinitionField) super.clone();
         // deep-copy
         List<DescriptorField> changes = CollectionFactory.newList();
         clone.setChanges(changes);
         clone.getChanges().addAll(getChanges());
         Map<String, DescriptorField> fields = CollectionFactory.newMap();
         clone.setFields(fields);
         clone.getFields().putAll(getFields());
         Map<Integer, DescriptorField> descriptorFields =
             CollectionFactory.newMap();
         clone.setDescriptorFields(descriptorFields);
         clone.getDescriptorFields().putAll(getDescriptorFields());
         return clone;
     }
 
 }