/*
      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;
  
  import static fulmine.util.Utils.COLON;
  import static fulmine.util.Utils.COMMA_SPACE;
  import static fulmine.util.Utils.string;
  import fulmine.Domain;
  import fulmine.IType;
  import fulmine.event.EventProcessor;
  import fulmine.event.IEvent;
  import fulmine.model.component.AbstractComponent;
  import fulmine.model.container.IContainer;
  import fulmine.util.reference.is;
  
  /**
   * The base-class for all {@link IField} implementations. All implementations
   * will include a setter and getter for the field's value. A field is added as a
   * member of an {@link IContainer}.
   * <p>
   * If a field is set with a different value, the field will raise an event with
   * its container. If the field is set with the same value, no event is raised.
   * <p>
   * Field implementations are not guaranteed to be thread-safe.
   * 
   * @author Ramon Servadei
   */
  public abstract class AbstractField extends AbstractComponent implements IField
  {
      /** The container this field is held in */
      private IContainer container;
  
      /** The application that created the field */
      private byte application;
  
      /** The permission assigned for the field by the application */
      private short permission;
  
      /**
       * Standard constructor.
       * 
       * @param identity
       *            the identity of the field
       * @param type
       *            the type of the field
       * @param application
       *            the application that created the field
       * @param permission
       *            the permission assigned for the field by the application
       */
      public AbstractField(String identity, IType type, byte application,
          short permission)
      {
          super(identity, type, Domain.FRAMEWORK);
          this.application = application;
          this.permission = permission;
      }
  
      public final IContainer getContainer()
      {
          return this.container;
      }
  
      public byte getApplication()
      {
          return this.application;
      }
  
      public short getPermission()
      {
          return this.permission;
      }
  
      public final void addedToContainer(IContainer container)
      {
          setContainer(container);
      }
  
      public final void removedFromContainer(IContainer container)
      {
          if (getContainer() != null && getContainer().equals(container))
          {
              setContainer(null);
          }
      }
  
     @Override
     protected void doComponentDestroy()
     {
         super.doComponentDestroy();
         setContainer(null);
     }
 
     /**
      * Notify the container with an event
      * 
      * @param event
      *            the event to notify the container with
      */
     protected final void notifyEvent(IEvent event)
     {
         checkClone();
         /*
          * Get the thread-bound {@link IEventFrameExecution} from the {@link
          * EventProcessor} currently executing and store it. This becomes known
          * as the 'driving' frame as it drives the change in this field.
          */
         setDrivingFrame(EventProcessor.getCurrentFrame());
         if (getContainer() != null)
         {
             getContainer().addEvent(event);
         }
     }
 
     public final void setContainer(IContainer container)
     {
         this.container = container;
     }
 
     public void setApplication(byte application)
     {
         this.application = application;
     }
 
     public void setPermission(short permission)
     {
         this.permission = permission;
     }
 
     @Override
     public String toIdentityString()
     {
         return getFormattedString(string(this,
             getIdentityStringWithPermission().toString()));
     }
 
     @Override
     public String toString()
     {
         return getFormattedString(string(this,
             getIdentityStringWithPermission().append(COMMA_SPACE).append(
                 "value=").append(getValueAsString()).toString()));
     }
 
     @Override
     public String toDetailedString()
     {
         return toString();
     }
 
     @Override
     public int hashCode()
     {
         final int prime = 31;
         int result = super.hashCode();
         result = prime * result + getPermission();
         result = prime * result + getApplication();
         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 AbstractField other = (AbstractField) obj;
             return is.eq(getPermission(), other.getPermission())
                 && is.eq(getApplication(), other.getApplication());
         }
         return false;
     }
 
     /**
      * Get a formatted string containing the container's identity (if the field
      * is attached to a container) and the field string value
      * 
      * @param fieldStringValue
      *            the string value for the field
      * @return a formatted string with the container and string value
      */
     private String getFormattedString(final String fieldStringValue)
     {
         return getContainer() == null ? fieldStringValue
             : getContainer().toIdentityString() + COLON + COLON
                 + fieldStringValue;
     }
 
     private StringBuilder getIdentityStringWithPermission()
     {
         return getIdentityString().append(COMMA_SPACE).append("application=").append(
             getApplication()).append(COMMA_SPACE).append("permission=").append(
             getPermission());
     }
 
     public boolean setValueFromString(String value)
     {
         throw new UnsupportedOperationException();
     }
 }