/* 
    * Copyright (c) 2007, Fraunhofer-Gesellschaft
    * All rights reserved.
    * 
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions are
    * met:
    * 
    * (1) Redistributions of source code must retain the above copyright
   *     notice, this list of conditions and the disclaimer at the end.
   *     Redistributions in binary form must reproduce the above copyright
   *     notice, this list of conditions and the following disclaimer in
   *     the documentation and/or other materials provided with the
   *     distribution.
   * 
   * (2) Neither the name of Fraunhofer nor the names of its
   *     contributors may be used to endorse or promote products derived
   *     from this software without specific prior written permission.
   * 
   * DISCLAIMER
   * 
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   *  
   */
  package org.ogf.graap.wsag.wsrf;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.text.MessageFormat;
  import java.util.List;
  import java.util.Properties;
  import java.util.Vector;
  
  import javax.security.auth.login.LoginContext;
  
  import org.apache.log4j.Logger;
  import org.apache.xml.resolver.tools.CatalogResolver;
  import org.apache.xmlbeans.XmlException;
  import org.apache.xmlbeans.XmlObject;
  import org.ogf.graap.wsag.api.WsagConstants;
  import org.ogf.graap.wsag.api.configuration.WSAG4JConfiguration;
  import org.ogf.graap.wsag.api.logging.LogMessage;
  import org.ogf.graap.wsag.server.api.WsagMessageContext;
  import org.ogf.graap.wsag.server.engine.WsagEngine;
  import org.ogf.graap.wsag.server.persistence.EmfRegistry;
  import org.ogf.graap.wsag.server.persistence.IAgreementFactoryHome;
  import org.ogf.graap.wsag.server.persistence.PersistentAgreementFactory;
  import org.ogf.graap.wsag4j.types.configuration.ConfigurationDocument;
  import org.ogf.graap.wsag4j.types.configuration.ConfigurationType;
  import org.ogf.graap.wsag4j.types.configuration.WSAG4JEngineConfigurationDocument;
  import org.ogf.graap.wsag4j.types.configuration.WSAG4JEngineConfigurationType;
  import org.ogf.graap.wsag4j.types.configuration.WSAG4JEngineInstanceType;
  import org.ogf.graap.wsag4j.types.configuration.WSRFEngineConfigurationType;
  import org.quartz.Scheduler;
  import org.quartz.SchedulerException;
  import org.quartz.SchedulerFactory;
  import org.quartz.impl.StdSchedulerFactory;
  
  /**
   * The WSAGEngine provides access to all agreement factories configured for this engine. The available
   * factories can be retrieved via the agreement factory home interface. The agreement factory home is
   * retrieved by the {@link #getAgreementFactoryHome()} method. Before the engine can be used it must be
   * initialized. Engine initialization is triggered by the {@link #initializeEngine(String)} method.
   * 
   * @author Oliver Waeldrich
   * 
   */
  public class WsrfEngine
  {
  
      private static final Logger LOG = Logger.getLogger( WsrfEngine.class );
  
      private static ThreadLocal<WsagMessageContext> messageContext = null;
  
      private static WsrfEngine engine = null;
  
      private WSRFEngineConfigurationType wsrfConfiguration = null;
  
      private String deploymentURI = null;
  
      private LoginContext serverLoginContext;
  
      private WSAG4JPersistenceFacade agreementFactoryHome;
  
      private boolean allowAnonymousAccess = false;
  
      /**
       * Allows to specify an alternate filename for the wsrf-engine configuration via the system properties.
       * 
      * @see System#setProperty(String, String)
      */
     public static final String WSAG4J_WSRF_ENGINE_FILE_NAME = "wsag4j.wsrf-engine.config.filename";
 
     /**
      * Returns the message context for the current invocation (thread).
      * 
      * @return the message context
      */
     public static WsagMessageContext getWsagMessageContext()
     {
 
         synchronized ( messageContext )
         {
             WsagMessageContext wsagcontext = messageContext.get();
 
             if ( wsagcontext == null )
             {
                 wsagcontext = new WsagMessageContext();
                 messageContext.set( wsagcontext );
             }
 
             return wsagcontext;
         }
     }
 
     /**
      * Sets the message context for the current invocation (thread).
      * 
      * @param context
      *            the message context
      */
     public static void setWsagMessageContext( WsagMessageContext context )
     {
         WsrfEngine.messageContext.set( context );
     }
 
     private static synchronized WsrfEngine getInstance()
     {
         if ( engine == null )
         {
             engine = new WsrfEngine();
         }
 
         return engine;
     }
 
     /**
      * Initializes the WSAG4J Engine. During the initialization process the WSRF engine configuration (system
      * configuration) is parsed and the referenced WSAG4J engine configurations (factory configurations) are
      * loaded. The WSAG4J engine must be initialized before making any calls to the system. By default the
      * WSRF engine configuration location is specified by the
      * {@link WsagConstants#WSAG4J_WSRF_ENGINE_CONFIG_FILE} constant. This value can be overwritten by the
      * system property {@value #WSAG4J_WSRF_ENGINE_FILE_NAME}.
      * 
      * @param defaultGatewayURL
      *            the default gateway URL
      * 
      * @throws Exception
      *             indicates an error during engine initialization
      */
     public static void initializeEngine( String defaultGatewayURL ) throws Exception
     {
         getInstance().initialize( defaultGatewayURL );
     }
 
     private void initialize( String defaultGatewayURL ) throws Exception
     {
         LOG.trace( "start initialization of wsag4j wsrf engine" );
 
         //
         // set the CatalogResolver as default entity resolver for XmlBeans
         //
         System.setProperty( "xmlbean.entityResolver", CatalogResolver.class.getName() );
 
         messageContext = new ThreadLocal<WsagMessageContext>();
 
         LOG.trace( "loading wsrf engine configuration" );
         wsrfConfiguration = loadWsrfConfiguration();
 
         LOG.trace( "initializing wsrf engine gateway url" );
         initializeGatewayURI( wsrfConfiguration, defaultGatewayURL );
 
         LOG.trace( "loading wsag4j engine configurations" );
         WSAG4JEngineConfigurationType[] engineConfigs = loadEngineConfigurations( wsrfConfiguration );
 
         LOG.trace( "intializing wsag4j engine instances" );
         List<WsagEngine> initializedEngines = initializeWsagEngines( engineConfigs );
 
         LOG.trace( "intializing wsrf engine persistence layer facade" );
         WsagEngine[] wsagEngines = initializedEngines.toArray( new WsagEngine[initializedEngines.size()] );
         agreementFactoryHome = initializePersistenceLayer( wsagEngines );
 
         LOG.trace( "initialization of wsag4j wsrf engine completed" );
     }
 
     /**
      * @param engineConfigs
      * @return
      */
     private List<WsagEngine> initializeWsagEngines( WSAG4JEngineConfigurationType[] engineConfigs )
     {
         List<WsagEngine> initializedEngines = new Vector<WsagEngine>();
         for ( int i = 0; i < engineConfigs.length; i++ )
         {
             try
             {
                 WsagEngine initialized = WsagEngine.getInstance( engineConfigs[i] );
                 initializedEngines.add( initialized );
             }
             catch ( Exception e )
             {
                 String messageText = "failed to initialize engine instance ''{0}''. Reason: {1}";
                 String resourceId = engineConfigs[i].getResourceId();
                 String message = MessageFormat.format( messageText, resourceId, e.getMessage() );
 
                 LOG.error( message, e );
             }
         }
         return initializedEngines;
     }
 
     /**
      * Shutdown of the WSAG4J engine instance.
      * 
      * @throws Exception
      *             indicates an error during engine shutdown
      */
     public static void shutdownEngine() throws Exception
     {
 
         try
         {
             SchedulerFactory factory = new StdSchedulerFactory();
             Scheduler scheduler = factory.getScheduler();
 
             if ( scheduler.isStarted() )
             {
                 scheduler.shutdown();
             }
         }
         catch ( SchedulerException e )
         {
             LOG.error( "Failed to shutdown quartz scheduler.", e );
         }
 
         getInstance().shutdownPersistenceLayer();
 
         //
         // prevent memory leak
         //
         if ( messageContext != null )
         {
             messageContext.set( null );
             messageContext = null;
         }
         engine = null;
     }
 
     /**
      * Loads the WSAG4J WSRF engine configuration file.
      * 
      * @return the WSRF engine configuration file
      * 
      * @throws Exception
      *             failed to load configuration
      */
     private WSRFEngineConfigurationType loadWsrfConfiguration() throws Exception
     {
         LOG.trace( "WsrfEngine: start to load WSAG4J configurations" );
 
         WSRFEngineConfigurationType wsrfConfig;
 
         //
         // resolve the WSAG4J configuration file name
         //
         String filename =
             System.getProperty( WSAG4J_WSRF_ENGINE_FILE_NAME, WsagConstants.WSAG4J_WSRF_ENGINE_CONFIG_FILE );
 
         //
         // load the WSAG4J configuration and set it in the WSAG4JEngine
         //
         ConfigurationType wsag4jConfiguration = findWsrfConfiguration( filename );
         if ( wsag4jConfiguration != null )
         {
             wsrfConfig = wsag4jConfiguration.getWSRFEngineConfiguration();
 
             //
             // If the WSRF configuration was not found, throw an exception
             //
             if ( wsrfConfig == null )
             {
                 String message = "WSAG4J WSRF configuration was not found.";
                 throw new Exception( message );
             }
         }
         else
         {
             //
             // If the WSAG4J configuration was not found, throw an exception
             //
             String message = "WSAG4J configuration was not found.";
             throw new Exception( message );
         }
 
         return wsrfConfig;
     }
 
     /**
      * Loads the WSAG4J engine configurations specified in the wsrf-engine.config file and initializes the
      * {link {@link #engineConfigurations} property.
      * 
      * @return
      */
     private WSAG4JEngineConfigurationType[] loadEngineConfigurations( WSRFEngineConfigurationType wsrfConfig )
     {
         Vector<WSAG4JEngineConfigurationType> engineConfig = new Vector<WSAG4JEngineConfigurationType>();
 
         WSAG4JEngineInstanceType[] instances = new WSAG4JEngineInstanceType[0];
         if ( ( wsrfConfig != null ) && wsrfConfig.isSetWSAG4JEngineInstances() )
         {
             instances = wsrfConfig.getWSAG4JEngineInstances().getWSAG4JEngineArray();
         }
 
         if ( instances == null )
         {
             String message =
                 "Missing section WSAG4JEngineInstances in wsag4j engine configuration. "
                     + "No Agreement Factories were instantiated.";
             LOG.warn( message );
         }
         else
         {
             for ( int i = 0; i < instances.length; i++ )
             {
                 String configFile = instances[i].getEngineConfigurationFile();
 
                 try
                 {
                     InputStream in = getClass().getResourceAsStream( configFile );
 
                     if ( in == null )
                     {
                         LOG.warn( LogMessage.getMessage(
                             "The wsag4j engine configuration file [{0}] was not found. Skipping this entry.",
                             configFile ) );
 
                         continue;
                     }
 
                     WSAG4JEngineConfigurationDocument engineConfiguration =
                         (WSAG4JEngineConfigurationDocument) XmlObject.Factory.parse( in );
                     engineConfig.add( engineConfiguration.getWSAG4JEngineConfiguration() );
                 }
                 catch ( Exception e )
                 {
                     LOG.error( LogMessage.getMessage(
                         "Could not load WSAG4J engine configuration {0}. Ignoring this instance. Error: {1}",
                         configFile, e.getMessage() ) );
                 }
             }
         }
 
         return engineConfig.toArray( new WSAG4JEngineConfigurationType[engineConfig.size()] );
     }
 
     /**
      * Initializes the WSAG4J Gateway URL.
      * 
      * @param defaultDeploymentURI
      * @throws Exception
      */
     private void initializeGatewayURI( WSRFEngineConfigurationType wsrfConfig, String defaultDeploymentURI )
         throws Exception
     {
 
         LOG.info( "WsagEngine -> initializeGatewayURI" );
 
         // first we try to load the deployment uri via the system properties
         String spConfiguredURI = loadViaSystemProperties();
         if ( spConfiguredURI != null )
         {
 
             LOG.info( "Gateway address for this service is configured via System Properties." );
             LOG.info( LogMessage.getMessage( "WS-Resources will be deployed at URI: {0}", spConfiguredURI ) );
 
             deploymentURI = spConfiguredURI;
             return;
         }
 
         // Read the gateway URI from the configuration file.
         // This value is provided by the user/administrator.
         String gatewayAddress = wsrfConfig.getGatewayAddress();
         if ( ( gatewayAddress != null ) && ( !gatewayAddress.equals( "" ) ) )
         {
             Object[] filler = new Object[] { gatewayAddress };
             String message =
                 MessageFormat.format(
                     "Loaded gateway url from configuration file. Resources will be deployed at [{0}]", filler );
             LOG.info( message );
 
             deploymentURI = gatewayAddress;
             return;
         }
 
         // Since no gateway URI was configured in the configuration
         // file, we try to generate one.
         // We use a standard way to obtain the context path name
         // which should work across all servers. We remove the
         // trailing slash, then take what's left over, which
         // should be the context path less the preceding
         // slash such as "wsag4j"
         String noDeploymentURI = "No gateway address is configured for this service";
         LOG.warn( noDeploymentURI );
 
         String msgGeneratedWarning = "Try to generate gateway address for service";
         LOG.warn( msgGeneratedWarning );
 
         deploymentURI = defaultDeploymentURI;
     }
 
     private String loadViaSystemProperties()
     {
         try
         {
             InputStream in = WSAG4JConfiguration.findResource( WsagConstants.WSAG4J_CONFIG_FILE );
             Properties properties = new Properties();
             properties.load( in );
 
             String key =
                 properties.getProperty( "org.ogf.graap.wsag.gateway.key",
                     WsagConstants.WSAG4J_GATEWAY_PROPERTY );
 
             return System.getProperty( key );
         }
         catch ( Exception ex )
         {
             return System.getProperty( WsagConstants.WSAG4J_GATEWAY_PROPERTY );
         }
     }
 
     /**
      * @return the configuration
      */
     public static WSRFEngineConfigurationType getWSRFConfiguration()
     {
         return getInstance().wsrfConfiguration;
     }
 
     /**
      * @return the deploymentAddress
      */
     public static String getGatewayURL()
     {
         return getInstance().deploymentURI;
     }
 
     /**
      * Sets the WSAG4J engine login context. This login context is used to identify a WSAG4J server instance,
      * e.g. action implementations can use this login context to sign outgoing messages.
      * 
      * @param context
      *            the login context
      */
     public static void setLoginContext( LoginContext context )
     {
         getInstance().serverLoginContext = context;
     }
 
     /**
      * Returns the WSAG4J engine login context. This login context is used to identify a WSAG4J server
      * instance, e.g. action implementations can use this login context to sign outgoing messages.
      * 
      * @return the login context
      */
     public static LoginContext getLoginContext()
     {
         return getInstance().serverLoginContext;
     }
 
     /**
      * Returns the agreement factory home
      * 
      * @return the agreement factory home
      */
     public static IAgreementFactoryHome getAgreementFactoryHome()
     {
         return getInstance().agreementFactoryHome;
     }
 
     /**
      * Initializes the WSAG4J persistence layer facade and returns the new created facade object. This facade
      * provides seamless access to multiple {@link WsagEngine} instances through the
      * {@link IAgreementFactoryHome} interface. Factory id's must be unique over all factory instances.
      * 
      * @return the initialized facade instance
      */
     private WSAG4JPersistenceFacade initializePersistenceLayer( WsagEngine[] engines ) throws Exception
     {
 
         try
         {
             LOG.info( "WsagEngine -> initialize PersistenceLayer" );
 
             // build and initialise agreement factory home
             WSAG4JPersistenceFacade facade = new WSAG4JPersistenceFacade( engines );
             facade.initialize();
 
             LOG.info( "WsagEngine -> Persistence Layer initialized" );
 
             return facade;
         }
         catch ( Exception e )
         {
             LOG.error( "WsagEngine -> failed to initialize Persistence Layer", e );
             throw new Exception( "Failed to initialize persistence layer.", e );
         }
     }
 
     /**
      * Shutdown the persistence layer and persist all agreements that are currently managed by the
      * implementation.
      * 
      * TODO: Save current agreement states.
      */
     private void shutdownPersistenceLayer() throws Exception
     {
         // load all agreements
         PersistentAgreementFactory[] factories = getAgreementFactoryHome().list();
         for ( int i = 0; i < factories.length; i++ )
         {
             try
             {
                 final String msgDoSave = "Save agreement factory ''{0}''.";
                 LOG.debug( LogMessage.getMessage( msgDoSave, factories[i].getResourceId() ) );
 
                 factories[i].save();
 
                 final String msgSaved = "Agreement factory ''{0}'' saved.";
                 LOG.debug( LogMessage.getMessage( msgSaved, factories[i].getResourceId() ) );
             }
             catch ( Exception e )
             {
                 String message = "Failed to save agreement factory ''{0}''.";
                 LOG.error( MessageFormat.format( message, new Object[] { factories[i].getResourceId() } ), e );
             }
         }
 
         // remove references to agreement (factory) home
         agreementFactoryHome = null;
 
         // close the entity manager factory
         EmfRegistry.finalizeEmfRegistry();
     }
 
     /**
      * Sets if anonymous access to the server is allowed.
      * 
      * @param allowAnonymousAccess
      *            the allowAnonymousAccess to set
      */
     public static void setAllowAnonymousAccess( boolean allowAnonymousAccess )
     {
         getInstance().allowAnonymousAccess = allowAnonymousAccess;
     }
 
     /**
      * Sets if anonymous access to the server is allowed.
      * 
      * @return the allowAnonymousAccess
      */
     public static boolean isAllowAnonymousAccess()
     {
         return getInstance().allowAnonymousAccess;
     }
 
     /**
      * @param fileName
      *            The file name of the requested XML configuration file.
      * @return The XML configuration file as an {@link org.apache.xmlbeans.XmlObject}.
      * @throws IOException
      *             the configuration file could not be read or a related error occurred
      */
     public static ConfigurationType findWsrfConfiguration( String fileName ) throws IOException
     {
         try
         {
 
             InputStream resourceInput = WSAG4JConfiguration.findResource( fileName );
 
             ConfigurationType result = null;
 
             if ( resourceInput != null )
             {
                 try
                 {
                     result = ConfigurationDocument.Factory.parse( resourceInput ).getConfiguration();
                 }
                 catch ( IOException e )
                 {
                     String msgText = "Error reading the configuration file {0}. Error: {1}";
                     String message = LogMessage.format( msgText, fileName, e.getMessage() );
 
                     LOG.error( message );
                     throw new IOException( message );
 
                 }
                 catch ( XmlException e )
                 {
                     String msgText = "Error reading the configuration file {0}. Description: {1}";
                     String message = LogMessage.format( msgText, fileName, e.getMessage() );
 
                     LOG.error( message );
                     throw new IOException( message );
                 }
             }
 
             return result;
         }
         catch ( Exception ex )
         {
             String msgText = "Error loading configuration file [{0}]. Message: {1}";
             String message = LogMessage.format( msgText, fileName, ex.getMessage() );
             LOG.error( message );
 
             return null;
         }
     }
 
 }