//
// Name
//  $RCSfile: Record.java,v $
//
// Copyright
//  Copyright 2014-2015 Cloud Software Group, Inc. ALL RIGHTS RESERVED.
//  Cloud Software Group, Inc. Confidential Information
//
// History
//  $Revision: 1.1.2.7 $ $Date: 2015/01/29 01:48:38 $
//
package com.kabira.store;

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

import java.util.HashSet;

/**
 * Class for receiving notifications of
 * modifications (create, update, delete)
 * to Managed object instances.
 * <p>
 * This notifier provides an opportunity to see Managed
 * objects modified within a transaction.
 * For example, it could be used for updating records in a database, or
 * for doing a Managed object change log.
 *
 * @param <T>   Managed type parameter
 */
@Managed
public abstract class Record<T> extends RecordBase
{
    // This must map to the notifier::Modification modeled enum values.
    private static final int BaseNotifier_Created = 1;
    private static final int BaseNotifier_Deleted = 2;
    private static final int BaseNotifier_Modified = 3;

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

    /** Constructor.
     * <p>
     * Creating an instance automatically installs it
     * as the record notifier for Managed class <code>T</code>.
     * <p>
     * If a notifier is already installed for the class,
     * 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>
     * A separate notifier may be set for each class in a hierarchy.
     * <p>
     * If no notifier is installed for a class,
     * it inherits the notifier of its parent.
     *
     * @param klass The Managed class base to receive notifications for.
     * @throws ManagedClassError <code>klass</code> is not managed.
     */
    protected Record(final Class<T> klass) throws ManagedClassError
    {
        audit(klass);

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

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

    /**
     * Return the currently installed Record notifier for
     * a Managed class.
     * <b>Note:</b>
     * Inheritance is not examined by this method.
     * If there is no notifier for the Managed class
     * null is returned.
     *
     * @param klass The class to search.
     * @return Record or null.
     * @throws com.kabira.platform.ManagedClassError if
     *         <code>klass</code> is not managed.
     */
    public static Record<?> getNotifier(final Class<?> klass)
    {
        audit(klass);
        return (Record)StoreUtil.getRecordNotifier(klass.getName());
    }

    /**
     * Notifier method for a created Managed object.
     * <p>
     * Called for each object created (but not deleted) within the transaction.
     * @param object The created object.
     *                  This may be a subtype of the notifier's managed
     *                  class type.
     */
    public void created(final T object)
    {
    }

    /**
     * Notifier method for a modified Managed object.
     * <p>
     * Called for each object modified
     * (but not created or deleted) within the transaction.
     * <p>
     * @param object The modified object.
     *                  This may be a subtype of the notifier's managed
     *                  class type.
     */
    public void modified(final T object)
    {
    }

    /**
     * Notifier method for a deleted Managed object.
     * <p>
     * Called when {@link ManagedObject#delete} is called by the application.
     * <p>
     * @param object The deleted object.
     *                  This may be a subtype of the notifier's managed
     *                  class type.
     */
    public void deleted(final T object)
    {
    }

    private void modifiedInternal(
            final T object, final int baseNotifierModification)
    {
        if (baseNotifierModification == BaseNotifier_Modified)
        {
            modified(object);
        }
        else if (baseNotifierModification == BaseNotifier_Created)
        {
            created(object);
        }
        else
        {
            assert baseNotifierModification == BaseNotifier_Deleted
                : baseNotifierModification + " != BaseNotifier.Deleted";
            deleted(object);
        }
    }

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

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

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

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