/*
      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.container;
  
  import static fulmine.util.Utils.logException;
  import static fulmine.util.Utils.safeToString;
  
  import java.util.Collection;
  import java.util.List;
  
  import fulmine.IDomain;
  import fulmine.IType;
  import fulmine.Type;
  import fulmine.context.IFrameworkContext;
  import fulmine.model.container.events.ContainerFieldAddedEvent;
  import fulmine.model.container.events.ContainerFieldRemovedEvent;
  import fulmine.model.field.IField;
  import fulmine.model.field.containerdefinition.ContainerDefinitionField;
  import fulmine.model.field.containerdefinition.IContainerDefinitionField;
  import fulmine.protocol.specification.FieldReader;
  import fulmine.protocol.specification.FrameReader;
  import fulmine.protocol.wire.operation.IOperationScope;
  import fulmine.util.collection.CollectionFactory;
  
  /**
   * Base class for dynamic containers.
   * <p>
   * This implementation is thread safe. A dynamic container is a container with a
   * variable field population; fields can be added and removed arbitrarily during
   * the container's life-cycle.
   * <p>
   * A dynamic container maintains a field that is the
   * {@link IContainerDefinitionField} to describe the field population for the
   * container. This definition is sent in the wire frame as the first field. This
   * allows receiving context instances to correctly construct the field
   * population of the dynamic container. This is a key difference between a
   * static and dynamic container structure.
   * <p>
   * This raises the following events:
   * <ul>
   * <li>{@link ContainerFieldAddedEvent} when a field is added
   * <li>{@link ContainerFieldRemovedEvent} when a field is removed
   * </ul>
   * 
   * @author Ramon Servadei
   */
  public abstract class AbstractDynamicContainer extends
      AbstractEventProcessingContainer
  {
      /**
       * The reader task executed by the {@link FieldReader} when reading messages
       */
      protected final class ReaderTask extends AbstractContainer.ReaderTask
      {
          @Override
          public void read(IOperationScope scope, int fieldId, byte[] dataBuffer,
              int dataStart, int dataLen)
          {
              // dynamic containers send their definition when it changes
              if (fieldId == Type.CONTAINER_DEFINITION.value())
              {
                  getDefinition().readState(scope, dataBuffer, dataStart, dataLen);
              }
              else
              {
                  super.read(scope, fieldId, dataBuffer, dataStart, dataLen);
              }
          }
      }
  
      /** The identity of the definition */
      private final String definitionId;
  
      /**
       * Standard constructor. A {@link ContainerDefinitionField} is constructed
       * and added as a field of this. The constructor calls the {@link #start()}
       * method.
       * 
       * @param nativeContextIdentity
       *            the name of the context this container is native to - the name
       *            of its local context
       * @param identity
       *            the identity of the container
       * @param type
       *            the type of the container
       * @param domain
      *            the domain for the container
      * @param hostContext
      *            the context hosting this container instance
      * @param local
      *            <code>true</code> the container is local to this context
      */
     public AbstractDynamicContainer(String nativeContextIdentity,
         String identity, IType type, IDomain domain,
         IFrameworkContext hostContext, boolean local)
     {
         super(nativeContextIdentity, identity, type, domain, hostContext, local);
         final ContainerDefinitionField containerDefinition =
             new ContainerDefinitionField(this);
         this.definitionId = containerDefinition.getIdentity();
         /*
          * this is not pretty - we need to masquerade as being in a FrameReader
          * context to ensure we can bypass the usual checks that prevent remote
          * containers being mutated - its the action of adding a container
          * definition that requires this
          */
         boolean alreadyInContext = FrameReader.inContext.get().booleanValue();
         try
         {
             if (!alreadyInContext && !isLocal())
             {
                 FrameReader.inContext.set(Boolean.TRUE);
             }
             add(containerDefinition);
         }
         finally
         {
             if (!alreadyInContext && !isLocal())
             {
                 FrameReader.inContext.remove();
             }
         }
         start();
     }
 
     @Override
     protected final void afterAdd(IField field)
     {
         super.afterAdd(field);
         final IContainerDefinitionField containerDefinition =
             ((IContainerDefinitionField) get(this.definitionId));
         containerDefinition.add(field);
         // don't raise the event for the ContainerDefinitionField
         if (!(field instanceof IContainerDefinitionField))
         {
             try
             {
                 if (getContext() != null && getContext().isActive())
                 {
                     getContext().queueEvent(
                         new ContainerFieldAddedEvent(this,
                             (IField) field.clone()));
                 }
             }
             catch (CloneNotSupportedException e)
             {
                 logException(getLog(), getIdentity()
                     + " could not raise ContainerFieldAddedEvent for "
                     + safeToString(field), e);
             }
         }
     }
 
     @Override
     protected final void afterRemove(IField field, IField removed)
     {
         super.afterRemove(field, removed);
         if (removed != null)
         {
             final IContainerDefinitionField containerDefinition =
                 ((IContainerDefinitionField) get(this.definitionId));
             containerDefinition.remove(removed);
             try
             {
                 if (getContext() != null && getContext().isActive())
                 {
 
                     getContext().queueEvent(
                         new ContainerFieldRemovedEvent(this,
                             (IField) removed.clone()));
                 }
             }
             catch (CloneNotSupportedException e)
             {
                 logException(getLog(), getIdentity()
                     + " could not raise ContainerFieldRemovedEvent for "
                     + safeToString(field), e);
             }
         }
     }
 
     public final boolean isDynamic()
     {
         return true;
     }
 
     @Override
     protected final IContainerDefinitionField getDefinition()
     {
         return (IContainerDefinitionField) get(this.definitionId);
     }
 
     @Override
     protected final ReaderTask newReaderTask()
     {
         return this.new ReaderTask();
     }
 
     @Override
     protected final Collection<IField> getFieldsToWrite(boolean completeState)
     {
         if (completeState)
         {
             return doGetComponentsToWriteWithDefinition(completeState);
         }
         /*
          * If the definition has changed, it must be the first field written
          * into the frame. The receiving end needs the definition first in order
          * to make sense of any new fields being sent.
          */
         if (super.changedFields.contains(getDefinition()))
         {
             return doGetComponentsToWriteWithDefinition(completeState);
         }
         return super.getFieldsToWrite(completeState);
     }
 
     private Collection<IField> doGetComponentsToWriteWithDefinition(
         boolean completeState)
     {
         final List<IField> changes =
             CollectionFactory.newList(completeState ? getFields().size()
                 : super.changedFields.size());
         // ensure the definition is at the head of the changes
         if (completeState)
         {
             changes.addAll(getFields().values());
             changes.remove(getDefinition());
             changes.add(0, getDefinition());
         }
         else
         {
             changes.add(getDefinition());
             super.changedFields.remove(getDefinition());
             changes.addAll(super.changedFields);
         }
         return changes;
     }
 }