/*
 * $RCSfile: NonTransient.java,v $
 * $Revision: 1.19.2.4 $
 * $Date: 2015/05/04 16:22:51 $
 *
 * Copyright 2013 Cloud Software Group, Inc. ALL RIGHTS RESERVED. 
 * Cloud Software Group, Inc. Confidential Information
 */
package com.tibco.xp.runtime;

import com.kabira.platform.ManagedObject;
import com.kabira.platform.ObjectNotUniqueError;
import com.kabira.platform.ResourceUnavailableException;
import com.kabira.platform.annotation.ByReference;
import com.kabira.platform.annotation.ByValue;
import com.kabira.platform.annotation.Managed;
import com.tibco.cep.runtime.model.event.EventContext;
import com.tibco.cep.runtime.model.event.impl.SimpleEventImpl;

/**
 * Base class for non-transient events
 * <p>
 * A non-transient event is one that has a TTL != 0.
 * <p>
 * Events with a TTL &gt; 0 have an expiration timer started.
 * When the expiration timer fires, the event is removed 
 * from shared memory
 * <p>
 * Events with a TTL &lt; 0 do not have an expiration timer 
 * started.  These events remain in shared memory until
 * explicitly deleted by the application.
 */
@Managed
public abstract class NonTransient extends Event 
{
        /**
         * Java constructor
         */
        protected NonTransient()
        {
        }
        
        /**
         * Rule or Rule Function constructor
         * @param id Unique identifier
         */
        protected NonTransient(long id)
        {
            register(id);
        }
        
        @Override
        public String toString()
        {
                StringBuilder value = new StringBuilder(super.toString());

                value.append("&context=");
                value.append(NonTransient.getChannelContext(this));
                value.append("&objectreference=");
                value.append(ManagedObject.objectToReference(this));
                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;
        }
        
        @Override
        public final void assertEvent() throws ObjectNotUniqueError, ResourceUnavailableException
        {
                // TODO - Work-around for FLUENCY-5593. 
                super.assertEvent();
        }
        
        /**
         * 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();
                
                if (destination == null)
                {
                        throw new IllegalArgumentException("Destination cannot be null");
                }
                
                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) 
        {
                assert timeToLive != 0 : this;
                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;
        }
        
        @Override
        protected final void updateProperties()
        {
                assert EntityProxy.getProxy(this) instanceof EventProxy : this;
        assert getHandle(false) instanceof SimpleEventImpl : this;
        
        EventProxy proxy = (EventProxy)EntityProxy.getProxy(this);
        SimpleEventImpl handle = (SimpleEventImpl) getHandle(false);

                proxy.updateMetaProperties(handle);
                updateUserProperties(handle);
                
                //
                //      Start TTL timer
                //
                assert TransactionService.getInstance() != null : this;
                TransactionService.getInstance().scheduleEvent(this);           
        }
    
        /**
         * Get the channel context for an event
         * @param event Event event
         * @return Channel context for this event, may be null
         * <p>
         * N.B. This method is static to prevent it from being dispatched
         * on distributed objects since it is accessing local POJOs
         */
        protected static final EventContext getChannelContext(NonTransient event) 
        {
                assert event != null;
                return event.m_context;
        }

        /**
         * Set the channel context for an event
         * @param event Event
         * @param context Channel context to set, may be null
         * <p>
         * N.B. This method is static to prevent it from being dispatched
         * on distributed objects since it is accessing local POJOs
         */
        protected static final void setChannelContext(NonTransient event, EventContext context) 
        {
                assert event != null;
                event.m_context = context;
        }
        
        @Override
        final String getTimerIdentifier()
        {
                return m_timerIdentifier;
        }
        
        @Override
        final void setTimerIdentifier(final String identifier)
        {
                assert getTimeToLive() != 0 : this;
                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;
        private String  m_destination = null;
        @ByValue
        private PayLoad m_payload = null;
        @ByReference
        private EventContext m_context = null;
        private String m_timerIdentifier = _INVALID_TIMER_IDENTIFIER;
        private static final long serialVersionUID = 3L;
}