/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache 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.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.apache.axis2.jaxws.catalog.impl;

import org.apache.axis2.java.security.AccessController;
import org.apache.axis2.jaxws.ExceptionFactory;
import org.apache.axis2.jaxws.catalog.JAXWSCatalogManager;
import org.apache.xml.resolver.Catalog;
import org.apache.xml.resolver.CatalogManager;

import java.lang.reflect.Method;
import java.net.URL;
import java.security.PrivilegedAction;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.util.logging.Logger;

/**
 *  OASISCatalogManager provides an interface to the catalog properties.
 *  The primary difference between this and the 
 *  org.apache.xml.resolver.CatalogManger is that the staticCatalog is not
 *  a static data member in the OASISCatalogManger class.  This enables the use
 *  of a static catalog per CatalogManager.  
 */
public class OASISCatalogManager extends CatalogManager implements JAXWSCatalogManager {
    public static final String DEFAULT_CATALOG_WEB = "WEB-INF/jax-ws-catalog.xml";
    public static final String DEFAULT_CATALOG_EJB = "META-INF/jax-ws-catalog.xml";
    public static final String CATALOG_DEBUG_KEY = "OASISCatalogManager.catalog.debug.level";
    
    private ClassLoader classloader = null;

    private static final Logger LOG =
    	Logger.getLogger(OASISCatalogManager.class.getName());
    private static String DEBUG_LEVEL = null;

    static {
        DEBUG_LEVEL = (String)
            AccessController.doPrivileged(
                  new PrivilegedAction() {

                      public Object run() {
                          try {
                              return System.getProperty(CATALOG_DEBUG_KEY);
                          } catch (Throwable t) {
                              return null;
                          }
                      }
                  });
    }
    /** The static catalog used by this manager. */
    private Catalog staticCatalog = null;

    /**
     * Default constructor with ClassLoader argument.
     * This constructor will use the defaults specified for Axis2 in the
     * acceptDefaults method.
     * @param classLoader
     */
    public OASISCatalogManager(ClassLoader classLoader) {
        this();
        this.classloader = classLoader;
    }
    
    /**
     * Constructor that specifies an explicit property file and ClassLoader.
     * @param classLoader
     * @param propertyFileName
     */
    public OASISCatalogManager(ClassLoader classLoader, String propertyFileName) {
        this(propertyFileName);
        this.classloader = classLoader;
    }
    
    /**
     * Default constructor with no arguments.
     * This constructor will use the defaults specified for Axis2 in the
     * acceptDefaults method.
     */
    public OASISCatalogManager() {
    	super();
    	this.acceptDefaults();
    	if (DEBUG_LEVEL != null) {
    		this.debug.setDebug(Integer.parseInt(DEBUG_LEVEL)); 
    	}
    	
    	String filepath = determineFileName();
    
        if (filepath != null) {
            this.setCatalogFiles(filepath);
        }
    }

    
    /**
     * Constructor that specifies an explicit property file.
     * @param propertyFileName
     */
    public OASISCatalogManager(String propertyFileName) {
    	super(propertyFileName);
        if (DEBUG_LEVEL != null) {
            this.debug.setDebug(Integer.parseInt(DEBUG_LEVEL));            
        }
    }
    
    private void acceptDefaults() {
    	this.setUseStaticCatalog(true);
    	this.setIgnoreMissingProperties(true);
    }
    
    /**
     * Get a catalog instance.
     *
     * If this manager uses static catalogs, the same static catalog will
     * always be returned. Otherwise a new catalog will be returned.
     */
    public Catalog getCatalog() {
        Catalog catalog = staticCatalog;

        if (catalog == null || !super.getUseStaticCatalog()) {
            catalog = getPrivateCatalog();
        }
        return catalog;
    }


    private String determineFileName() {

        ClassLoader classLoader = (classloader != null) ? classloader : findClassLoader();
        // try web app WEB-INF first
        URL url = classLoader.getResource(DEFAULT_CATALOG_WEB);
        if (url != null) {
            return url.toString();
        }
        // have not returned -- perhaps we're in an EJB?
        url = classLoader.getResource(DEFAULT_CATALOG_EJB);
        return url == null? null: url.toString();

    }
    
    /**
     * Get a new catalog instance.
     *
     * This method returns an instance of the underlying catalog class.
     */
    public Catalog getPrivateCatalog() {
        try {
            final CatalogManager cm = this;
            Catalog catalog = 
                (Catalog) AccessController.
                doPrivileged(new PrivilegedExceptionAction() {
                    public Object run() throws Exception {
                        Catalog catalog = staticCatalog;
                        boolean useStatic = cm.getUseStaticCatalog();

                        if (catalog == null || !useStatic) {

                            String catalogClassName = getCatalogClassName();
                            if (catalogClassName == null) {
                                catalog = new Catalog();
                            } else {
                                try {
                                    catalog = (Catalog) Class.forName(catalogClassName).newInstance();
                                } catch (ClassNotFoundException cnfe) {
                                    debug.message(1,"Catalog class named '"
                                                  + catalogClassName
                                                  + "' could not be found. Using default.");
                                    catalog = new Catalog();
                                } catch (ClassCastException cnfe) {
                                    debug.message(1,"Class named '"
                                                  + catalogClassName
                                                  + "' is not a Catalog. Using default.");
                                    catalog = new Catalog();
                                }
                            }

                            catalog.setCatalogManager(cm);
                            catalog.setupReaders();
                            catalog.loadSystemCatalogs();
                        }
                        return catalog;
                    }});
            staticCatalog = catalog;
            return catalog;
        } catch (PrivilegedActionException pae) {
            // The Catch and swallow
            debug.message(1,"getPrivateCatatalog failed.  " +
                        "Processing continues " + pae.getException());
        }
        return null;
    }
    
    /**
     * Set the list of catalog files.
     * This method will reset the staticCatalog for this CatalogManager.
     */
    public void setCatalogFiles(String fileList) {
    	staticCatalog = null;
    	super.setCatalogFiles(fileList);
    }
    
    /**
     * COPIED FROM javax.xml.ws.spi.FactoryFinder
     * 
     * Figure out which ClassLoader to use.  For JDK 1.2 and later use
     * the context ClassLoader.
     *
     * @return the <code>ClassLoader</code>
     * @throws ConfigurationError if this class is unable to work with the
     *                            host JDK
     */
    private static ClassLoader findClassLoader() {

        try {
            ClassLoader cl = 
                (ClassLoader) AccessController.
                doPrivileged(new PrivilegedExceptionAction() {
                    public Object run() throws Exception {
                        Method m = null;

                        try {
                            m = Thread.class.getMethod("getContextClassLoader", (Class[]) null);
                        } catch (NoSuchMethodException e) {
                            // Assume that we are running JDK 1.1, use the current ClassLoader
                            // TODO print debug statement about assuming JDK 1.1
                            return OASISCatalogManager.class.getClassLoader();
                        }
                        return (ClassLoader) m.invoke(Thread.currentThread(),
                                                      (Object[]) null);
                    }}
                );
            return cl;
        } catch (PrivilegedActionException pae) {
            throw ExceptionFactory.makeWebServiceException(pae.getException());
        }
    }
   
}
