/**
    * Copyright 2005-2006 the original author or authors.
    *
    * Licensed under the Gnu General Pubic License, Version 2.0 (the
    * "License"); you may not use this file except in compliance with
    * the License. You may obtain a copy of the License at
    *
    *      http://www.opensource.org/licenses/gpl-license.php
    *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   * See the Gnu General Public License for more details.
   */
  package org.figure8.join.core;
  
  import org.figure8.join.util.LogUtil;
  
  import org.apache.commons.logging.Log;
  import org.springframework.context.ApplicationContext;
  import org.springframework.context.ApplicationContextException;
  import org.springframework.context.event.ContextRefreshedEvent;
  import org.springframework.web.context.ContextLoader;
  import org.springframework.web.context.support.WebApplicationContextUtils;
  import org.springframework.beans.factory.support.DefaultListableBeanFactory;
  
  import javax.servlet.ServletContext;
  /**
   * This is a wrapper around Spring applicative main context.
   * @author <a href="mailto:laurent.broudoux@free.fr">Laurent Broudoux</a>
   * @version $Revision: 1.2 $
   */
  public class ContainerContextHandler{
  
     // Static -------------------------------------------------------------------
  
     /** Get a commons logger */
     private static Log log = LogUtil.getLog(ContainerContextHandler.class);
  
  
     // Attributes ---------------------------------------------------------------
  
     /** Singleton own instance */
     private static ContainerContextHandler me = null;
  
     /** The servlet context for whom handling Spring context */
     private ServletContext servletContext = null;
     /** The handled Sptring context */
     private ApplicationContext applicationContext = null;
     /** The handled Spring bean factory */
     private DefaultListableBeanFactory beanFactory = null;
  
  
     // Constructors -------------------------------------------------------------
  
     /** Creates a new instance of ContainerContextHandler */
     private ContainerContextHandler(){
        beanFactory = new DefaultListableBeanFactory(null);
     }
  
     
     // Public -------------------------------------------------------------------
  
     /** @return true if context is setup (ie. <b>applicatinoContext</b> not null) */
     public boolean isSetup(){
        return applicationContext != null;
     }
  
     /**
      * Assign the servlet context for whom Spring context will be handled
      * @param context The servlet context for whom handling Spring context
      */
     public void setServletContext(ServletContext context){
        servletContext = context;
        setApplicationContext(WebApplicationContextUtils.getWebApplicationContext(context));
     }
     /** @return The servlet context for whom Spring context is handled */
     public ServletContext getServletContext(){
        return servletContext;
     }
  
     /**
      * Set the handled Spring applicative context.
      * @param appContext The context to wrapp
      * @throws ApplicationContextException if problem occurs during beanFactory initialization
      */
     public void setApplicationContext(ApplicationContext appContext) throws ApplicationContextException{
        applicationContext = appContext;
        beanFactory = new DefaultListableBeanFactory(appContext);
     }
     /** @return Handled String context (if any) */
     public ApplicationContext getApplicationContext(){
        return applicationContext;
     }
  
     /**
      * Retrieve a component from Spring handled context.
      * @param key Key identifier of the component to retrieve
      * @return The component denoted by <b>key</b>
     * @throws IllegalStateException if no Spring context is handled
     * @throws InvalidParameterException if key is null or component cannot be found.
     */
    public Object getComponent(String key) throws IllegalStateException, InvalidParameterException{
       if (applicationContext == null){
          log.fatal("Spring Application context has not been set");
          throw new IllegalStateException("Spring Application context has not been set");
       }
       if (key == null){
          log.error("The component key cannot be null");
          throw new InvalidParameterException("The component key cannot be null");
       }
       try{
          // Try getting bean, wrap exception into invalid parameter one.
          return applicationContext.getBean(key.toString());
       }
       catch (Exception e){
          log.error("The component denoted by '" + key + "' cannot be found within context");
          throw new InvalidParameterException("'" + key + "' component cannot be found within context", e);
       }
     }
 
    /**
     * Register a component as a singleton within Spring handled application
     * context and the web tier servlet context if present.
     * @param key The key to use for registring singleton
     * @param component The component to register
     * @throws IllegalStateException if no Spring context is handled
     * @throws InvalidParameterException if key is null or component already exists
     */
    public void registerComponent(String key, Object component) throws IllegalStateException, InvalidParameterException{
       if (applicationContext == null){
          log.fatal("Spring Application context has not been set");
          throw new IllegalStateException("Spring Application context has not been set");
       }
       if (key == null){
          log.error("The component key cannot be null");
          throw new InvalidParameterException("The component key cannot be null");
       }
       if (applicationContext.containsBean(key)){
          log.error("A component with the key '" + key + "' already exists in Application context");
          throw new InvalidParameterException("A component with this key already exists in context");
       }
       try{
          // Register this component within bean factory of application context.
          beanFactory.registerSingleton(key, component);
          // Register this component as a servlet context attribute.
          servletContext.setAttribute(key, component);
       }
       catch (Exception e){
          throw new InvalidParameterException("A component with this key already exists in context");
       }
    }
 
    /**
     * Refresh or create the handled String applicative context.
     * If it exists, it is first closed. Then, it is loaded using
     * the <code>ContainerContextLoader</code> implementation.
     */
    public synchronized void refresh(){
       ContextLoader loader = new ContainerContextLoader();
       ApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(getServletContext());
       if (ctx != null)
          loader.closeWebApplicationContext(getServletContext());
       loader.initWebApplicationContext(getServletContext());
       if (getApplicationContext() == null)
          setApplicationContext(WebApplicationContextUtils.getWebApplicationContext(getServletContext()));
       contextReloaded();
    }
 
    /** @return The running instance of ContainerContextHandler */
    public static ContainerContextHandler getInstance(){
       if (me == null)
          me = new ContainerContextHandler();
       return me;
    }
 
 
    // Protected ----------------------------------------------------------------
 
    /** Publish a <code>ContextRefreshedEvent</code> on applicationContext */
    protected void contextReloaded(){
       // Refresh application context from servlet context.
       setApplicationContext(WebApplicationContextUtils.getWebApplicationContext(servletContext));
       // Publish event.
       if (applicationContext != null)
          applicationContext.publishEvent(new ContextRefreshedEvent(applicationContext));
    }
 }