/*
 * $RCSfile: Entity.java,v $
 * $Revision: 1.61.2.5 $
 * $Date: 2015/05/05 14:21:48 $
 *
 * Copyright 2012, 2013 Cloud Software Group, Inc. ALL RIGHTS RESERVED. 
 * Cloud Software Group, Inc. Confidential Information
 */
package com.tibco.xp.runtime;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import com.kabira.platform.ResourceUnavailableException;
import com.kabira.platform.swbuiltin.TransactionNotifier;
import com.tibco.cep.kernel.core.rete.ReteWM;
import com.tibco.cep.kernel.model.knowledgebase.DuplicateExtIdException;
import com.tibco.cep.kernel.service.logging.Level;
import com.tibco.cep.runtime.model.element.impl.EntityImpl;
import com.tibco.cep.runtime.model.element.impl.ManagedObjectManager;
import com.tibco.cep.runtime.session.RuleServiceProviderManager;
import com.tibco.cep.runtime.session.RuleSession;
import com.tibco.cep.runtime.session.RuleSessionManager;
import com.tibco.cep.runtime.session.impl.RuleSessionImpl;
import com.tibco.cep.runtime.session.impl.RuleSessionManagerImpl;

/**
 * Concept and Event base class.
 */
public abstract class Entity implements Serializable
{
        /**
         * Invalid type identifier constant
         */
        protected static final int INVALID_TYPE_IDENTIFIER = 0;
        
        // TODO - Find constant value in BE source for the magic 0
        /**
         * Empty entity identifier
         */
    static final long EMPTY_ENTITY_IDENTIFIER = 0;

        
    /**
     * Load an entity into working memory.
     * <p>
     * The entity is not asserted, it does not
     * cause any rules to be triggered.
     * <p>
     * Calling this method on entities that are already
     * loaded into working memory quietly does nothing.
     * @throws ResourceUnavailableException Rules engine not running
     */
    final public void load() throws ResourceUnavailableException
    {           
        EntityImpl entityImpl = getHandle(this);
        assert entityImpl != null : getId();
        
        if (TransactionService.isLoggerEnabledFor(Level.TRACE) == true)
        {
            TransactionService.log(Level.TRACE, "Loaded " + entityImpl);
        }
    }

    /**
     * Get the unique identifier for this entity
     * @return Entity identifier
     */
    public final long getId()
    {
        if (TransactionService.isRulesEngineActive() == false)
        {
                return EMPTY_ENTITY_IDENTIFIER;
        }
        
            assert TransactionService.getInstance() != null;
            long identifier = getIdentifierFromRegistry();
            
            //
            //  If no identifier registered for this entity do it now.
            //  Identifiers are not assigned to entities created from Java
            //  until required.
            //
            if (identifier == IdentifierGenerator.RESERVED_FOR_EMPTY_INDICATOR)
            {
                identifier = TransactionService.getInstance().generateId(getClass());
                register(identifier);
            }
        
        return identifier;
    }
    
    @Override
    public String toString()
    {
        return getClass().getName() + "@id=" + getId() + "@extId=" + getExtId();
    }
    
    /**
     * Remove this identifier from thread local storage
     * @param id Identifier to remove
     */
    static void unRegisterId(long id)
    {
        HashMap<Long,Holder> map = m_byIdentifierRegistry.get();
        assert map != null : Thread.currentThread().getName();
        assert map.containsKey(id) == true : id;
        map.remove(id);
    }
    
    /**
     * Assert an entity
     * @param startRTC True starts an RTC.  False just asserts the entity
     * @throws DuplicateExtIdException Duplicated external identifier
     */
    protected void assertEntity(final Boolean startRTC) throws DuplicateExtIdException
    {
        checkActive();
        
        RuleSession session = getAndSetActiveRuleSession();   
        assert session != null : getClass().getName();

        //
        //  If RTC being started mark the thread as being in an RTC
        //
        if (startRTC == true)
        {
            pushRTCStack();
        }
        
        //
        //      Get the handle - don't load it into working
        //      memory since that will prevent the assert 
        //      from working
        //
        EntityImpl entityImpl = getHandle(false);
       
        if (TransactionService.isLoggerEnabledFor(Level.TRACE) == true)
        {
            TransactionService.log(Level.TRACE, "Asserting entity " + entityImpl);
        }
        
        try
        {
                session.assertObject(entityImpl, startRTC);
        }
        finally
        {       
                //
                //  If we executed an RTC, pop the RTC stack
                //
                if (startRTC == true)
                {
                        popRTCStack();
                }
        }
    }
    
    /**
     * Get the external identifier for this entity.
     * <p>
     * Default implementation returns an empty string.
     * Overridden in sub-types if they have mapped a user
     * key to an external identifier
     * @return Externalization identifier
     */
    protected String getExtId()
    {
        return "";
    }
    
    /**
     * Register this entity
     * @param id Entity identifier
     */
    final protected void register(long id)
    {
        registerByEntity(id);
        registerByIdentifier(null);
    }
        
    /**
     * Lookup an entity by its unique identifier
     * @param id Unique identifier
     * @return Entity with unique identifier, or null if not found
     */
    static Entity lookupById(long id)
    {
        if (id == EMPTY_ENTITY_IDENTIFIER)
        {
                return null;
        }
        
        //
        //      Check thread registry first
        //
        return getEntityFromRegistry(id);
    }
    
    /**
     * Map a RETE handle to a managed object entity
     * <p>
     * If the handle is dirty, shared memory is updated
     * before returning the mapped entity.
     * @param handle Handle to map.  Can be null.
     * @return Mapped entity, or null if no entity to map
     */
    // TODO - Currently required to be public because it is used in the 
    // wrapper catalog function stubs
    public static Entity mapHandle(com.tibco.cep.kernel.model.entity.Entity handle)
    {
        if (handle == null)
        {
            return null;
        }
        
        Entity me = Entity.lookupById(handle.getId());
        
        //
        //  If we didn't find the entity we need to insert it.  This can happen
        //  if an entity is created in an RTC and then a catalog function is called
        //
        if (me == null)
        {
            TransactionService.getInstance().insert((EntityImpl)handle);
            me = Entity.lookupById(handle.getId());
            assert me != null : handle;           
        }

        return me;
    }
    
    /**
     * Map an array of RETE handles to managed entities
     * @param handles Handle array to map
     * @return Entities mapped from handle objects returned here
     */
    // TODO - Currently required to be public because it is used in the 
    // wrapper catalog function stubs
    public static ArrayList<Entity> mapHandleArray(
            com.tibco.cep.kernel.model.entity.Entity [ ] handles)
    {
        if (handles == null)
        {
                return new ArrayList<Entity>();
        }
        
        ArrayList<Entity> mapped = new ArrayList<Entity>(handles.length);
        
        for (com.tibco.cep.kernel.model.entity.Entity e : handles)
        {
            mapped.add(mapHandle(e));
        }
        return mapped;
    }
    
    /**
     * Map an array of entities to their implementation objects
     * @param entities Entity array to map
     * @return Entity implementations mapped from entity objects
     */
    // TODO - Currently required to be public because it is used in the 
    // wrapper catalog function stubs
    public static ArrayList<com.tibco.cep.kernel.model.entity.Entity> mapArray(Entity [ ] entities)
    {
        assert entities != null;
        
        ArrayList<com.tibco.cep.kernel.model.entity.Entity> mapped = 
                new ArrayList<com.tibco.cep.kernel.model.entity.Entity>(entities.length);
        
        for (Entity e : entities)
        {
            mapped.add(Entity.getHandle(e));
        }
        return mapped;
    }

    /**
     * Check that the rules engine is running in this JVM
     */
    protected static void checkActive()
    {
        //
        //  Throw a resource unavailable exception if the
        //  rules engine isn't active
        //
        if (ServiceProvider.isRulesEngineActive() == false)
        {
                String message = "Rules engine not active in this JVM";
                TransactionService.log(Level.FATAL, message);
            throw new com.kabira.platform.ResourceUnavailableException(message);
        }
    }
    
    /**
     * Push an RTC stack
     */
    static void pushRTCStack()
    {
        assert TransactionService.getInstance() != null;
        
        Long count = m_rtcState.get();

        //
        //      If count is 0, we are starting an RTC stack
        //      If using transaction scope, create a transaction
        //      notifier to do the reseting at the transaction boundary
        //      An additional stack frame is pushed to hold the stack open
        //      until the transaction completes.
        //
        if (count == 0)
        {
                if (TransactionService.getInstance().isTransactionWorkingMemoryScope() == true)
                {
                        //
                        //      Add transaction stack frame
                        //
                        count++;
                        new Notifier();
                }
                
                if (TransactionService.isLoggerEnabledFor(Level.TRACE) == true)
                {
                        String scope = "RUN_TO_COMPLETION";
                        if (TransactionService.getInstance().isTransactionWorkingMemoryScope() == true)
                        {
                        scope = "TRANSACTION";                          
                        }
                        
                        TransactionService.log(Level.TRACE,
                                "Starting " + scope + " scope for working memory.  Thread " 
                                + Thread.currentThread().getId()
                                + ":"
                                + Thread.currentThread().getName());                            
                }
        }
        count++;
        m_rtcState.set(count);
    }
    
    /**
     * Pop an RTC stack frame
     */
    static void popRTCStack()
    {
        Long count = m_rtcState.get();
        assert count > 0;
        count--;
        m_rtcState.set(count);
        
        //
        //      If stack is empty - clean up
        //
        if (count == 0)
        {
                reset();
        }
    }
    
    /**
     * Return the current RTC stack depth
     */
    static Long getRTCStackDepth()
    {
        return m_rtcState.get();
    }
    
    /**
     * Set the active rule session
     * @return Active rule session
     */
    static RuleSession getAndSetActiveRuleSession()
    {
        assert RuleServiceProviderManager.getInstance() != null;
        assert RuleServiceProviderManager.getInstance().getDefaultProvider() != null;
        assert RuleServiceProviderManager.getInstance().getDefaultProvider() instanceof BexRuleServiceProvider;
        
        //
        //    If we are called from the context of a rule or rule function
        //    the current rule session has already been set - use it
        //
        RuleSession session = RuleSessionManager.getCurrentRuleSession();

        if (session != null)
        {
            return session;
        }
        
        //
        //      Get the rule session for this thread and make it active
        //
        session = m_ruleSessions.get();
        assert session != null;
        assert session.getRuleRuntime() instanceof RuleSessionManagerImpl 
                                : session.getRuleRuntime().getClass().getName();
        ((RuleSessionManagerImpl)session.getRuleRuntime()).setCurrentRuleSession(session);
        
        return session;
    }
    
    /**
     * Get the RETE handle for an entity
     * <p>
     * N.B. - this method is static so that it isn't 
     * dispatched on remote objects since it is accessing
     * local POJOs
     * @param entity Entity for which to get associated handle object.  May be null.
     * @return RETE handle, or null.
     */
    // TODO - Currently required to be public because it is used in the
    // wrapper catalog function stubs
    public static EntityImpl getHandle(final Entity entity)
    {
        if (entity == null)
        {
            return null;
        }
        
        checkActive();
        
        return entity.getHandle(true);
    } 
    
    /**
     * Get a RETE handle
     * @param load True if handle should be loaded into working
     * memory if not already loaded, false do not load into working memory.
     * @return RETE handle
     */
    protected final EntityImpl getHandle(boolean load)
    {
        //
        //      Check to see if this entity is already loaded into working memory
        //
        EntityImpl handle = getHandleFromRegistry(getId());
        
        if (handle != null)
        {
                return handle;
        }
                
        EntityProxy entityProxy = EntityProxy.getProxy(this);
        assert entityProxy != null : this;
        
        handle = entityProxy.getHandle();
        assert handle != null : this;
        
        //
        //      Register the entity with the identifier registry
        //
        registerByIdentifier(handle);
        
        //
        //      Load the handle into the RTC working memory
        //
        if (load == true)
        {
                handle = ManagedObjectManager.loadIntoRtc(handle);
        }
                
        return handle;
    }
    //
    //  Reset per thread context
    //
    private static void reset()
    {
        assert getRTCStackDepth() == 0 : getRTCStackDepth();
                
        EntityProxy.clearProxyObjects();
        clearRegistry();
        
        //
        //      Clean up the rule session if still set.  This is the 
        //      case when asserts were done from Java
        //
        RuleSession session = RuleSessionManager.getCurrentRuleSession();

        if (session != null)
        {
                        try 
                        {
                                //
                                //      Retract objects from working memory
                                //
                                //      N.B. - Do not use session.reset() which spans threads
                                //
                                // TODO - Verify that this only returns objects in current thread
                                List<?> list = session.getObjects();
                                for (Object o : list)
                                {
                                        if (TransactionService.isLoggerEnabledFor(Level.TRACE) == true)
                                        {
                                                TransactionService.log(Level.TRACE, "Retracting " + o);
                                        }
                                        session.retractObject(o, false);
                                }
                                                                
                                //
                                //      Reset the rule agenda - the rules engine is not resetting this 
                                //      correctly on exceptions
                                //
                                assert session instanceof RuleSessionImpl : session;
                                assert ((RuleSessionImpl)session).getWorkingMemory() != null;
                                assert ((RuleSessionImpl)session).getWorkingMemory() instanceof ReteWM :
                                        ((RuleSessionImpl)session).getWorkingMemory();
                                
                                ReteWM workingMemory = (ReteWM)((RuleSessionImpl)session).getWorkingMemory();
                                workingMemory.cleanResolver();
                        } 
                        catch (Exception e) 
                        {
                                e.printStackTrace();
                        }
        }
                
                if (TransactionService.isLoggerEnabledFor(Level.TRACE) == true)
                {
                        TransactionService.log(
                                Level.TRACE, "Reset thread context for thread " 
                                                + Thread.currentThread().getId()
                                                + ":"
                                                + Thread.currentThread().getName());                            
                }
    }
    
    //
    //  Register identifier in entity registry
    //
    private void registerByEntity(long id)
    {
        HashMap<Entity,Long> map = m_byEntityRegistry.get();
        assert map != null : Thread.currentThread().getName();
        assert map.get(this) == null : id + " already registered";
        map.put(this, id);
    }
    
    //
    //  Get the entity from the registry
    //
    private long getIdentifierFromRegistry()
    {
        HashMap<Entity,Long> map = m_byEntityRegistry.get();
        assert map != null : Thread.currentThread().getName();
        Long identifier = map.get(this);
        
        if (identifier == null)
        {
                return IdentifierGenerator.RESERVED_FOR_EMPTY_INDICATOR;
        }
        return identifier;
    }
    
    //
    //  Register entity in by-identifier registry
    //
    private void registerByIdentifier(EntityImpl entityImpl)
    {
        HashMap<Long,Holder> map = m_byIdentifierRegistry.get();
        assert map != null : Thread.currentThread().getName();
        assert (entityImpl == null) || getHandleFromRegistry(getId()) == null :
                getId() + " already registered";
        Holder holder = new Holder(this, entityImpl);
        map.put(getId(), holder);
    }
    
    //
    //  Get the entity from the registry
    //
    private static Entity getEntityFromRegistry(long id)
    {
        assert id != EMPTY_ENTITY_IDENTIFIER;
        HashMap<Long,Holder> map = m_byIdentifierRegistry.get();
        assert map != null : Thread.currentThread().getName();
        Holder holder = map.get(id);
        
        if (holder == null)
        {
                return null;
        }
        return holder.getEntity();
      }
    
    //
    //  Get the RETE handle from the registry
    //
    private EntityImpl getHandleFromRegistry(long id)
    {
        HashMap<Long,Holder> map = m_byIdentifierRegistry.get();
        assert map != null : Thread.currentThread().getName();
        Holder holder = map.get(id);
        
        if (holder == null)
        {
                return null;
        }
        return holder.getHandle();
    }
    
    //
    //  Clear identifier registry
    //
    private static void clearRegistry()
    {
        m_byIdentifierRegistry.get().clear();
        m_byEntityRegistry.get().clear();
    }
      
    //
    //  Holder object for identifier registry
    //
        private static class Holder
        {
                Holder(final Entity entity, final EntityImpl entityImpl)
                {
                        m_entity = entity;
                        m_entityImpl = entityImpl;
                }
                        
                Entity getEntity()
                {
                        return m_entity;
                }
                
                EntityImpl getHandle()
                {
                        return m_entityImpl;
                }
                @Override
                public String toString()
                {
                        return m_entity + ":" + m_entityImpl;
                }
                private final Entity m_entity;
                private final EntityImpl m_entityImpl;
        } 
        
    //
    //  Thread local storage for by-identifier registry
    //
    private static class ByIdentifierRegistry extends ThreadLocal<HashMap<Long, Holder>>
    {

        @Override
        protected HashMap<Long, Holder> initialValue() 
        {        
            return new HashMap<Long, Holder>();
        }
        @Override
        public HashMap<Long,Holder> get() 
        {
            return super.get();
        }
        @Override
        public void set(HashMap<Long,Holder> value) 
        {
            super.set(value);
        }
        @Override
        public void remove() 
        {
            super.remove();
        }
    }
    
    //
    //  Thread local storage for by-entity registry
    //
    private static class ByEntityRegistry extends ThreadLocal<HashMap<Entity, Long>>
    {
        @Override
        protected HashMap<Entity, Long> initialValue() 
        {        
            return new HashMap<Entity, Long>();
        }
        @Override
        public HashMap<Entity,Long> get() 
        {
            return super.get();
        }
        @Override
        public void set(HashMap<Entity,Long> value) 
        {
            super.set(value);
        }
        @Override
        public void remove() 
        {
            super.remove();
        }
    }
 
    //
    //  Thread local storage for the current RTC state
    //
    private static class RTCState extends ThreadLocal<Long>
    {
        @Override
        protected Long initialValue() 
        {        
            return 0L;
        }
        @Override
        public Long get() 
        {
            return super.get();
        }
        @Override
        public void set(Long value) 
        {
            super.set(value);
        }
        @Override
        public void remove()
        {
            super.remove();
        }
    }
    //
    //  Thread local storage for the RuleSessions
    //
    private static class RuleSessions extends ThreadLocal<RuleSession>
    {
        @Override
        protected RuleSession initialValue() 
        {        
            return createRuleSession();
        }
        @Override
        public RuleSession get() 
        {
            return super.get();
        }
        @Override
        public void set(RuleSession value) 
        {
            super.set(value);
        }
        @Override
        public void remove()
        {
            super.remove();
        }
        
        //
        //      Create a rule session
        //
        private RuleSession createRuleSession()
        {
            assert RuleServiceProviderManager.getInstance() != null;
            assert RuleServiceProviderManager.getInstance().getDefaultProvider() != null;
            assert RuleServiceProviderManager.getInstance().getDefaultProvider() instanceof BexRuleServiceProvider;

                RuleSession session = null;
                BexRuleServiceProvider rsp 
                = (BexRuleServiceProvider)RuleServiceProviderManager.getInstance().getDefaultProvider();
            
            RuleSession[] sessions = rsp.getRuleRuntime().getRuleSessions();
            
            assert sessions != null;
            
            for (RuleSession s : sessions)
            {
                session = s;
                break;
            }
            
            return session;
        }
    }
    
    //
    //  Transaction notifier for transaction scope working
    //  memory management
    //
    private static class Notifier extends TransactionNotifier
    {
        public Notifier() 
        {
                assert Entity.getRTCStackDepth() == 0 : Entity.getRTCStackDepth();
                }
                @Override
                public void onPrepare() 
                {
                        assert Entity.getRTCStackDepth() == 1 : Entity.getRTCStackDepth();
                        reset();
                }

                @Override
                public void onRollback() 
                {
                        assert Entity.getRTCStackDepth() > 0 : Entity.getRTCStackDepth();
                        reset();
                }
        
                private void reset()
                {
                        assert TransactionService.getInstance().isTransactionWorkingMemoryScope() == true;
                                                
                        //
                        //      Pop the transaction stack frame
                        //
                        Entity.popRTCStack();
                }
    }
    
        private static final long serialVersionUID = 1L;
        private static final RTCState m_rtcState = new RTCState();
        private static final ByIdentifierRegistry m_byIdentifierRegistry = new ByIdentifierRegistry();
        private static final ByEntityRegistry m_byEntityRegistry = new ByEntityRegistry();
        private static final RuleSessions m_ruleSessions = new RuleSessions();
}