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

import com.kabira.platform.KeyFieldValueList;
import com.kabira.platform.KeyManager;
import com.kabira.platform.KeyQuery;
import com.kabira.platform.KeyOrderedBy;
import com.kabira.platform.LockMode;
import com.kabira.platform.ManagedObject;
import com.kabira.platform.ObjectNotUniqueError;
import com.kabira.platform.ResourceUnavailableException;
import com.kabira.platform.annotation.Managed;
import com.tibco.cep.kernel.model.knowledgebase.DuplicateExtIdException;
import com.tibco.cep.kernel.service.logging.Level;
import com.tibco.cep.runtime.model.element.Property;
import com.tibco.cep.runtime.model.element.PropertyArray;
import com.tibco.cep.runtime.model.element.PropertyAtom;
import com.tibco.cep.runtime.model.element.PropertyAtomConcept;
import com.tibco.cep.runtime.model.element.impl.ConceptImpl;
import com.tibco.cep.runtime.model.element.impl.ManagedObjectLockType;
import com.tibco.cep.runtime.model.element.impl.property.simple.PropertyArrayConceptReferenceSimple;
import com.tibco.cep.runtime.model.element.impl.property.simple.PropertyArrayContainedConceptSimple;

import java.util.Date;
import java.util.HashMap;
import java.util.Set;

/**
 * Concept base class
 */
@Managed
public abstract class Concept extends Entity
{
        /**
         * Lookup operation type - unique, or not.
         */
        protected enum LookupType
        {
            /**
             * Perform a unique key lookup
             */
                UNIQUE_LOOKUP,
                /**
                 * Perform a non-unique key lookup
                 */
                NONUNIQUE_LOOKUP
        };
        
        /**
         * Java constructor
         */
        protected Concept()
        {
        }
        
        /**
         * Rule or Rule Function constructor
         * @param id Unique identifier
         */
        protected Concept(long id)
        {
            register(id);
        }

        /**
     * Assert a concept and start a run-to-completion cycle.  
     * <p>
     * This starts a new run-to-completion (RTC) cycle.  A
     * new transaction is started if one is not already active.
     * The RTC cycle is complete when this
     * method returns.  RETE working memory is cleared at the end
     * of the RTC cycle.
     * <p>
     * If the concept was previously loaded into working memory
     * this method quietly does nothing.
     * @throws ObjectNotUniqueError Duplicate external identifier
     * @throws ResourceUnavailableException Rules engine not running
     */
    public final void assertConcept() 
            throws ObjectNotUniqueError, ResourceUnavailableException
    {
        try
        {
            assertEntity(true);
        }
        catch (DuplicateExtIdException e)
        {
            throw new ObjectNotUniqueError(e.getLocalizedMessage());
        }
    }
    
    /**
     * Assert a concept, but do not start a run-to-completion cycle.
     * <p>
     * Assert a concept into the RETE, but do not start a
     * run-to-completion cycle.
     * <p>
     * If the concept was previously loaded into working memory
     * this method quietly does nothing.
     * @throws ObjectNotUniqueError Duplicate external identifier
     * @throws ResourceUnavailableException Rules engine not running
     */
    public final void assertConceptWithoutRunToCompletion() 
            throws ObjectNotUniqueError, ResourceUnavailableException
    {
        try
        {
            assertEntity(false);
        }
        catch (DuplicateExtIdException e)
        {
            throw new ObjectNotUniqueError(e.getLocalizedMessage());
        }
    }
    
        @Override
        public String toString()
        {
                StringBuilder value = new StringBuilder(super.toString());

                value.append("&objectreference=");
                value.append(ManagedObject.objectToReference(this));
                return value.toString();
        }

        /**
         * Execute a query.
         * <p>
         * Unique queries return a concept or, null if not found.  The concept is
         * added to working memory in the current RTC.
         * <p>
         * Non-unique or ordered queries return an iterator.  Concepts
         * returned in the iterator or not added to working memory
         * in the current RTC until they are accessed via the returned
         * iterator.
         * @param klass Concept class.
         * @param keyName Key name.
         * @param lockMode The lock mode to use when performing the query.
         * @param lookupType Specify whether this is a unique or non-unique query.
         * @param direction Ordering for non-unique queries.
         * @param keyFields Query key fields.
         * @return A concept for a unique query or null, if not found.
         * An iterator for a non-unique query.
         */
        // TODO - Break into two separate methods - one for unique and one for non-unique
        protected static Object lookupQuery(
                final Class<?> klass,
                        final String keyName,
                        final String lockMode,
                        final LookupType lookupType,
                        final String direction,
                        final HashMap<String, Object> keyFields)
        {
                //
                // define the query
                //
                KeyManager keyManager = new KeyManager();
                KeyQuery<?> keyQuery = keyManager.createKeyQuery(klass, keyName);
                KeyFieldValueList keyFieldValueList = new KeyFieldValueList();

                //
                // fill in the key fields
                //
                Set<String> fieldNames = keyFields.keySet();
                for (String fieldName : fieldNames)
                {
                        keyFieldValueList.add(fieldName, keyFields.get(fieldName));
                }
                keyQuery.defineQuery(keyFieldValueList);
                
                if (TransactionService.isLoggerEnabledFor(Level.TRACE) == true)
        {
                TransactionService.log(Level.TRACE, "Query (" + mapLockMode(lockMode) + "): " 
                        + keyQuery.toString());
        }

                //
                // if this is a non-unique query, just return the iterator.
                //
                if (lookupType == LookupType.NONUNIQUE_LOOKUP)
                {
                        if (direction != null)
                        {
                                return keyQuery.getResults(mapOrderBy(direction), mapLockMode(lockMode)).iterator();
                        }
                        return keyQuery.getResults(mapLockMode(lockMode)).iterator();
                }
                
                assert lookupType == LookupType.UNIQUE_LOOKUP : klass;

                Concept concept = (Concept)keyQuery.getSingleResult(mapLockMode(lockMode));

                if (concept == null)
                {
                        return null;
                }
                
                //
                //    Load the concept into working memory
                //
                concept.load();
                
                return concept;
        }
        
        /**
     * Determine the cardinality of the specified query
     * @param klass Concept class
     * @param keyName Key name
     * @param keyFields Key fields
     * @return The cardinality for the specified key and values.
     */
    protected static Integer cardinality(
            final Class<?> klass,
            final String keyName,
            final HashMap<String, Object> keyFields)
    {
        //
        // define the query
        //
        KeyManager keyManager = new KeyManager();
        KeyQuery keyQuery = keyManager.createKeyQuery((Class<?>) klass, keyName);
        KeyFieldValueList keyFieldValueList = new KeyFieldValueList();

        //
        // fill in the key fields
        //
        Set<String> fieldNames = keyFields.keySet();
        for (String fieldName : fieldNames)
        {
            keyFieldValueList.add(fieldName, keyFields.get(fieldName));
        }
        keyQuery.defineQuery(keyFieldValueList);
        
                if (TransactionService.isLoggerEnabledFor(Level.TRACE) == true)
        {
                TransactionService.log(Level.TRACE, "Cardinality: " + keyQuery.toString());
        }
        
        return keyQuery.cardinality();
    }

        /**
         * Map the lock mode value
         * @param lockMode User provided lock mode value
         * @return Mapped lock mode
         * <p>
         * A user provided lockMode value of read is mapped to a READLOCK.
         * <p>
         * A user provided lockMode value of write is mapped to WRITELOCK
         * <p>
         * All other values are mapped to NOLOCK.
         */
    // TODO - This should not be public
        public static LockMode mapLockMode(final String lockMode)
        {
            LockMode mappedValue = LockMode.NOLOCK;
            
            if (lockMode.equals("read") == true)
            {
                mappedValue = LockMode.READLOCK;
            }
            
            if (lockMode.equals("write") == true)
            {
                mappedValue = LockMode.WRITELOCK;
            }
            
            return mappedValue;
        }
        

        /**
     * Map the order-by direction
     * @param direction User provided order-by direction
     * @return Mapped order-by direction
     * <p>
     * A user provided direction value of descending is mapped to a DESCENDING.
     * <p>
     * All other values are mapped to ASCENDING.
     */
    protected static KeyOrderedBy mapOrderBy(final String direction)
    {
        KeyOrderedBy mappedValue = KeyOrderedBy.ASCENDING;
        
        if (direction.equals("descending") == true)
        {
            mappedValue = KeyOrderedBy.DESCENDING;
        }
        
        return mappedValue;
    }

        /**
     * Refresh the concept
     * <p>
     * Concept values are refreshed from shared memory.
     * @param original Concept to refresh.
     * @return Refreshed concept.  May be null.
     */
    // TODO - Currently required to be public because it is used in the
    // wrapper catalog function stubs
    public static com.tibco.cep.runtime.model.element.Concept
        refresh(com.tibco.cep.runtime.model.element.Concept original)
    {
        if (original == null)
        {
            return null;
        }
        
        assert original instanceof ConceptImpl == true : original;
         
        //
        //  Fetch a current view of this entity from shared memory
        //
        ConceptImpl current = (ConceptImpl)TransactionService.getInstance().fetchById(
                original.getId(), 
                original.getClass(), 
                ManagedObjectLockType.READLOCK);
        
        //
        //      Nothing do to if concept doesn't exist in shared memory - it was deleted
        //      directly in Java code
        //
        if (current == null)
        {
                return null;
        }
        
        assert original.getClass().getName().equals(current.getClass().getName()) == true : original;
        assert original.getProperties().length == current.getProperties().length : original;

        //
        //  Update the original handle with the current view from shared memory
        //
        for (Property p : current.getProperties())
        {
            //
            //  Refresh any references (or contained) concepts
            //
            if (p instanceof PropertyAtomConcept)
            {
                PropertyAtomConcept to = (PropertyAtomConcept)original.getPropertyAtom(p.getName());
                assert to != null : p.getName();
                
                if (to.getValue() == null)
                {
                        
                        to.setValue(((PropertyAtomConcept) p).getValue());
                        continue;
                }
                refresh((com.tibco.cep.runtime.model.element.Concept)to.getValue());
            }
            //
            //  Refresh arrays containing concepts
            //
            else if ((p instanceof PropertyArrayConceptReferenceSimple)
                        || (p instanceof PropertyArrayContainedConceptSimple))
            {
                PropertyArray from = (PropertyArray)p;
                PropertyArray to = original.getPropertyArray(p.getName());
                assert to != null : p.getName();
                PropertyAtom [ ] atoms = from.toArray();
                
                if ((atoms == null) || (atoms.length == 0))
                {
                        copyArray(from, to);
                        continue;
                }
                com.tibco.cep.runtime.model.element.Concept [ ] concepts 
                        = new com.tibco.cep.runtime.model.element.Concept[atoms.length];
                for (int i = 0; i < atoms.length; i++)
                {
                        if (atoms[i].getValue() == null)
                        {
                                continue;
                        }
                        assert atoms[i].getValue() instanceof ConceptImpl : atoms[i].getValue();
                        ConceptImpl c = (ConceptImpl)atoms[i].getValue();
                        
                        //
                        //      Clear parent reference.  It will be reset when concept is refreshed
                        //
                        c.setParentReference(null);
                        concepts[i] = refresh(c);
                }
                copyArray(from, to);
            }
            //
            //  Primitive types
            //
            else if (p instanceof PropertyAtom)
            {
                try
                {
                    PropertyAtom from = (PropertyAtom)p;
                    PropertyAtom to = original.getPropertyAtom(p.getName());
                    assert to != null : p.getName();
 
                    if (from.getValue() == null && to.getValue() == null)
                    {
                        continue;
                    }
                    if (((from.getValue() == null) && (to.getValue() != null))
                            || (from.getValue().equals(to.getValue()) == false))
                    {
                        to.setValue(from.getValue());
                    }
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                }
            }
            //
            //  Arrays of primitive types
            //
            else
            {
                assert p instanceof PropertyArray : p.getName();
                PropertyArray from = (PropertyArray)p;
                PropertyArray to = original.getPropertyArray(p.getName());
                assert to != null : p.getName();
                
                copyArray(from, to);
            }
        }
        return original;
    }
    
    /**
     * Refresh an array of concepts
     * <p>
     * All concepts in the array are refreshed from shared memory
     * @param concepts Concept array to refresh
     */
    // TODO - Currently required to be public because it is used in the 
    // wrapper catalog function stubs
    public static void refreshArray(
            com.tibco.cep.runtime.model.element.Concept [ ] concepts)
    {
        if (concepts == null)
        {
                return;
        }
        
        for (com.tibco.cep.runtime.model.element.Concept c : concepts)
        {
            refresh(c);
        }
    }
    
    /**
     * Update a concept in shared memory
     * <p>
     * Flush concepts to shared memory
     * @param concept Concept to flush to shared memory.
     */
    // TODO - Currently required to be public because it is used in the
    // wrapper catalog function stubs
    public static void update(com.tibco.cep.runtime.model.element.Concept concept)
    {
        if (concept == null)
        {
            return;
        }
        
                if (TransactionService.isLoggerEnabledFor(Level.TRACE) == true)
        {
                TransactionService.log(Level.TRACE, "Updating concept " + concept);
        }
        
        assert concept instanceof ConceptImpl : concept;
        ConceptImpl conceptImpl = (ConceptImpl)concept;
        Entity me = Entity.lookupById(conceptImpl.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(conceptImpl);       
        }
        else
        {
                TransactionService.getInstance().update(conceptImpl);
        }
       
        //
        //      Recursively update any concept properties
        //
        for (Property p : concept.getProperties())
        {
            if (p instanceof PropertyAtomConcept)
            {
                PropertyAtomConcept c = (PropertyAtomConcept)p;
                if (c.isSet() == false)
                {
                        continue;
                }
                update((com.tibco.cep.runtime.model.element.Concept)c.getValue());
            }
        }
    }
    
    /**
     * Update an array of concepts
     * <p>
     * All concepts in the array are updated in shared memory 
     * if they have been modified in the current RTC.
     * @param concepts Concept array to update
     */
    // TODO - Currently required to be public because it is used in the 
    // wrapper catalog function stubs
    public static void updateArray(
            com.tibco.cep.runtime.model.element.Concept [ ] concepts)
    {
        if (concepts == null)
        {
                return;
        }
        
        for (com.tibco.cep.runtime.model.element.Concept c : concepts)
        {
            update(c);
        }
    }
    
    /**
     * Set the parent identifier for a contained type
     * @param parent Parent identifier
     */
    protected final void setParent(long parent)
    {
        m_parent = parent;
    }
    
    /**
     * Get the parent identifier for a contained type
     * @return Parent identifier;
     */
    protected final long getParent()
    {
        return m_parent;
    }
    
    /**
     * Map auto-box array to primitive array
     * @param a Array to map
     * @return Mapped array
     */
    protected final long [ ] toPrimitiveArray(Long [ ] a)
    {
        if (a == null)
        {
                return null;
        }
        long [ ] n = new long[a.length];
        for (int i = 0; i < a.length; i++)
        {
                n[i] = a[i];
        }
        return n;
    }
    
    /**
     * Map auto-box array to primitive array
     * @param a Array to map
     * @return Mapped array
     */
    protected final int [ ] toPrimitiveArray(Integer [ ] a)
    {
        if (a == null)
        {
                return null;
        }
        int [ ] n = new int[a.length];
        for (int i = 0; i < a.length; i++)
        {
                n[i] = a[i];
        }
        return n;
    }
    
    /**
     * Map auto-box array to primitive array
     * @param a Array to map
     * @return Mapped array
     */
    protected final boolean [ ] toPrimitiveArray(Boolean [ ] a)
    {
        if (a == null)
        {
                return null;
        }
        boolean [ ] n = new boolean[a.length];
        for (int i = 0; i < a.length; i++)
        {
                n[i] = a[i];
        }
        return n;       
    }
    
    /**
     * Map auto-box array to primitive array
     * @param a Array to map
     * @return Mapped array
     */
    protected final double [ ] toPrimitiveArray(Double [ ] a)
    {
        if (a == null)
        {
                return null;
        }
        double [ ] n = new double[a.length];
        for (int i = 0; i < a.length; i++)
        {
                n[i] = a[i];
        }
        return n;               
    }
    
    /**
     * Map auto-box array to primitive array
     * @param a Array to map
     * @return Mapped array
     */
    protected final String [ ] toPrimitiveArray(String [ ] a)
    {
        return a;               
    }
    
    /**
     * Map auto-box array to primitive array
     * @param a Array to map
     * @return Mapped array
     */
    protected final Date [ ] toPrimitiveArray(Date [ ] a)
    {
        return a;               
    }
    
    //
    //  Copy an array
    //
    private static void copyArray(PropertyArray from, PropertyArray to)
    {   
        //
        //      Grow the target array
        //
        if (from.length() > to.length())
        {
            for (int i = to.length(); i < from.length(); i++)
            {
                to.add(i, from.get(i).getValue());
            }
        }
        
        //
        //      Shrink the target array
        //
        if (to.length() > from.length())
        {
                int originalLength = to.length();
            for (int i = from.length(); i < originalLength; i++)
            {
                assert to.length() > 0 : to.length();
                to.remove(to.length() - 1);
            }
        }
        
        assert from.length() == to.length() : 
                from.getName() + "(" + from.length() + "):" 
                + to.getName() + "(" + to.length() + ")";
        
        //
        //      Update changed values
        //
        for (int i = 0; i < from.length(); i++)
        {
            if (from.get(i).getValue().equals(to.get(i).getValue()) == false)
            {
                to.get(i).setValue(from.get(i).getValue());
            }
        }
    }
    
    private long m_parent = IdentifierGenerator.RESERVED_FOR_EMPTY_INDICATOR;
        private static final long serialVersionUID = 5L;
}