/*
 * Copyright (C) 2009 eXo Platform SAS.
 *
 * This is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * This software 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this software; if not, write to the Free
 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 */
package org.exoplatform.container.configuration;

import org.exoplatform.commons.utils.SecurityHelper;
import org.exoplatform.container.ar.Archive;
import org.exoplatform.container.xml.Component;
import org.exoplatform.container.xml.Configuration;
import org.exoplatform.container.xml.Deserializer;
import org.exoplatform.services.log.ExoLogger;
import org.exoplatform.services.log.Log;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.security.PrivilegedAction;
import java.security.PrivilegedExceptionAction;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import javax.servlet.ServletContext;

/**
 * Jul 19, 2004
 * 
 * @author: Tuan Nguyen
 * @version: $Id: ConfigurationServiceImpl.java,v 1.8 2004/10/30 02:29:51 tuan08
 *           Exp $
 */
public class ConfigurationManagerImpl implements ConfigurationManager
{
   final static public String WAR_CONF_LOCATION = "/WEB-INF";

   private static final Log LOG = ExoLogger.getLogger("exo.kernel.container.ConfigurationManagerImpl");

   protected Configuration configurations_;

   private ServletContext scontext_;

   private ClassLoader scontextClassLoader_;

   private String contextPath;

   private boolean validateSchema = true;
   
   private boolean logEnabled = true;

   /** . */
   private final Set<String> profiles;

   /** The URL of the current document being unmarshalled. */
   private static final ThreadLocal<URL> currentURL = new ThreadLocal<URL>();

   /**
    * Returns the URL of the current document being unmarshalled or null.
    * @return the URL
    */
   public static URL getCurrentURL()
   {
      return currentURL.get();
   }

   public ConfigurationManagerImpl()
   {
      this.profiles = Collections.emptySet();
   }

   public ConfigurationManagerImpl(Set<String> profiles)
   {
      this.profiles = profiles;
   }

   public ConfigurationManagerImpl(Set<String> profiles, boolean logEnabled)
   {
      this(profiles);
      this.logEnabled = logEnabled;
   }

   public ConfigurationManagerImpl(ServletContext context, Set<String> profiles)
   {
      scontext_ = context;
      this.profiles = profiles;
   }

   public ConfigurationManagerImpl(ClassLoader loader, Set<String> profiles)
   {
      scontextClassLoader_ = loader;
      this.profiles = profiles;
   }

   public Configuration getConfiguration()
   {
      return configurations_;
   }

   @Override
   public Set<String> getProfiles() {
     return profiles;
   }

   public void addConfiguration(ServletContext context, String url) throws Exception
   {
      if (url == null)
         return;
      addConfiguration(context, getURL(context, url));
   }

   public void addConfiguration(String url) throws Exception
   {
      if (url == null)
         return;
      addConfiguration(getURL(url));
   }

   public void addConfiguration(Collection<URL> urls)
   {
      Iterator<URL> i = urls.iterator();
      while (i.hasNext())
      {
         URL url = i.next();
         addConfiguration(url);
      }
   }

   public void addConfiguration(URL url)
   {
      addConfiguration(scontext_, url);
   }

   private void addConfiguration(ServletContext context, URL url)
   {
      if (url == null)
         return;
      if (logEnabled && LOG_DEBUG)
         LOG.info("Add configuration " + url);
      try
      {
         contextPath = (new File(url.toString())).getParent() + "/";
         contextPath = contextPath.replaceAll("\\\\", "/");
      }
      catch (Exception e)
      {
         contextPath = null;
      }

      // Just to prevent some nasty bug to happen
      if (currentURL.get() != null)
      {
         throw new IllegalStateException("Would not expect that");
      }
      else
      {
         currentURL.set(url);
      }

      //
      try
      {
         ConfigurationUnmarshaller unmarshaller = new ConfigurationUnmarshaller(profiles);
         Configuration conf = unmarshaller.unmarshall(url);

         if (configurations_ == null)
            configurations_ = conf;
         else
            configurations_.mergeConfiguration(conf);
         importConf(unmarshaller, conf);
      }
      catch (Exception ex)
      {
         LOG.error("Cannot process the configuration " + currentURL.get(), ex);
      }
      finally
      {
         currentURL.set(null);
      }
   }

   /**
    * Recursively import the configuration files
    * 
    * @param unmarshaller the unmarshaller used to unmarshall the configuration file to import
    * @param conf the configuration in which we get the list of files to import
    * @throws Exception if an exception occurs while loading the files to import
    */
   private void importConf(ConfigurationUnmarshaller unmarshaller, Configuration conf) throws Exception
   {
      importConf(unmarshaller, conf, 1);
   }
   
   /**
    * Recursively import the configuration files
    * 
    * @param unmarshaller the unmarshaller used to unmarshall the configuration file to import
    * @param conf the configuration in which we get the list of files to import
    * @param depth used to log properly the URL of the file to import
    * @throws Exception if an exception occurs while loading the files to import
    */
   private void importConf(ConfigurationUnmarshaller unmarshaller, Configuration conf, int depth) throws Exception
   {
      List<String> urls = conf.getImports();
      if (urls != null)
      {
         StringBuilder prefix = new StringBuilder(depth);
         for (int i = 0; i < depth; i++)
         {
            prefix.append('\t');
         }
         for (int i = 0; i < urls.size(); i++)
         {
            String uri = (String)urls.get(i);
            URL urlObject = getURL(uri);
            if (urlObject != null)
            {
               if (logEnabled && LOG_DEBUG)
                  LOG.info(prefix + "import " + urlObject);
               // Set the URL of imported file
               currentURL.set(urlObject);
               conf = unmarshaller.unmarshall(urlObject);
               configurations_.mergeConfiguration(conf);
               importConf(unmarshaller, conf, depth + 1);
            }
            else
            {
               LOG.warn("Couldn't process the URL for " + uri + " configuration file ignored ");
            }
         }
      }
   }

   public void processRemoveConfiguration()
   {
      if (configurations_ == null)
         return;
      List<String> list = configurations_.getRemoveConfiguration();
      if (list != null)
      {
         for (int i = 0; i < list.size(); i++)
         {
            String type = (String)list.get(i);
            configurations_.removeConfiguration(type);
         }
      }
   }

   public Component getComponent(String service)
   {
      return configurations_.getComponent(service);
   }

   public Component getComponent(Class<?> clazz)
   {
      return configurations_.getComponent(clazz.getName());
   }

   public Collection<Component> getComponents()
   {
      if (configurations_ == null)
         return null;
      return configurations_.getComponents();
   }

   public boolean isValidateSchema()
   {
      return validateSchema;
   }

   public void setValidateSchema(boolean validateSchema)
   {
      this.validateSchema = validateSchema;
   }

   public URL getResource(String url, String defaultURL) throws Exception
   {
      if (url == null)
         url = defaultURL;
      return getResource(url);
   }

   public URL getResource(String uri) throws Exception
   {
      return getURL(uri);
   }

   public InputStream getInputStream(String url, String defaultURL) throws Exception
   {
      if (url == null)
         url = defaultURL;
      return getInputStream(url);
   }

   public InputStream getInputStream(String uri) throws Exception
   {
      final URL url = getURL(uri);
      if (url == null)
      {
         throw new IOException("Resource (" + uri
            + ") could not be found or the invoker doesn't have adequate privileges to get the resource");
      }

      return SecurityHelper.doPrivilegedIOExceptionAction(new PrivilegedExceptionAction<InputStream>()
      {
         public InputStream run() throws Exception
         {
            return url.openStream();
         }
      });
   }

   public URL getURL(String url) throws Exception
   {
      return getURL(scontext_, url);
   }

   private URL getURL(final ServletContext context, String url) throws Exception
   {
      if (url == null)
      {
         return null;
      }
      else if (url.startsWith("jar:"))
      {
         String path = removePrefix("jar:", url);
         if (path.startsWith("/"))
         {
            path = path.substring(1);
         }
         final ClassLoader cl = Thread.currentThread().getContextClassLoader();
         final String finalPath = path;
         return SecurityHelper.doPrivilegedAction(new PrivilegedAction<URL>()
         {
            public URL run()
            {
               return cl.getResource(finalPath);
            }
         });
      }
      else if (url.startsWith("classpath:"))
      {
         String path = removePrefix("classpath:", url);
         if (path.startsWith("/"))
         {
            path = path.substring(1);
         }
         final ClassLoader cl = Thread.currentThread().getContextClassLoader();
         final String finalPath = path;
         return SecurityHelper.doPrivilegedAction(new PrivilegedAction<URL>()
         {
            public URL run()
            {
               return cl.getResource(finalPath);
            }
         });
      }
      else if (url.startsWith("war:"))
      {
         String path = removePrefix("war:", url);
         if (context != null)
         {
            final String fPath = path;
            return SecurityHelper.doPrivilegedMalformedURLExceptionAction(new PrivilegedExceptionAction<URL>()
            {
               public URL run() throws Exception
               {
                  return context.getResource(WAR_CONF_LOCATION + fPath);
               }
            });
         }
         if (scontextClassLoader_ != null)
         {
            if (path.startsWith("/"))
            {
               // The ClassLoader doesn't support the first "/"
               path = path.substring(1);
            }
            final String fPath = path;
            return SecurityHelper.doPrivilegedAction(new PrivilegedAction<URL>()
            {
               public URL run()
               {
                  return scontextClassLoader_.getResource(fPath);
               }
            });
         }
         throw new Exception("unsupport war uri in this configuration service");
      }
      else if (url.startsWith("file:"))
      {
         url = resolveFileURL(url);
         return new URL(url);
      }
      else if (Archive.isArchiveURL(url))
      {
         return Archive.createArchiveURL(url);
      }
      else if (url.indexOf(":") < 0 && contextPath != null)
      {
         if (Archive.isArchiveURL(contextPath))
            return Archive.createArchiveURL(contextPath + url.replace('\\', '/'));
         return new URL(contextPath + url.replace('\\', '/'));
      }
      return null;
   }

   /**
    * This methods is used to convert the given into a valid url, it will:
    * <ol>
    * <li>Resolve variables in the path if they exist</li>
    * <li>Replace windows path separators with proper separators</li>
    * <li>Ensure that the path start with file:///</li>
    * </ol>
    * , then it will 
    * @param url the url to resolve
    * @return the resolved url
    */
   private String resolveFileURL(String url)
   {
      url = Deserializer.resolveVariables(url);
      // we ensure that we don't have windows path separator in the url
      url = url.replace('\\', '/');
      if (!url.startsWith("file:///"))
      {
         // The url is invalid, so we will fix it
         // it happens when we use a path of type file://${path}, under
         // linux or mac os the path will start with a '/' so the url
         // will be correct but under windows we will have something
         // like C:\ so the first '/' is missing
         if (url.startsWith("file://"))
         {
            // The url is of type file://, so one '/' is missing
            url = "file:///" + url.substring(7);
         }
         else if (url.startsWith("file:/"))
         {
            // The url is of type file:/, so two '/' are missing
            url = "file:///" + url.substring(6);
         }
         else
         {
            // The url is of type file:, so three '/' are missing
            url = "file:///" + url.substring(5);
         }
      }
      return url;
   }

   protected String removePrefix(String prefix, String url)
   {
      return url.substring(prefix.length(), url.length());
   }
}
