/*

 * 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 com.sun.org.apache.xml.internal.resolver;

import com.sun.org.apache.xerces.internal.utils.SecuritySupport;

import com.sun.org.apache.xml.internal.resolver.helpers.BootstrapResolver;

import com.sun.org.apache.xml.internal.resolver.helpers.Debug;

import java.io.InputStream;

import java.net.MalformedURLException;

import java.net.URL;

import java.util.MissingResourceException;

import java.util.PropertyResourceBundle;

import java.util.ResourceBundle;

import java.util.StringTokenizer;

import java.util.Vector;

import sun.reflect.misc.ReflectUtil;

/**

 * CatalogManager provides an interface to the catalog properties.

 *

 * <p>Properties can come from two places: from system properties or

 * from a <i>CatalogManager.properties</i> file. This class provides a transparent

 * interface to both, with system properties preferred over property file values.</p>

 *

 * <p>The following table summarizes the properties:</p>

 *

 * <table border="1">

 * <thead>

 * <tr>

 * <td>System Property</td>

 * <td>CatalogManager.properties<br/>Property</td>

 * <td>Description</td>

 * </tr>

 * </thead>

 * <tbody>

 * <tr>

 * <td>xml.catalog.ignoreMissing</td>

 * <td>&#160;</td>

 * <td>If true, a missing <i>CatalogManager.properties</i> file or missing properties

 * within that file will not generate warning messages. See also the

 * <i>ignoreMissingProperties</i> method.</td>

 * </tr>

 *

 * <tr>

 * <td>xml.catalog.files</td>

 * <td>catalogs</td>

 * <td>The <emph>semicolon-delimited</emph> list of catalog files.</td>

 * </tr>

 *

 * <tr>

 * <td>&#160;</td>

 * <td>relative-catalogs</td>

 * <td>If false, relative catalog URIs are made absolute with respect to the base URI of

 * the <i>CatalogManager.properties</i> file. This setting only applies to catalog

 * URIs obtained from the <i>catalogs</i> property <emph>in the</emph>

 * <i>CatalogManager.properties</i> file</td>

 * </tr>

 *

 * <tr>

 * <td>xml.catalog.verbosity</td>

 * <td>verbosity</td>

 * <td>If non-zero, the Catalog classes will print informative and debugging messages.

 * The higher the number, the more messages.</td>

 * </tr>

 *

 * <tr>

 * <td>xml.catalog.prefer</td>

 * <td>prefer</td>

 * <td>Which identifier is preferred, "public" or "system"?</td>

 * </tr>

 *

 * <tr>

 * <td>xml.catalog.staticCatalog</td>

 * <td>static-catalog</td>

 * <td>Should a single catalog be constructed for all parsing, or should a different

 * catalog be created for each parser?</td>

 * </tr>

 *

 * <tr>

 * <td>xml.catalog.allowPI</td>

 * <td>allow-oasis-xml-catalog-pi</td>

 * <td>If the source document contains "oasis-xml-catalog" processing instructions,

 * should they be used?</td>

 * </tr>

 *

 * <tr>

 * <td>xml.catalog.className</td>

 * <td>catalog-class-name</td>

 * <td>If you're using the convenience classes

 * <tt>com.sun.org.apache.xml.internal.resolver.tools.*</tt>), this setting

 * allows you to specify an alternate class name to use for the underlying

 * catalog.</td>

 * </tr>

 * </tbody>

 * </table>

 *

 * @see Catalog

 *

 * @author Norman Walsh

 * <a href="mailto:Norman.Walsh@Sun.COM">Norman.Walsh@Sun.COM</a>

 *

 * @version 1.0

 */

public class CatalogManager {

    private static final String pFiles         = "xml.catalog.files";

    private static final String pVerbosity     = "xml.catalog.verbosity";

    private static final String pPrefer        = "xml.catalog.prefer";

    private static final String pStatic        = "xml.catalog.staticCatalog";

    private static final String pAllowPI       = "xml.catalog.allowPI";

    private static final String pClassname     = "xml.catalog.className";

    private static final String pIgnoreMissing = "xml.catalog.ignoreMissing";

    /** A static CatalogManager instance for sharing */

    private static final CatalogManager staticManager = new CatalogManager();

    /** The bootstrap resolver to use when loading XML Catalogs. */

    private BootstrapResolver bResolver = new BootstrapResolver();

    /** Flag to ignore missing property files and/or properties */

    private boolean ignoreMissingProperties

    = (SecuritySupport.getSystemProperty(pIgnoreMissing) != null

    || SecuritySupport.getSystemProperty(pFiles) != null);

    /** Holds the resources after they are loaded from the file. */

    private ResourceBundle resources;

    /** The name of the CatalogManager properties file. */

    private String propertyFile = "CatalogManager.properties";

    /** The location of the propertyFile */

    private URL propertyFileURI = null;

    /** Default catalog files list. */

    private String defaultCatalogFiles = "./xcatalog";

    /** Current catalog files list. */

    private String catalogFiles = null;

    /** Did the catalogFiles come from the properties file? */

    private boolean fromPropertiesFile = false;

    /** Default verbosity level if there is no property setting for it. */

    private int defaultVerbosity = 1;

    /** Current verbosity level. */

    private Integer verbosity = null;

    /** Default preference setting. */

    private boolean defaultPreferPublic = true;

    /** Current preference setting. */

    private Boolean preferPublic = null;

    /** Default setting of the static catalog flag. */

    private boolean defaultUseStaticCatalog = true;

    /** Current setting of the static catalog flag. */

    private Boolean useStaticCatalog = null;

    /** The static catalog used by this manager. */

    private static volatile Catalog staticCatalog = null;

    /** Default setting of the oasisXMLCatalogPI flag. */

    private boolean defaultOasisXMLCatalogPI = true;

    /** Current setting of the oasisXMLCatalogPI flag. */

    private Boolean oasisXMLCatalogPI = null;

    /** Default setting of the relativeCatalogs flag. */

    private boolean defaultRelativeCatalogs = true;

    /** Current setting of the relativeCatalogs flag. */

    private Boolean relativeCatalogs = null;

    /** Current catalog class name. */

    private String catalogClassName = null;

    /**

     * Indicates whether implementation parts should use

     *   service loader (or similar).

     * Note the default value (false) is the safe option..

     */

    private boolean useServicesMechanism;

    /** The manager's debug object. Used for printing debugging messages.

     *

     * <p>This field is public so that objects that have access to this

     * CatalogManager can use this debug object.</p>

     */

    public Debug debug = null;

    /** Constructor. */

    public CatalogManager() {

        init();

    }

    /** Constructor that specifies an explicit property file. */

    public CatalogManager(String propertyFile) {

        this.propertyFile = propertyFile;

        init();

  }

  private void init() {

        debug = new Debug();

    // Note that we don't setDebug() here; we do that lazily. Either the

    // user will set it explicitly, or we'll do it automagically if they

    // read from the propertyFile for some other reason. That way, there's

    // no attempt to read from the file before the caller has had a chance

    // to avoid it.

    if (System.getSecurityManager() == null) {

        useServicesMechanism = true;

    }

        // Make sure verbosity is set by xml.catalog.verbosity sysprop

        // setting, if defined.

        queryVerbosityFromSysProp();

    }

    /** Set the bootstrap resolver

     * @param resolver the bootstrap resolver

     */

    public void setBootstrapResolver(BootstrapResolver resolver) {

        bResolver = resolver;

    }

    /** Get the bootstrap resolver

     * @return the bootstrap resolver

     */

    public BootstrapResolver getBootstrapResolver() {

        return bResolver;

    }

    /** Query system property for verbosity level. */

    private void queryVerbosityFromSysProp() {

        String verbStr = SecuritySupport.getSystemProperty(pVerbosity);

        if (verbStr != null) {

            try {

                int verb = Integer.parseInt(verbStr.trim());

                verbosity = new Integer(verb);

                debug.setDebug(verb);

            } catch (Exception e) {

                System.err.println("Cannot parse verbosity: \"" + verbStr + "\"");

            }

        }

    }

    /**

     * Load the properties from the propertyFile and build the

     * resources from it.

     */

    private synchronized void readProperties() {

        try {

            propertyFileURI = CatalogManager.class.getResource("/"+propertyFile);

            InputStream in =

                    CatalogManager.class.getResourceAsStream("/"+propertyFile);

            if (in==null) {

                if (!ignoreMissingProperties) {

                    System.err.println("Cannot find "+propertyFile);

                    // there's no reason to give this warning more than once

                    ignoreMissingProperties = true;

                }

                return;

            }

            resources = new PropertyResourceBundle(in);

        } catch (MissingResourceException mre) {

            if (!ignoreMissingProperties) {

                System.err.println("Cannot read "+propertyFile);

            }

        } catch (java.io.IOException e) {

            if (!ignoreMissingProperties) {

                System.err.println("Failure trying to read "+propertyFile);

            }

        }

        // This is a bit of a hack. After we've successfully read the properties,

        // use them to set the default debug level, if the user hasn't already set

        // the default debug level.

        if (verbosity == null) {

            try {

                String verbStr = resources.getString("verbosity");

                int verb = Integer.parseInt(verbStr.trim());

                debug.setDebug(verb);

                verbosity = new Integer(verb);

            } catch (Exception e) {

                // nop

            }

        }

    }

    /**

     * Allow access to the static CatalogManager

     */

    public static CatalogManager getStaticManager() {

        return staticManager;

    }

    /**

     * How are missing properties handled?

     *

     * <p>If true, missing or unreadable property files will

     * not be reported. Otherwise, a message will be sent to System.err.

     * </p>

     */

    public boolean getIgnoreMissingProperties() {

        return ignoreMissingProperties;

    }

    /**

     * How should missing properties be handled?

     *

     * <p>If ignore is true, missing or unreadable property files will

     * not be reported. Otherwise, a message will be sent to System.err.

     * </p>

     */

    public void setIgnoreMissingProperties(boolean ignore) {

        ignoreMissingProperties = ignore;

    }

    /**

     * How are missing properties handled?

     *

     * <p>If ignore is true, missing or unreadable property files will

     * not be reported. Otherwise, a message will be sent to System.err.

     * </p>

     *

     * @deprecated No longer static; use get/set methods.

     */

    public void ignoreMissingProperties(boolean ignore) {

        setIgnoreMissingProperties(ignore);

    }

    /**

     * Obtain the verbosity setting from the properties.

     *

     * @return The verbosity level from the propertyFile or the

     * defaultVerbosity.

     */

    private int queryVerbosity () {

        String defaultVerbStr = Integer.toString(defaultVerbosity);

        String verbStr = SecuritySupport.getSystemProperty(pVerbosity);

        if (verbStr == null) {

            if (resources==null) readProperties();

            if (resources != null) {

                try {

                    verbStr = resources.getString("verbosity");

                } catch (MissingResourceException e) {

                    verbStr = defaultVerbStr;

                }

            } else {

                verbStr = defaultVerbStr;

            }

        }

        int verb = defaultVerbosity;

        try {

            verb = Integer.parseInt(verbStr.trim());

        } catch (Exception e) {

            System.err.println("Cannot parse verbosity: \"" + verbStr + "\"");

        }

        // This is a bit of a hack. After we've successfully got the verbosity,

        // we have to use it to set the default debug level,

        // if the user hasn't already set the default debug level.

        if (verbosity == null) {

            debug.setDebug(verb);

            verbosity = new Integer(verb);

        }

        return verb;

    }

    /**

     * What is the current verbosity?

     */

    public int getVerbosity() {

        if (verbosity == null) {

            verbosity = new Integer(queryVerbosity());

        }

        return verbosity.intValue();

    }

    /**

     * Set the current verbosity.

     */

    public void setVerbosity (int verbosity) {

        this.verbosity = new Integer(verbosity);

        debug.setDebug(verbosity);

    }

    /**

     * What is the current verbosity?

     *

     * @deprecated No longer static; use get/set methods.

     */

    public int verbosity () {

        return getVerbosity();

    }

    /**

     * Obtain the relativeCatalogs setting from the properties.

     *

     * @return The relativeCatalogs setting from the propertyFile or the

     * defaultRelativeCatalogs.

     */

    private boolean queryRelativeCatalogs () {

        if (resources==null) readProperties();

        if (resources==null) return defaultRelativeCatalogs;

        try {

            String allow = resources.getString("relative-catalogs");

            return (allow.equalsIgnoreCase("true")

                    || allow.equalsIgnoreCase("yes")

                    || allow.equalsIgnoreCase("1"));

        } catch (MissingResourceException e) {

            return defaultRelativeCatalogs;

        }

    }

    /**

     * Get the relativeCatalogs setting.

     *

     * <p>This property is used when the catalogFiles property is

     * interrogated. If true, then relative catalog entry file names

     * are returned. If false, relative catalog entry file names are

     * made absolute with respect to the properties file before returning

     * them.</p>

     *

     * <p>This property <emph>only applies</emph> when the catalog files

     * come from a properties file. If they come from a system property or

     * the default list, they are never considered relative. (What would

     * they be relative to?)</p>

     *

     * <p>In the properties, a value of 'yes', 'true', or '1' is considered

     * true, anything else is false.</p>

     *

     * @return The relativeCatalogs setting from the propertyFile or the

     * defaultRelativeCatalogs.

     */

    public boolean getRelativeCatalogs () {

        if (relativeCatalogs == null) {

            relativeCatalogs = queryRelativeCatalogs() ? Boolean.TRUE : Boolean.FALSE;

        }

        return relativeCatalogs.booleanValue();

    }

    /**

     * Set the relativeCatalogs setting.

     *

     * @see #getRelativeCatalogs()

     */

    public void setRelativeCatalogs (boolean relative) {

        relativeCatalogs = relative ? Boolean.TRUE : Boolean.FALSE;

    }

    /**

     * Get the relativeCatalogs setting.

     *

     * @deprecated No longer static; use get/set methods.

     */

    public boolean relativeCatalogs () {

        return getRelativeCatalogs();

    }

    /**

     * Obtain the list of catalog files from the properties.

     *

     * @return A semicolon delimited list of catlog file URIs

     */

    private String queryCatalogFiles () {

        String catalogList = SecuritySupport.getSystemProperty(pFiles);

        fromPropertiesFile = false;