//
// Name
//  $RCSfile: Query.java,v $
//
// Copyright
//  Copyright 2014 Cloud Software Group, Inc. ALL RIGHTS RESERVED.
//  Cloud Software Group, Inc. Confidential Information
//
// History
//  $Revision: 1.1.2.9.2.1 $ $Date: 2015/10/08 22:36:03 $
//
package com.kabira.store;

import com.kabira.platform.*;
import com.kabira.platform.annotation.Key;
import com.kabira.platform.annotation.KeyList;
import com.kabira.platform.annotation.Managed;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectStreamField;
import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.HashSet;

/**
 * Class for receiving notifications of
 * {@link com.kabira.platform.KeyQuery} results calls.
 * <p>
 * A <code>Query</code> notifier does not directly return results.
 * The notification provides an opportunity to change the contents of
 * shared memory (creating and or deleting Managed objects) before
 * a keyed query is done.
 * For example, it could be used for creating Managed objects from data
 * in a database.
 */
@Managed
public abstract class Query<T> extends QueryBase
{
    private static final int RangeQueryType_RangeQuery = 1;
    private static final int RangeQueryType_MinimumQuery = 2;
    private static final int RangeQueryType_MaximumQuery = 3;

    // FIX THIS, DS: these are a copy from KeyQuery.java
    //               but I don't want to make them public there.
    //
    // enumeration values for ObjSrv::RangeOperator
    static final int ObjSrv_EQ       = 1;
    static final int ObjSrv_NEQ      = 2;
    static final int ObjSrv_GTE      = 3;
    static final int ObjSrv_GT       = 4;
    static final int ObjSrv_LTE      = 5;
    static final int ObjSrv_LT       = 6;
    // enumeration values for OSKeyOpt::ObjectLock
    static final int KeyOptReadLock  = 1;
    static final int KeyOptWriteLock = 2;
    static final int KeyOptNoLock    = 3;

    // force usage of protected ctor
    private Query()
    {
    }

    /** Constructor.
     * <p>
     * Creating an instance automatically installs it
     * as the query notifier for the associated Managed class and key.
     * <p>
     * A notifier may only be set on the class where the key is defined.
     * <p>
     * The notifier will apply to queries on the class where the key is
     * defined, and queries on classes which inherit the key.
     * <p>
     * If a notifier is already installed for the key,
     * the new instance replaces the previous instance.
     * <p>
     * Deleting a notifier automatically uninstalls it.
     * <p>
     * Notifiers are automatically deleted when the JVM shuts down.
     * Notifiers created in other JVMs are not affected.
     * <p>
     * When a {@link KeyQuery} results method is called, the Query notifier
     * for the key will be called before executing the query.
     *
     * @param klass The Managed class where
     *              <code>keyName</code> is defined.
     * @param keyName      The key to receive query notifications for.
     *
     * @throws ManagedClassError    If <code>klass</code> is not managed.
     *
     * @throws KeyUnknownKeyNameError if <code>keyName</code> is not
     *         defined on <code>klass</code>.
     */
    protected Query(final Class<T> klass, final String keyName)
        throws ManagedClassError, KeyUnknownKeyNameError
    {
        audit(klass, keyName);

        m_className = klass.getName();
        m_keyName = keyName;
        install();
        NotifierHash.addToHash(this);
    }

    /**
     * Return the currently installed Query notifier for
     * the Managed class and key.
     * <p>
     * Inheritance is not examined by this method.
     *
     * @param klass  Class where key is defined.
     * @param key    Name of key.
     * @return Query or null.
     * @throws ManagedClassError If <code>klass</code> is not managed.
     * @throws KeyUnknownKeyNameError If <code>keyName</code> is not
     *         defined on <code>klass</code>.
     */
    public static Query<?> getNotifier(
            final Class<?> klass, final String key)
    {
        audit(klass, key);
        return (Query)StoreUtil.getQueryNotifier(klass.getName(), key);
    }

    /**
     * Get the name of the key for this Query notifier.
     * @return Key name.
     */
    public final String getKeyName()
    {
        return m_keyName;
    }

    /**
     * Notifier method for {@link KeyQuery} results calls.
     * <p>
     * Called by the system when following KeyQuery methods are called,
     * but before they are executed:
     * <p>
     * {@link KeyQuery#getOrCreateSingleResult} - for unique keys
     * <p>
     * {@link KeyQuery#getSingleResult} - for unique keys
     * <p>
     * {@link KeyQuery#getResults} - for non unique keys
     * <p>
     * {@link com.kabira.platform.KeyOrderedBy} does not need to be
     * considered by the notifier.
     * Result set ordering is handled by the runtime when the
     * query executes.
     * <p>
     * Will be called on each of the nodes in the
     * {@link com.kabira.platform.QueryScope} of the KeyQuery results call.
     * <p>
     * Work done within Query.query() will not
     * generate calls to com.kabira.store notifiers on the local node.
     * <p>
     * <b>Note:</b> work done within the Query.query() method will generate
     * calls to com.kabira.store notifiers on remote nodes.
     *
     * @param klass    The Managed class for the query results call.
     *                 This may be a subtype of the class
     *                 associated with the notifier.
     * @param lockMode The lock mode for the query results. The notifier
     *                 implementation should attempt to honor this lock mode,
     *                 but there is no enforcement.
     * @param queryData The query data, ordered as the caller added it
     *                  to the {@link com.kabira.platform.KeyFieldValueList}
     *                  or {@link com.kabira.platform.KeyFieldValueRangeList}
     *                  for the query.
     *                  See {@link KeyField}.
     */
    public abstract void query(
            final Class<? extends T> klass,
            final LockMode lockMode,
            final ArrayList<KeyField> queryData);

    /**
     * Notifier method for {@link KeyQuery#getMinimumResult} calls.
     * <p>
     * Called by the system when KeyQuery.getMinimumResult
     * is called, but before it is executed.
     * <p>
     * Will be called on each of the nodes in the
     * {@link com.kabira.platform.QueryScope} of getMinimumResult
     * call.
     * <p>
     * Work done within Query.queryMinimum() will not
     * generate calls to com.kabira.store notifiers on the local node.
     * <p>
     * <b>Note:</b> work done within Query.queryMinimum() will generate
     * calls to com.kabira.store notifiers on remote nodes.
     *
     * @param klass    The Managed class for the getMinimumResult call.
     *                 This may be a subtype of the class associated
     *                 with the notifier.
     * @param lockMode The lock mode for the query result. The notifier
     *                 implementation should attempt to honor this lock mode,
     *                 but there is no enforcement.
     * @param queryData The query data, ordered as the caller added it
     *                  to the {@link com.kabira.platform.KeyFieldValueList}
     *                  or {@link com.kabira.platform.KeyFieldValueRangeList}
     *                  for the query.
     *                  See {@link KeyField}.
     */
    public abstract void queryMinimum(
            final Class<? extends T> klass,
            final LockMode lockMode,
            final ArrayList<KeyField> queryData);

    /**
     * Notifier method for {@link KeyQuery#getMaximumResult} calls.
     * <p>
     * Called by the system when KeyQuery.getMaximumResult
     * is called, but before it is executed.
     * <p>
     * Will be called on each of the nodes in the
     * {@link com.kabira.platform.QueryScope} of getMaximumResult
     * call.
     * <p>
     * Work done within Query.queryMaximum() will not
     * generate calls to com.kabira.store notifiers on the local node.
     * <p>
     * <b>Note:</b> work done within Query.queryMaximum() will generate
     * calls to com.kabira.store notifiers on remote nodes.
     *
     * @param klass    The Managed class for the getMaximumResult call.
     *                 This may be a subtype of the class associated with
     *                 the notifier.
     * @param lockMode The lock mode for the query result. The notifier
     *                 implementation should attempt to honor this lock mode,
     *                 but there is no enforcement.
     * @param queryData The query data, ordered as the caller added it
     *                  to the {@link com.kabira.platform.KeyFieldValueList}
     *                  or {@link com.kabira.platform.KeyFieldValueRangeList}
     *                  for the query.
     *                  See {@link KeyField}.
     */
    public abstract void queryMaximum(
            final Class<? extends T> klass,
            final LockMode lockMode,
            final ArrayList<KeyField> queryData);

    void querySimpleInternal(
            final Class<? extends T> klass,
            final int objSrvLockMode,
            final ManagedObjectInputStream keyStream)
            throws IOException, ClassNotFoundException
    {
        ManagedObjectStreamClass keyDesc = keyStream.getStreamClass();
        LockMode lockMode = mapLockMode(objSrvLockMode);
        ArrayList<KeyField> queryData = buildQueryData(keyDesc, keyStream);

        query(klass, lockMode, queryData);
    }

    void queryOrderedInternal(
            final Class<? extends T> klass,
            final int objSrvLockMode,
            final int rangeQueryType,
            final ManagedObjectStreamClass keyDesc1,
            final ManagedObjectInputStream keyStream1,
            final int rop1,
            final ManagedObjectStreamClass keyDesc2,
            final ManagedObjectInputStream keyStream2,
            final int rop2,
            final ManagedObjectStreamClass keyDesc,
            final KeyFilter[] filters)
            throws IOException, ClassNotFoundException
    {
        LockMode lockMode = mapLockMode(objSrvLockMode);
        ArrayList<KeyField> queryData = buildQueryData(
                keyDesc1, keyStream1, rop1, keyDesc2,
                keyStream2, rop2, keyDesc, filters);

        if (rangeQueryType == RangeQueryType_RangeQuery)
        {
            query(klass, lockMode, queryData);
        }
        else if (rangeQueryType == RangeQueryType_MinimumQuery)
        {
            queryMinimum(klass, lockMode, queryData);
        }
        else
        {
            assert rangeQueryType == RangeQueryType_MaximumQuery
                : rangeQueryType + " != " + RangeQueryType_MaximumQuery;
            queryMaximum(klass, lockMode, queryData);
        }
    }

    private static void audit(final Class<?> klass, final String keyName)
    {
        if (! ManagedObject.isManagedClass(klass))
        {
            throw new ManagedClassError(
                    klass.getName() + " is not @Managed");
        }

        for (Annotation annotation :  klass.getDeclaredAnnotations())
        {
            Class<?> annotationClass = annotation.annotationType();

            if (annotationClass == Key.class)
            {
                if (((Key)annotation).name().equals(keyName))
                {
                    return;
                }
            }
            else if (annotationClass == KeyList.class)
            {
                KeyList keyList = (KeyList)annotation;

                for (Key key : keyList.keys())
                {
                    if (key.name().equals(keyName))
                    {
                        return;
                    }
                }
            }
        }

        throw new KeyUnknownKeyNameError(
                "Key " + keyName + " is not defined on "
                + "Managed class " + klass.getName());
    }

    private LockMode mapLockMode(final int objSrvLockMode)
    {
        switch (objSrvLockMode)
        {
            case KeyOptNoLock:
                return LockMode.NOLOCK;
            case KeyOptReadLock:
                return LockMode.READLOCK;
        }

        assert objSrvLockMode == KeyOptWriteLock;

        return LockMode.WRITELOCK;
    }

    static KeyComparisonOperator mapComparisonOp(final int rop)
    {
        switch (rop)
        {
            case ObjSrv_EQ:
                return KeyComparisonOperator.EQ;
            case ObjSrv_GT:
                return KeyComparisonOperator.GT;
            case ObjSrv_GTE:
                return KeyComparisonOperator.GTE;
            case ObjSrv_LT:
                return KeyComparisonOperator.LT;
            case ObjSrv_LTE:
                return KeyComparisonOperator.LTE;
        }

        assert rop == ObjSrv_NEQ;
        return KeyComparisonOperator.NEQ;
    }

    // filter ops are the opposite of comparison ops
    static KeyComparisonOperator mapFilterOp(final int rop)
    {
        switch (rop)
        {
            case ObjSrv_EQ:
                return KeyComparisonOperator.NEQ;
            case ObjSrv_GT:
                return KeyComparisonOperator.LTE;
            case ObjSrv_GTE:
                return KeyComparisonOperator.LT;
            case ObjSrv_LT:
                return KeyComparisonOperator.GTE;
            case ObjSrv_LTE:
                return KeyComparisonOperator.GT;
        }

        assert rop == ObjSrv_NEQ;
        return KeyComparisonOperator.EQ;
    }

    private ArrayList<KeyField> buildQueryData(
            final ManagedObjectStreamClass keyDescription,
            final ManagedObjectInputStream keyStream)
            throws IOException, ClassNotFoundException
    {
        ArrayList<KeyField> queryData = new ArrayList<KeyField>();

        ObjectInputStream.GetField gf = keyStream.readFields();

        for (ObjectStreamField field : keyDescription.getFields())
        {
            final String fieldName = field.getName();
            final Object value = gf.get(fieldName, null);
            final KeyField keyField =
                    new KeyField(fieldName, value, KeyComparisonOperator.EQ);

            queryData.add(keyField);
        }

        return queryData;
    }

    private ArrayList<KeyField> buildQueryData(
            final ManagedObjectStreamClass keyDescription1,
            final ManagedObjectInputStream keyStream1,
            final int rop1,
            final ManagedObjectStreamClass keyDescription2,
            final ManagedObjectInputStream keyStream2,
            final int rop2,
            final ManagedObjectStreamClass keyDescription,
            final KeyFilter[] filters)
            throws IOException, ClassNotFoundException
    {
        ArrayList<KeyField> queryData = new ArrayList<KeyField>();
        ObjectInputStream.GetField gf;
        KeyComparisonOperator rop;

        if (keyStream1 != null)
        {
            gf = keyStream1.readFields();
            rop = mapComparisonOp(rop1);

            for (ObjectStreamField field : keyDescription1.getFields())
            {
                final String fieldName = field.getName();
                queryData.add(new KeyField(
                    fieldName, gf.get(fieldName, null), rop));
            }
        }

        if (keyStream2 != null)
        {
            gf = keyStream2.readFields();
            rop = mapComparisonOp(rop2);

            for (ObjectStreamField field : keyDescription2.getFields())
            {
                final String fieldName = field.getName();
                queryData.add(new KeyField(
                    fieldName, gf.get(fieldName, null), rop));
            }
        }

        if (filters != null)
        {
            for (KeyFilter filter : filters)
            {
                gf = filter.m_keyData.readFields();

                int keyDepth = filter.m_keyDepth;

                final ObjectStreamField[] fields = keyDescription.getFields();

                assert keyDepth < fields.length;
                final ObjectStreamField field = fields[keyDepth];

                final String fieldName = field.getName();
                queryData.add(new KeyField(
                        fieldName, gf.get(fieldName, null), filter.m_rop));
            }
        }

        return queryData;
    }

    static
    {
        Runtime.getRuntime().addShutdownHook(new Thread()
        {
            @Override
            public void run()
            {
                new Transaction("Query notifier shutdown")
                {
                    @Override
                    protected void run()
                    {
                        NotifierHash.clearNotifiers();
                    }
                }.execute();
            }
        });
    }

    private static class NotifierHash
    {
        static final HashSet<Query<?>> m_installedNotifiers
                = new HashSet<Query<?>>();

        static void addToHash(final Query<?> notifier)
        {
            m_installedNotifiers.add(notifier);
        }

        static void clearNotifiers()
        {
            for (Query<?> query : m_installedNotifiers)
            {
                if (! ManagedObject.isEmpty(query))
                {
                    ManagedObject.delete(query);
                }
            }
        }
    }
}