/*
      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.event;
  
  import static fulmine.util.Utils.COMMA_SPACE;
  import static fulmine.util.Utils.EMPTY_STRING;
  import static fulmine.util.Utils.logException;
  import static fulmine.util.Utils.nullCheck;
  import static fulmine.util.Utils.safeToString;
  import static fulmine.util.Utils.string;
  import fulmine.IAddressable;
  import fulmine.IDomain;
  import fulmine.IType;
  
  /**
   * Base-class for {@link IEvent} instances that are marker events. A marker
   * event represents an arbitrary event and is not necessarily related to the
   * state of its {@link IEventSource}. Therefore marker events cannot be
   * coalesced and thus the {@link #equals(Object)} and {@link #hashCode()}
   * methods are final and perform the standard operation exposed by the
   * {@link Object} class.
   * 
   * @author Ramon Servadei
   */
  public abstract class AbstractEvent implements IEvent
  {
      /** The source for this */
      private IEventSource source;
  
      /** The frame */
      private IEventFrameExecution frame;
  
      /** The driving frame */
      private IEventFrameExecution drivingFrame;
  
      private IAddressable address;
  
      /**
       * The trigger event, this is queued via
       * {@link IEventManager#queueEvent(IEvent)} <b>after</b> this event has been
       * processed.
       */
      private IEvent triggerEvent;
  
      /**
       * Public constructor
       */
      public AbstractEvent()
      {
          super();
      }
  
      public final IEventFrameExecution getDrivingFrame()
      {
          return this.drivingFrame;
      }
  
      public final IEventFrameExecution getFrame()
      {
          return this.frame;
      }
  
      public final IEventSource getSource()
      {
          return this.source;
      }
  
      public final void setSource(IEventSource source)
      {
          this.source = source;
          setAddress(source);
      }
  
      protected final void setAddress(IAddressable address)
      {
          nullCheck(address, "null address");
          this.address = address;
      }
  
      public void setFrame(IEventFrameExecution frame)
      {
          this.frame = frame;
      }
  
      public void setDrivingFrame(IEventFrameExecution drivingFrame)
      {
         this.drivingFrame = drivingFrame;
     }
 
     @Override
     public Object clone() throws CloneNotSupportedException
     {
         return super.clone();
     }
 
     public String toDetailedString()
     {
         return getString(true);
     }
 
     public String toIdentityString()
     {
         return getClass().getSimpleName();
     }
 
     public final IDomain getDomain()
     {
         return this.address.getDomain();
     }
 
     public final String getIdentity()
     {
         return this.address.getIdentity();
     }
 
     public final IType getType()
     {
         return this.address.getType();
     }
 
     public final String getAddress()
     {
         return this.address.getAddress();
     }
 
     public void setTriggerEvent(IEvent triggerEvent)
     {
         this.triggerEvent = triggerEvent;
     }
 
     public IEvent getTriggerEvent()
     {
         return this.triggerEvent;
     }
 
     /**
      * Delegate method for subclasses to provide additional toString
      * information. This should be a comma separated string, e.g.
      * "one, two, three"
      * 
      * @return the additional toString information in comma separated format
      */
     protected String getAdditionalToString()
     {
         return EMPTY_STRING;
     }
 
     private String getString(boolean detailed)
     {
         try
         {
             final String additionalToString = getAdditionalToString();
             StringBuilder sb = new StringBuilder();
             boolean addSeparator = false;
             if (getSource() != null && !hideSourceFromToString())
             {
                 sb.append("source=").append(
                     (detailed ? getSource().toDetailedString()
                         : getSource().toIdentityString()));
                 addSeparator = true;
             }
             if (getFrame() != null)
             {
                 if (addSeparator)
                 {
                     sb.append(COMMA_SPACE);
                 }
                 sb.append("frame=").append(getFrame());
                 addSeparator = true;
             }
             if (getDrivingFrame() != null)
             {
                 if (addSeparator)
                 {
                     sb.append(COMMA_SPACE);
                 }
                 sb.append("drivingFrame=").append(getDrivingFrame());
                 addSeparator = true;
             }
             if (additionalToString != EMPTY_STRING)
             {
                 if (addSeparator)
                 {
                     sb.append(COMMA_SPACE);
                 }
                 sb.append(additionalToString);
             }
             return string(this, sb.toString());
         }
         catch (Exception e)
         {
             String address = safeToString(this.address);
             logException(null, address, e);
             return string(this, address);
         }
 
     }
 
     /**
      * Allows sub-classes the ability to hide the source attribute from the
      * {@link #toString()} calls.
      * 
      * @return <code>true</code> if the source attribute should not be shown in
      *         string representations. Default is <code>false</code>.
      */
     protected boolean hideSourceFromToString()
     {
         return false;
     }
 
     @Override
     public final String toString()
     {
         return getString(false);
     }
 
     @Override
     public final int hashCode()
     {
         return super.hashCode();
     }
 
     @Override
     public final boolean equals(Object obj)
     {
         return super.equals(obj);
     }
 }