// ========================================================================
   // Copyright (c) 1999-2009 Mort Bay Consulting Pty. Ltd.
   // ------------------------------------------------------------------------
   // All rights reserved. This program and the accompanying materials
   // are made available under the terms of the Eclipse Public License v1.0
   // and Apache License v2.0 which accompanies this distribution.
   // The Eclipse Public License is available at 
   // http://www.eclipse.org/legal/epl-v10.html
   // The Apache License v2.0 is available at
  // http://www.opensource.org/licenses/apache2.0.php
  // You may elect to redistribute this code under either of these licenses. 
  // ========================================================================
  
  package org.eclipse.jetty.plus.webapp;
  
  import java.net.URL;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Iterator;
  import java.util.List;
  
  import javax.naming.Binding;
  import javax.naming.Context;
  import javax.naming.InitialContext;
  import javax.naming.Name;
  import javax.naming.NameNotFoundException;
  import javax.naming.NamingException;
  
  import org.eclipse.jetty.jndi.NamingContext;
  import org.eclipse.jetty.jndi.NamingUtil;
  import org.eclipse.jetty.jndi.local.localContextRoot;
  import org.eclipse.jetty.plus.jndi.EnvEntry;
  import org.eclipse.jetty.plus.jndi.NamingEntryUtil;
  import org.eclipse.jetty.util.log.Log;
  import org.eclipse.jetty.util.log.Logger;
  import org.eclipse.jetty.webapp.AbstractConfiguration;
  import org.eclipse.jetty.webapp.Configuration;
  import org.eclipse.jetty.webapp.WebAppContext;
  import org.eclipse.jetty.xml.XmlConfiguration;
  
  
  /**
   * EnvConfiguration
   *
   *
   */
  public class EnvConfiguration extends AbstractConfiguration
  {
      private static final Logger LOG = Log.getLogger(EnvConfiguration.class);
  
      private static final String JETTY_ENV_BINDINGS = "org.eclipse.jetty.jndi.EnvConfiguration";
      private URL jettyEnvXmlUrl;
  
      public void setJettyEnvXml (URL url)
      {
          this.jettyEnvXmlUrl = url;
      }
  
      /** 
       * @see Configuration#configure(WebAppContext)
       * @throws Exception
       */
      @Override
      public void preConfigure (WebAppContext context) throws Exception
      {        
          //create a java:comp/env
          createEnvContext(context);
      }
  
      /** 
       * @throws Exception
       */
      @Override
      public void configure (WebAppContext context) throws Exception
      {  
          if (LOG.isDebugEnabled())
              LOG.debug("Created java:comp/env for webapp "+context.getContextPath());
          
          //check to see if an explicit file has been set, if not,
          //look in WEB-INF/jetty-env.xml
          if (jettyEnvXmlUrl == null)
          {
              //look for a file called WEB-INF/jetty-env.xml
              //and process it if it exists
              org.eclipse.jetty.util.resource.Resource web_inf = context.getWebInf();
              if(web_inf!=null && web_inf.isDirectory())
              {
                  org.eclipse.jetty.util.resource.Resource jettyEnv = web_inf.addPath("jetty-env.xml");
                  if(jettyEnv.exists())
                  {
                      jettyEnvXmlUrl = jettyEnv.getURL();
                  }
              }
          }
          
          if (jettyEnvXmlUrl != null)
          {
              synchronized (localContextRoot.getRoot())
              {
                 // create list and listener to remember the bindings we make.
                 final List<Bound> bindings = new ArrayList<Bound>();
                 NamingContext.Listener listener = new NamingContext.Listener()
                 {
                     public void unbind(NamingContext ctx, Binding binding)
                     {
                     }
 
                     public Binding bind(NamingContext ctx, Binding binding)
                     {
                         bindings.add(new Bound(ctx,binding.getName()));
                         return binding;
                     }
                 };
 
                 try
                 {
                     localContextRoot.getRoot().addListener(listener);
                     XmlConfiguration configuration = new XmlConfiguration(jettyEnvXmlUrl);
                     configuration.configure(context);
                 }
                 finally
                 {
                     localContextRoot.getRoot().removeListener(listener);
                     context.setAttribute(JETTY_ENV_BINDINGS,bindings);
                 }
             }
         }
 
         //add java:comp/env entries for any EnvEntries that have been defined so far
         bindEnvEntries(context);
     }
 
     
     /** 
      * Remove jndi setup from start
      * @see Configuration#deconfigure(WebAppContext)
      * @throws Exception
      */
     @Override
     public void deconfigure (WebAppContext context) throws Exception
     {
         //get rid of any bindings for comp/env for webapp
         ClassLoader oldLoader = Thread.currentThread().getContextClassLoader();
         Thread.currentThread().setContextClassLoader(context.getClassLoader());
         try
         {
             Context ic = new InitialContext();
             Context compCtx =  (Context)ic.lookup ("java:comp");
             compCtx.destroySubcontext("env");
 
             //unbind any NamingEntries that were configured in this webapp's name space
             @SuppressWarnings("unchecked")
             List<Bound> bindings = (List<Bound>)context.getAttribute(JETTY_ENV_BINDINGS);
             context.setAttribute(JETTY_ENV_BINDINGS,null);
             if (bindings!=null)
             {
                 Collections.reverse(bindings);
                 for (Bound b:bindings)
                     b._context.destroySubcontext(b._name);
             }
         }
         catch (NameNotFoundException e)
         {
             LOG.warn(e);
         }
         finally
         {
             Thread.currentThread().setContextClassLoader(oldLoader);
         }
     }
 
     
     /** 
      * Remove all jndi setup
      * @see Configuration#deconfigure(WebAppContext)
      * @throws Exception
      */
     @Override
     public void destroy (WebAppContext context) throws Exception
     {
         try
         {            
             //unbind any NamingEntries that were configured in this webapp's name space
             NamingContext scopeContext = (NamingContext)NamingEntryUtil.getContextForScope(context);
             scopeContext.getParent().destroySubcontext(scopeContext.getName());
         }
         catch (NameNotFoundException e)
         {
             LOG.ignore(e);
             LOG.debug("No naming entries configured in environment for webapp "+context);
         }
     }
     
     /**
      * Bind all EnvEntries that have been declared, so that the processing of the
      * web.xml file can potentially override them.
      * 
      * We first bind EnvEntries declared in Server scope, then WebAppContext scope.
      * @throws NamingException
      */
     public void bindEnvEntries (WebAppContext context)
     throws NamingException
     {
         LOG.debug("Binding env entries from the jvm scope");
         InitialContext ic = new InitialContext();
         Context envCtx = (Context)ic.lookup("java:comp/env");
         Object scope = null;
         List<Object> list = NamingEntryUtil.lookupNamingEntries(scope, EnvEntry.class);
         Iterator<Object> itor = list.iterator();
         while (itor.hasNext())
         {
             EnvEntry ee = (EnvEntry)itor.next();
             ee.bindToENC(ee.getJndiName());
             Name namingEntryName = NamingEntryUtil.makeNamingEntryName(null, ee);
             NamingUtil.bind(envCtx, namingEntryName.toString(), ee);//also save the EnvEntry in the context so we can check it later          
         }
         
         LOG.debug("Binding env entries from the server scope");
         
         scope = context.getServer();
         list = NamingEntryUtil.lookupNamingEntries(scope, EnvEntry.class);
         itor = list.iterator();
         while (itor.hasNext())
         {
             EnvEntry ee = (EnvEntry)itor.next();
             ee.bindToENC(ee.getJndiName());
             Name namingEntryName = NamingEntryUtil.makeNamingEntryName(null, ee);
             NamingUtil.bind(envCtx, namingEntryName.toString(), ee);//also save the EnvEntry in the context so we can check it later          
         }
         
         LOG.debug("Binding env entries from the context scope");
         scope = context;
         list = NamingEntryUtil.lookupNamingEntries(scope, EnvEntry.class);
         itor = list.iterator();
         while (itor.hasNext())
         {
             EnvEntry ee = (EnvEntry)itor.next();
             ee.bindToENC(ee.getJndiName());
             Name namingEntryName = NamingEntryUtil.makeNamingEntryName(null, ee);
             NamingUtil.bind(envCtx, namingEntryName.toString(), ee);//also save the EnvEntry in the context so we can check it later
         }
     }  
     
     protected void createEnvContext (WebAppContext wac)
     throws NamingException
     {
         ClassLoader old_loader = Thread.currentThread().getContextClassLoader();
         Thread.currentThread().setContextClassLoader(wac.getClassLoader());
         try
         {
             Context context = new InitialContext();
             Context compCtx =  (Context)context.lookup ("java:comp");
             compCtx.createSubcontext("env");
         }
         finally 
         {
            Thread.currentThread().setContextClassLoader(old_loader);
        }
     }
     
     private static class Bound
     {
         final NamingContext _context;
         final String _name;
         Bound(NamingContext context, String name)
         {
             _context=context;
             _name=name;
         }
     }
 }