//
//  Copyright 2013 Cloud Software Group, Inc. ALL RIGHTS RESERVED. 
//  Cloud Software Group, Inc. Confidential Information
//
//  $Revision: 1.5 $ $Date: 2013/07/01 22:45:59 $
//
package com.tibco.xp.runtime;

import com.kabira.platform.ManagedObject;
import com.kabira.platform.annotation.ByValue;
import com.kabira.platform.annotation.Managed;
import com.tibco.cep.runtime.model.event.impl.SimpleEventImpl;
import com.tibco.cep.runtime.model.event.impl.TimeEventImpl;

/**
 * Timed event base class
 */
@Managed
public abstract class Timed extends Event 
{
        /**
         * Java constructor
         */
        public Timed() 
        {
        }
        
        /**
         * Rule or Rule Function constructor
         * @param id Unique identifier
         */
        public Timed(long id) 
        {
            register(id);
        }
        
        @Override
        public String toString()
        {
                StringBuilder value = new StringBuilder(super.toString());
                
                value.append("@closure=");
                value.append(getClosure());
                value.append("@scheduledTime=");
                value.append(getScheduledTime());
                value.append("@interval=");
                value.append(getInterval());
                value.append(" ");
                value.append(getIntervalUnits());
                value.append("&fired=");
                value.append(getFired());
                return value.toString();
        }
        
        /**
         * Delete this event.
         * <p>
         * If this event currently has a TTL expiration timer
         * scheduled, the timer is canceled.
         */
        @Override
        public final void delete()
        {
                if (getTimerIdentifier().equals(_INVALID_TIMER_IDENTIFIER) == false)
                {
                        assert TransactionService.getInstance() != null : this;
                        TransactionService.getInstance().cancelExpirationTimer(this);
                }
                
                //
                //      Delete the event
                //
                ManagedObject.delete(this);
        }
        
        @Override
        public final Boolean getRetryOnException() 
        {
                return m_retryOnException;
        }

        @Override
        public final Long getTimeToLive() 
        {
                return m_timeToLive;
        }

        @Override
        public final String getTimeToLiveUnits() 
        {
                return m_timeToLiveUnits;
        }
        
        /**
         * Update user properties from shared memory
         * @param eventImpl Event handle to update
         */
        protected abstract void updateUserProperties(SimpleEventImpl eventImpl);

        @Override
        protected final void setRetryOnException(Boolean retryOnException) 
        {
                m_retryOnException = retryOnException;
        }

        @Override
        public final PayLoad getPayLoad() 
        {
                return m_payload;
        }
        
        @Override
        public final void setDestination(final String destination) 
        {
                enforceDispatchState();
                
                m_destination = destination;
        }
        
        @Override
        public final String getDestination() 
        {
                return m_destination;
        }
        
        @Override
        protected final void updatePayLoad(PayLoad payload) 
        {
                m_payload = payload;
        }

        @Override
        protected final void setTimeToLive(Long timeToLive) 
        {
                m_timeToLive = timeToLive;
        }

        @Override
        protected final void setTimeToLiveUnits(String timeToLiveUnits) 
        {
                m_timeToLiveUnits = timeToLiveUnits;
        }

        @Override
        protected final Boolean getDispatched() 
        {
                return m_dispatched;
        }

        @Override
        protected final void setDispatched() 
        {
                m_dispatched = true;
        }

        /**
         * Get the closure for this timed event
         * @return Closure value
         */
        public final String getClosure()
        {
                return m_closure;
        }
        
        /**
         * Set the closure for this timed event
         * @param closure Closure value
         */
        final void setClosure(final String closure)
        {
                m_closure = closure;
        }
        
        /**
         * Get the next scheduled expiration time
         * @return Next expiration time
         */
        final long getScheduledTime()
        {
                return m_scheduledTime;
        }
        
        /**
         * Set the next scheduled expiration time
         * @param next Next expiration time
         */
        final void setScheduledTime(final long next)
        {
                m_scheduledTime = next;
        }
        
        /**
         * Get the repeat interval
         * @return Repeat interval in milliseconds
         */
        final long getInterval()
        {
                return m_interval;
        }
        
        /**
         * Set the repeat interval
         * @param interval Repeat interval
         */
        protected final void setInterval(final long interval)
        {
                m_interval = interval;
        }
        
        /**
         * Get the repeat interval units
         * @return Repeat interval units
         */
        final String getIntervalUnits()
        {
                return m_intervalUnits;
        }
        
        /**
         * Set the expiration interval units
         * @param units Repeat interval units
         */
        protected final void setIntervalUnits(final String units)
        {
                m_intervalUnits = units;
        }
        
        /**
         * Get the fired value
         * @return Fired value
         */
        public final boolean getFired()
        {
                return m_fired;
        }
        
        /**
         * Set the fired value
         * @param fired Fired flag
         */
        final void setFired(final boolean fired)
        {
                m_fired = fired;
        }
        
        @Override
        protected final void updateProperties()
        {
                assert EntityProxy.getProxy(this) instanceof TimedProxy : this;
        assert getHandle(false) instanceof TimeEventImpl : this;
        
        TimedProxy proxy = (TimedProxy)EntityProxy.getProxy(this);
        TimeEventImpl handle = (TimeEventImpl) getHandle(false);

                proxy.updateMetaProperties(handle);
        }
        
        @Override
        final String getTimerIdentifier()
        {
                return m_timerIdentifier;
        }
        
        @Override
        final void setTimerIdentifier(final String identifier)
        {
                assert identifier != null : this;
                m_timerIdentifier = identifier;
        }
                
        private boolean m_dispatched = false;
        private boolean m_retryOnException = _DEFAULT_RETRY_ON_EXCEPTION;
        private long    m_timeToLive = _DEFAULT_TIME_TO_LIVE;
        private String  m_timeToLiveUnits = _TIME_TO_LIVE_UNITS_DEFAULT;
        @ByValue
        private PayLoad m_payload = null;
        private String  m_destination = null;
        private String m_closure = null;
        private long m_scheduledTime = 0;
        private long m_interval = 0;
        private String  m_intervalUnits = _TIME_TO_LIVE_UNITS_DEFAULT;
        private boolean m_fired = false;
        private String m_timerIdentifier = _INVALID_TIMER_IDENTIFIER;
        private static final long serialVersionUID = 3L;
}