/*
 * $Id: I18nFactorySet.java 265658 2005-09-01 05:54:57Z niallp $ 
 *
 * Copyright 1999-2005 The Apache Software Foundation.
 * 
 * Licensed 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.struts.tiles.xmlDefinition;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.StringTokenizer;

import javax.servlet.ServletContext;
import javax.servlet.ServletRequest;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.struts.taglib.tiles.ComponentConstants;
import org.apache.struts.tiles.DefinitionsFactoryException;
import org.apache.struts.tiles.FactoryNotFoundException;
import org.xml.sax.SAXException;

/**
 * Definitions factory.
 * This implementation allows to have a set of definition factories.
 * There is a main factory and one factory for each file associated to a Locale.
 *
 * To retrieve a definition, we first search for the appropriate factory using
 * the Locale found in session context. If no factory is found, use the
 * default one. Then we ask the factory for the definition.
 *
 * A definition factory file is loaded using main filename extended with locale code
 * (ex : <code>templateDefinitions_fr.xml</code>). If no file is found under this name, use default file.
 */
public class I18nFactorySet extends FactorySet {

    /** 
     * Commons Logging instance. 
     */
    protected static Log log = LogFactory.getLog(I18nFactorySet.class);

    /** 
     * Config file parameter name. 
     */
    public static final String DEFINITIONS_CONFIG_PARAMETER_NAME =
        "definitions-config";

    /** 
     * Config file parameter name. 
     */
    public static final String PARSER_DETAILS_PARAMETER_NAME =
        "definitions-parser-details";

    /** 
     * Config file parameter name. 
     */
    public static final String PARSER_VALIDATE_PARAMETER_NAME =
        "definitions-parser-validate";

    /** 
     * Possible definition filenames. 
     */
    public static final String DEFAULT_DEFINITION_FILENAMES[] =
        {
            "/WEB-INF/tileDefinitions.xml",
            "/WEB-INF/componentDefinitions.xml",
            "/WEB-INF/instanceDefinitions.xml" };

    /** 
     * Default filenames extension. 
     */
    public static final String FILENAME_EXTENSION = ".xml";

    /** 
     * Default factory. 
     */
    protected DefinitionsFactory defaultFactory = null;

    /** 
     * XML parser used.
     * Attribute is transient to allow serialization. In this implementaiton,
     * xmlParser is created each time we need it ;-(.
     */
    protected transient XmlParser xmlParser;

    /** 
     * Do we want validating parser. Default is <code>false</code>.
     * Can be set from servlet config file.
     */
    protected boolean isValidatingParser = false;

    /** 
     * Parser detail level. Default is 0.
     * Can be set from servlet config file.
     */
    protected int parserDetailLevel = 0;

    /** 
     * Names of files containing instances descriptions. 
     */
    private List filenames = null;

    /** 
     * Collection of already loaded definitions set, referenced by their suffix. 
     */
    private Map loaded = null;

    /**
     * Parameterless Constructor.
     * Method {@link #initFactory} must be called prior to any use of created factory.
     */
    public I18nFactorySet() {
        super();
    }

    /**
     * Constructor.
     * Init the factory by reading appropriate configuration file.
     * @param servletContext Servlet context.
     * @param properties Map containing all properties.
     * @throws FactoryNotFoundException Can't find factory configuration file.
     */
    public I18nFactorySet(ServletContext servletContext, Map properties)
        throws DefinitionsFactoryException {

        initFactory(servletContext, properties);
    }

    /**
     * Initialization method.
     * Init the factory by reading appropriate configuration file.
     * This method is called exactly once immediately after factory creation in
     * case of internal creation (by DefinitionUtil).
     * @param servletContext Servlet Context passed to newly created factory.
     * @param properties Map of name/property passed to newly created factory. Map can contains
     * more properties than requested.
     * @throws DefinitionsFactoryException An error occur during initialization.
     */
    public void initFactory(ServletContext servletContext, Map properties)
        throws DefinitionsFactoryException {

        // Set some property values
        String value = (String) properties.get(PARSER_VALIDATE_PARAMETER_NAME);
        if (value != null) {
            isValidatingParser = Boolean.valueOf(value).booleanValue();
        }

        value = (String) properties.get(PARSER_DETAILS_PARAMETER_NAME);
        if (value != null) {
            try {
                parserDetailLevel = Integer.valueOf(value).intValue();

            } catch (NumberFormatException ex) {
                log.error(
                    "Bad format for parameter '"
                        + PARSER_DETAILS_PARAMETER_NAME
                        + "'. Integer expected.");
            }
        }

        // init factory withappropriate configuration file
        // Try to use provided filename, if any.
        // If no filename are provided, try to use default ones.
        String filename = (String) properties.get(DEFINITIONS_CONFIG_PARAMETER_NAME);
        if (filename != null) { // Use provided filename
            try {
                initFactory(servletContext, filename);
                if (log.isDebugEnabled()) {
                    log.debug("Factory initialized from file '" + filename + "'.");
                }

            } catch (FileNotFoundException ex) { // A filename is specified, throw appropriate error.
                log.error(ex.getMessage() + " : Can't find file '" + filename + "'");
                throw new FactoryNotFoundException(
                    ex.getMessage() + " : Can't find file '" + filename + "'");
            }

        } else { // try each default file names
            for (int i = 0; i < DEFAULT_DEFINITION_FILENAMES.length; i++) {
                filename = DEFAULT_DEFINITION_FILENAMES[i];
                try {
                    initFactory(servletContext, filename);
                    if (log.isInfoEnabled()) {
                        log.info(
                            "Factory initialized from file '" + filename + "'.");
                    }
                } catch (FileNotFoundException ex) {
                    // Do nothing
                }
            }
        }

    }

    /**
     * Initialization method.
     * Init the factory by reading appropriate configuration file.
     * This method is called exactly once immediately after factory creation in
     * case of internal creation (by DefinitionUtil).
     * @param servletContext Servlet Context passed to newly created factory.
     * @param proposedFilename File names, comma separated, to use as  base file names.
     * @throws DefinitionsFactoryException An error occur during initialization.
     */
    protected void initFactory(
        ServletContext servletContext,
        String proposedFilename)
        throws DefinitionsFactoryException, FileNotFoundException {

        // Init list of filenames
        StringTokenizer tokenizer = new StringTokenizer(proposedFilename, ",");
        this.filenames = new ArrayList(tokenizer.countTokens());
        while (tokenizer.hasMoreTokens()) {
            this.filenames.add(tokenizer.nextToken().trim());
        }

        loaded = new HashMap();
        defaultFactory = createDefaultFactory(servletContext);
        if (log.isDebugEnabled())
            log.debug("default factory:" + defaultFactory);
    }

    /**
     * Get default factory.
     * @return Default factory
     */
    protected DefinitionsFactory getDefaultFactory() {
        return defaultFactory;
    }

    /**
     * Create default factory .
     * Create InstancesMapper for specified Locale.
     * If creation failes, use default mapper and log error message.
     * @param servletContext Current servlet context. Used to open file.
     * @return Created default definition factory.
     * @throws DefinitionsFactoryException If an error occur while creating factory.
     * @throws FileNotFoundException if factory can't be loaded from filenames.
     */
    protected DefinitionsFactory createDefaultFactory(ServletContext servletContext)
        throws DefinitionsFactoryException, FileNotFoundException {

        XmlDefinitionsSet rootXmlConfig = parseXmlFiles(servletContext, "", null);
        if (rootXmlConfig == null) {
            throw new FileNotFoundException();
        }

        rootXmlConfig.resolveInheritances();

        if (log.isDebugEnabled()) {
            log.debug(rootXmlConfig);
        }

        DefinitionsFactory factory = new DefinitionsFactory(rootXmlConfig);
        if (log.isDebugEnabled()) {
            log.debug("factory loaded : " + factory);
        }

        return factory;
    }

    /**
     * Extract key that will be used to get the sub factory.
     * @param name Name of requested definition
     * @param request Current servlet request.
     * @param servletContext Current servlet context.
     * @return the key or <code>null</code> if not found.