//
// Name
//      $RCSfile: Notifier.java,v $
//
// COPYRIGHT
//      Copyright 2009-2015 Cloud Software Group, Inc. ALL RIGHTS RESERVED.
//      Cloud Software Group, Inc. Confidential Information
//
// History
//      $Revision: 1.1.2.20 $ $Date: 2015/01/20 00:32:10 $
//      $Source: /opt/cvs-dtm/switchcore/ktvm/component/com/kabira/platform/component/Attic/Notifier.java,v $
//
package com.kabira.platform.component;

import com.kabira.platform.classloader.ClassLoader;
import com.kabira.platform.property.Status;
import java.io.File;
import java.net.URL;

/**
 * Component state change notifier class. <p> A Notifier class may choose to
 * override any of the methods. The default implementation does nothing. <p>
 * Notifier methods are called from within a transaction.
 */
public class Notifier
{
    static final String className = "com.kabira.platform.component.Notifier";

    private final com.kabira.platform.classloader.ClassLoader m_classLoader;
    
    private static final char WindowsSeparator = '\\';
    private static final char UnixSeparator = '/';
    private static final String TargetNameProperty =
            "com.kabira.platform.component.target.name";
    private static final String TargetParametersProperty =
            "com.kabira.platform.component.target.parameters";
    private static final String TargetParametersPropertySeparator = ",";

    /**
     * Prevent direct instantiation.
     */
    protected Notifier()
    {
        m_classLoader = (ClassLoader) getClass().getClassLoader();

        // we are not reading the TargetName and TargetNameParmeters
        // properties here, to allow for some testing within a single
        // JVM run in componenttest
    }

    /**
     * Called before any configuration files for the component currently being
     * activated have been loaded and activated.
     *
     * @throws ComponentException Used to communicate a fatal initialize error.
     */
    protected void preConfigurationInitialize() throws ComponentException
    {
    }

    /**
     * Called after all configuration files for the component currently being
     * activated have been loaded and activated.
     *
     * @throws ComponentException Used to communicate a fatal initialization
     * error.
     */
    protected void postConfigurationInitialize() throws ComponentException
    {
    }

    /**
     * Called during component deactivation before any of the configuration
     * files from this component have been deactivated and unloaded.
     */
    protected void preConfigurationTerminate()
    {
    }

    /**
     * Called during component deactivation after all of the configuration files
     * from this component have been deactivated and unloaded.
     */
    protected void postConfigurationTerminate()
    {
    }

    /**
     * Returns the name of the target provided to the deploy tool when the
     * current JVM was deployed.
     *
     * @return target name.
     */
    protected final String getTargetName()
    {
        return getFileName(getFullTargetName());
    }

    /**
     * Returns a handle to a local copy of the target archive or file
         * specified to the
     * deploy tool when the current JVM was deployed.
     *
     * Returns null if the current target is not an archive or file.
     *
     * @return target archive or file
     */
    protected final File getTargetArchive()
    {
        String targetName = getTargetName();
        
        // if detached, it may have been copied to the JVM's classpath
        // directory, or if not there, then it has to be in the deploy
        // directories.

        URL url = m_classLoader.getResource(getFileName(targetName));

        if (url == null)
        {
            return ComponentUtils.getFileFromDeployDirectories(
                getFileName(targetName));
        }

        return new File(url.getFile());
    }

    /**
     * Returns a handle to a local copy of the requested file.
     * 
     * This method will be removed from the public interface in a 
     * future release.  There is no replacement.
     *
     * @param resourceName Name of the file to find. Path information
     *                     is ignored.
     *
     * @return The copy of the file. null is returned if the file cannot be
     * found.
     * 
     * @throws ComponentException - no longer used.
     */
    @Deprecated
    protected final File getResource(final String resourceName)
            throws ComponentException
    {
        Log.debug("getResource(" + resourceName + ")");

        String fileName = getFileName(resourceName);
            
        // The client either already copied the file to the application
        // classpath folder.

        URL url = m_classLoader.getResource(fileName);

        // Or the user put it in a deploy directory.
        if (url == null)
        {
            return ComponentUtils.getFileFromDeployDirectories(fileName);
        }

        return new File(url.getFile());
    }

    /**
     * Returns the application parameters provided to the deploy tool when the
     * current JVM was deployed.
     *
     * @return deployment tool application parameters
     */
     protected final String[] getApplicationParameters()
    {
        String parameters = getTargetParametersPropertyValue();
        
        if (parameters == null)
        {
            return null;
        }
        
        return parameters.split(TargetParametersPropertySeparator);
    }

    /**
     * Returns a server-side directory which can be used for creating JVM
     * specific artifacts.
         * <p>
         * Null is returned if the output directory found or created.
     *
     * @return The output directory for the calling JVM.
     */
    protected final File getOutputDirectory()
    {
        final String errorPrefix = "getOutputDirectory failure: ";
        final String outputDirName = System.getProperty(Status.CLASS_PATH);

        if (outputDirName == null)
        {
            Log.warning(errorPrefix + "cannot find directory");
            return null;
        }

        File outputDir = new File(outputDirName);

        if (!(outputDir.isDirectory()
                && outputDir.canExecute()
                && outputDir.canRead()
                && outputDir.canWrite()))
        {
            Log.warning(errorPrefix
                    + "directory permission problems on " + outputDirName);
            return null;
        }

        return outputDir;
    }

    /**
     * Adds to the class path of the current JVM.
     *
     * @param file The jar or directory to add to the class path.
     */
    protected final void addToClassPath(final File file)
    {
        m_classLoader.addToClasspath(file.getPath());
    }

    private String getFileName(final String fileAndPath)
    {
        // fileAndPath may contain client side path information, from
        // either Windows or a Unix client.   Break it into path and file
        // name.

        int lastUnixPos = fileAndPath.lastIndexOf(UnixSeparator);
        int lastWindowsPos = fileAndPath.lastIndexOf(WindowsSeparator);
        int lastPos = Math.max(lastUnixPos, lastWindowsPos);

        String fileName = fileAndPath;

        if (lastPos >= 0)
        {
            assert (fileAndPath.length() > lastPos);
            fileName = fileAndPath.substring(lastPos + 1);
        }

        return fileName;
    }
    
    private String getFullTargetName()
    {
        String targetName = getTargetNamePropertyValue();
  
        assert targetName != null;
        
        return getFileName(targetName);
    }
    
    private String getTargetNamePropertyValue()
    {
        return System.getProperty(TargetNameProperty);
    }
    
    private String getTargetParametersPropertyValue()
    {
        return System.getProperty(TargetParametersProperty);
    }
}