/*
 * 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.myfaces.test.config;

import org.apache.commons.digester.Digester;
import org.apache.commons.digester.Rule;
import org.apache.myfaces.test.mock.MockRenderKit;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;

import javax.faces.FactoryFinder;
import javax.faces.application.Application;
import javax.faces.application.ApplicationFactory;
import javax.faces.render.RenderKit;
import javax.faces.render.RenderKitFactory;
import javax.faces.render.Renderer;
import java.io.IOException;
import java.net.URL;

/**
 * <p>Utility class to parse JavaServer Faces configuration resources, and
 * register JSF artifacts with the mock object hierarchy.</p>
 *
 * <p>The following artifacts are registered:</p>
 * <ul>
 *     <li><code>Converter</code> (by-id and by-class)</li>
 *     <li><code>RenderKit</code> and <code>Renderer</code></li>
 *     <li><code>UIComponent</code></li>
 *     <li><code>Validator</code></li>
 * </ul>
 *
 * <p>Note that any declared <em>factory</em> instances are explicitly
 * <strong>NOT</strong> registered, allowing the mock object hierarchy
 * of the Myfaces Test Framework to manage these APIs.</p>
 *
 * <p><strong>USAGE NOTE</strong> - If you are using an instance of this
 * class within a subclass of <code>AbstractJsfTestCase</code> or
 * <code>AbstractJmockJsfTestCase</code>, be sure you have completed the
 * <code>setUp()</code> processing in this base class before calling one
 * of the <code>parse()</code> methods.</p>
 *
 * @since 1.0.0
 */
public class ConfigParser
{

    // ------------------------------------------------------------ Constructors

    /** Creates a new instance of ConfigParser */
    public ConfigParser()
    {
    }

    // ------------------------------------------------------ Manifest Constants

    /**
     * <p>Configuration resource URLs for the JSF RI.</p>
     */
    private static final String[] JSFRI_RESOURCES = { "/com/sun/faces/jsf-ri-runtime.xml", };

    /**
     * <p>Configuration resource URLs for Apache MyFaces.</p>
     */
    private static final String[] MYFACES_RESOURCES = { "/org/apache/myfaces/resource/standard-faces-config.xml", };

    /**
     * <p>Configuration resource URLs for Apache MyFaces 1.2.</p>
     */
    private static final String[] MYFACES_RESOURCES12 = { "/META-INF/standard-faces-config.xml", };

    // ------------------------------------------------------ Instance Variables

    /**
     * <p>The <code>Digester</code> instance we will use for parsing.</p>
     */
    private Digester digester = null;

    // ------------------------------------------------------- Public Properties

    /**
     * <p>Return the URLs of the platform configuration resources for this
     * application.  The following platforms are currently supported:</p>
     * <ul>
     * <li>JavaServer Faces Reference Implementation (version 1.0 - 1.2)</li>
     * <li>MyFaces (version 1.1)</li>
     * </ul>
     *
     * <p>If MyFaces (version 1.2), currently under development, does not change
     * the name of the configuration resource, it will be supported as well.</p>
     */
    public URL[] getPlatformURLs()
    {

        URL[] urls = translate(JSFRI_RESOURCES);
        if (urls[0] == null)
        {
            urls = translate(MYFACES_RESOURCES12);
            if (urls[0] == null)
            {
                urls = translate(MYFACES_RESOURCES);
            }
        }
        return urls;

    }

    // ---------------------------------------------------------- Public Methods

    /**
     * <p>Parse the specified JavaServer Faces configuration resource, causing
     * the appropriate JSF artifacts to be registered with the mock object
     * hierarchy.</p>
     *
     * @param url <code>URL</code> of the configuration resource to parse
     *
     * @exception IOException if an input/output error occurs
     * @exception SAXException if a parsing error occurs
     */
    public void parse(URL url) throws IOException, SAXException
    {

        // Acquire and configure the Digester instance we will use
        Digester digester = digester();
        ApplicationFactory factory = (ApplicationFactory) FactoryFinder
                .getFactory(FactoryFinder.APPLICATION_FACTORY);
        Application application = factory.getApplication();
        digester.push(application);

        // Perform the required parsing
        try
        {
            digester.parse(url);
        }
        finally
        {
            digester.clear();
        }

    }

    /**
     * <p>Parse the specified set of JavaServer Faces configuration resources,
     * in the listed order, causing the appropriate JSF artifacts to be registered
     * with the mock object hierarchy.</p>
     *
     * @param urls <code>URL</code>s of the configuration resources to parse
     *
     * @exception IOException if an input/output error occurs
     * @exception SAXException if a parsing error occurs
     */
    public void parse(URL[] urls) throws IOException, SAXException
    {

        for (int i = 0; i < urls.length; i++)
        {
            parse(urls[i]);
        }

    }

    // --------------------------------------------------------- Private Methods

    /**
     * <p>Return the <code>Digester</code> instance we will use for parsing,
     * creating and configuring a new instance if necessary.</p>
     */
    private Digester digester()
    {

        if (this.digester == null)
        {
            this.digester = new Digester();
            digester.addRule("faces-config/component", new ComponentRule());
            digester.addCallMethod("faces-config/component/component-type",
                    "setComponentType", 0);
            digester.addCallMethod("faces-config/component/component-class",
                    "setComponentClass", 0);
            digester.addRule("faces-config/converter", new ConverterRule());
            digester.addCallMethod("faces-config/converter/converter-id",
                    "setConverterId", 0);
            digester.addCallMethod("faces-config/converter/converter-class",
                    "setConverterClass", 0);
            digester.addCallMethod(
                    "faces-config/converter/converter-for-class",
                    "setConverterForClass", 0);
            digester.addRule("faces-config/render-kit", new RenderKitRule());
            digester.addRule("faces-config/render-kit/render-kit-id",
                    new RenderKitIdRule());
            digester.addRule("faces-config/render-kit/renderer",
                    new RendererRule());
            digester.addCallMethod(
                    "faces-config/render-kit/renderer/component-family",
                    "setComponentFamily", 0);
            digester.addCallMethod(
                    "faces-config/render-kit/renderer/renderer-class",
                    "setRendererClass", 0);
            digester.addCallMethod(
                    "faces-config/render-kit/renderer/renderer-type",
                    "setRendererType", 0);
            digester.addRule("faces-config/validator", new ValidatorRule());
            digester.addCallMethod("faces-config/validator/validator-id",
                    "setValidatorId", 0);
            digester.addCallMethod("faces-config/validator/validator-class",
                    "setValidatorClass", 0);
        }
        return this.digester;

    }

    /**
     * <p>Translate an array of resource names into an array of resource URLs.</p>
     *
     * @param names Resource names to translate
     */
    private URL[] translate(String[] names)
    {

        URL[] results = new URL[names.length];
        for (int i = 0; i < names.length; i++)
        {
            results[i] = this.getClass().getResource(names[i]);
        }
        return results;

    }

    // --------------------------------------------------------- Private Classes

    /**
     * <p>Data bean that stores information related to a component.</p>
     */
    class ComponentBean
    {

        private String componentClass;

        public String getComponentClass()
        {
            return this.componentClass;
        }

        public void setComponentClass(String componentClass)
        {
            this.componentClass = componentClass;
        }

        private String componentType;

        public String getComponentType()
        {
            return this.componentType;
        }

        public void setComponentType(String componentType)
        {
            this.componentType = componentType;
        }

    }

    /**
     * <p>Digester <code>Rule</code> for processing components.</p>
     */
    class ComponentRule extends Rule
    {

        public void begin(String namespace, String name, Attributes attributes)
        {
            getDigester().push(new ComponentBean());
        }

        public void end(String namespace, String name)
        {
            ComponentBean bean = (ComponentBean) getDigester().pop();
            Application application = (Application) getDigester().peek();
            application.addComponent(bean.getComponentType(), bean
                    .getComponentClass());
        }

    }

    /**
     * <p>Data bean that stores information related to a converter.</p>
     */
    class ConverterBean
    {

        private String converterClass;

        public String getConverterClass()
        {
            return this.converterClass;
        }

        public void setConverterClass(String converterClass)
        {
            this.converterClass = converterClass;
        }

        private String converterForClass;

        public String getConverterForClass()
        {
            return this.converterForClass;
        }

        public void setConverterForClass(String converterForClass)
        {
            this.converterForClass = converterForClass;
        }

        private String converterId;

        public String getConverterId()
        {
            return this.converterId;
        }

        public void setConverterId(String converterId)
        {
            this.converterId = converterId;
        }

    }

    /**
     * <p>Digester <code>Rule</code> for processing converers.</p>
     */
    class ConverterRule extends Rule
    {

        public void begin(String namespace, String name, Attributes attributes)
        {
            getDigester().push(new ConverterBean());
        }

        public void end(String namespace, String name)
        {
            ConverterBean bean = (ConverterBean) getDigester().pop();
            Application application = (Application) getDigester().peek();
            if (bean.getConverterId() != null)
            {
                application.addConverter(bean.getConverterId(), bean
                        .getConverterClass());
            }
            else
            {
                Class clazz = null;
                try
                {
                    clazz = classForName(bean.getConverterForClass());
                }
                catch (ClassNotFoundException e)
                {
                    throw new IllegalArgumentException(
                            "java.lang.ClassNotFoundException: "
                                    + bean.getConverterForClass());
                }
                application.addConverter(clazz, bean.getConverterClass());
            }
        }

    }

    private Class classForName(String type) throws ClassNotFoundException
    {
        try
        {
            // Try WebApp ClassLoader first
            return Class.forName(type, false, // do not initialize for faster startup
                    Thread.currentThread().getContextClassLoader());
        }
        catch (ClassNotFoundException ignore)
        {
            // fallback: Try ClassLoader for ClassUtils (i.e. the myfaces.jar lib)
            return Class.forName(type, false, // do not initialize for faster startup
                    this.getClass().getClassLoader());
        }
    }

    /**
     * <p>Digester <code>Rule</code> for processing render kits.</p>
     */
    class RenderKitRule extends Rule
    {

        public void begin(String namespace, String name, Attributes attributes)
        {
            RenderKitFactory factory = (RenderKitFactory) FactoryFinder
                    .getFactory(FactoryFinder.RENDER_KIT_FACTORY);
            getDigester().push(
                    factory.getRenderKit(null,
                            RenderKitFactory.HTML_BASIC_RENDER_KIT));
        }

        public void end(String namespace, String name)
        {
            getDigester().pop();
        }

    }

    /**
     * <p>Digester <code>Rule</code> for processing render kit identifiers.</p>
     */
    class RenderKitIdRule extends Rule
    {

        public void body(String namespace, String name, String text)
        {
            String renderKitId = text.trim();
            RenderKitFactory factory = (RenderKitFactory) FactoryFinder
                    .getFactory(FactoryFinder.RENDER_KIT_FACTORY);
            RenderKit renderKit = factory.getRenderKit(null, renderKitId);
            if (renderKit == null)
            {
                renderKit = new MockRenderKit();
                factory.addRenderKit(renderKitId, renderKit);
            }
            getDigester().pop();
            getDigester().push(renderKit);
        }

    }

    /**
     * <p>Data bean that stores information related to a renderer.</p>
     */
    class RendererBean
    {

        private String componentFamily;

        public String getComponentFamily()
        {
            return this.componentFamily;
        }

        public void setComponentFamily(String componentFamily)
        {
            this.componentFamily = componentFamily;
        }

        private String rendererClass;

        public String getRendererClass()
        {
            return this.rendererClass;
        }

        public void setRendererClass(String rendererClass)
        {
            this.rendererClass = rendererClass;
        }

        private String rendererType;

        public String getRendererType()
        {
            return this.rendererType;
        }

        public void setRendererType(String rendererType)
        {
            this.rendererType = rendererType;
        }

    }

    /**
     * <p>Digester <code>Rule</code> for processing renderers.</p>
     */
    class RendererRule extends Rule
    {

        public void begin(String namespace, String name, Attributes attributes)
        {
            getDigester().push(new RendererBean());
        }

        public void end(String namespace, String name)
        {
            RendererBean bean = (RendererBean) getDigester().pop();
            RenderKit kit = (RenderKit) getDigester().peek();
            Renderer renderer = null;
            Class clazz = null;
            try
            {
                clazz = classForName(bean.getRendererClass());
                renderer = (Renderer) clazz.newInstance();
            }
            catch (Exception e)
            {
                throw new IllegalArgumentException(
                        "Exception while trying to instantiate"
                                + " renderer class '" + bean.getRendererClass()
                                + "' : " + e.getMessage());
            }
            kit.addRenderer(bean.getComponentFamily(), bean.getRendererType(),
                    renderer);
        }

    }

    /**
     * <p>Data bean that stores information related to a validator.</p>
     */
    class ValidatorBean
    {

        private String validatorClass;

        public String getValidatorClass()
        {
            return this.validatorClass;
        }

        public void setValidatorClass(String validatorClass)
        {
            this.validatorClass = validatorClass;
        }

        private String validatorId;

        public String getValidatorId()
        {
            return this.validatorId;
        }

        public void setValidatorId(String validatorId)
        {
            this.validatorId = validatorId;
        }

    }

    /**
     * <p>Digester <code>Rule</code> for processing validators.</p>
     */
    class ValidatorRule extends Rule
    {

        public void begin(String namespace, String name, Attributes attributes)
        {
            getDigester().push(new ValidatorBean());
        }

        public void end(String namespace, String name)
        {
            ValidatorBean bean = (ValidatorBean) getDigester().pop();
            Application application = (Application) getDigester().peek();
            application.addValidator(bean.getValidatorId(), bean
                    .getValidatorClass());
        }

    }

}