/*
 *  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.buildtools.maven2.plugin.tagdoc;

import java.io.File;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.StringWriter;
import java.io.Writer;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

import org.apache.commons.digester.AbstractObjectCreationFactory;
import org.apache.maven.artifact.DependencyResolutionRequiredException;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.project.MavenProject;
import org.apache.maven.reporting.MavenReportException;
import org.apache.myfaces.buildtools.maven2.plugin.builder.Flattener;
import org.apache.myfaces.buildtools.maven2.plugin.builder.IOUtils;
import org.apache.myfaces.buildtools.maven2.plugin.builder.model.BehaviorMeta;
import org.apache.myfaces.buildtools.maven2.plugin.builder.model.ClassMeta;
import org.apache.myfaces.buildtools.maven2.plugin.builder.model.ComponentMeta;
import org.apache.myfaces.buildtools.maven2.plugin.builder.model.ConverterMeta;
import org.apache.myfaces.buildtools.maven2.plugin.builder.model.FaceletFunctionMeta;
import org.apache.myfaces.buildtools.maven2.plugin.builder.model.FaceletTagMeta;
import org.apache.myfaces.buildtools.maven2.plugin.builder.model.Model;
import org.apache.myfaces.buildtools.maven2.plugin.builder.model.TagMeta;
import org.apache.myfaces.buildtools.maven2.plugin.builder.model.ValidatorMeta;
import org.apache.myfaces.buildtools.maven2.plugin.builder.utils.MavenPluginConsoleLogSystem;
import org.apache.myfaces.buildtools.maven2.plugin.builder.utils.MyfacesUtils;
import org.apache.velocity.Template;
import org.apache.velocity.VelocityContext;
import org.apache.velocity.app.VelocityEngine;
import org.apache.velocity.context.Context;
import org.apache.velocity.runtime.RuntimeConstants;
import org.apache.velocity.runtime.resource.ResourceManagerImpl;
import org.codehaus.plexus.util.IOUtil;
import org.codehaus.plexus.util.xml.Xpp3Dom;
import org.codehaus.plexus.util.xml.Xpp3DomBuilder;
import org.codehaus.plexus.util.xml.Xpp3DomWriter;
import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
import org.xml.sax.Attributes;

/**
 * 
 * Generate the tag doc content pages using velocity. This is done before
 * site, because maven-site-plugin use velocity and if we do this inside 
 * report generation, we cause a ClassLoader problem.
 * 
 * @author Leonardo Uribe
 * @goal tagdoc-content
 * @phase generate-resources
 */
public class TagdocContentMojo extends AbstractMojo
{
    private Model _model;

    /**
     * Specifies the directory where the report will be generated
     *
     * @parameter default-value="${project.reporting.outputDirectory}"
     * @required
     */
    private File outputDirectory;

    /**
     * Directory where the original site is present.
     * (TRIED using ${baseDir}/src/site;  that inserted a 'null' into
     * the string for some reason.  TRIED using ${siteDirectory},
     * which was undefined.  TRIED ${project.directory}src/site; which also
     * inserted a null.  ${project.build.directory}/../src/site seems to work,
     * though it assumes that ${project.build.directory} is 
     * ${project.directory}/target.
     * 
     * @parameter default-value="${project.build.directory}/../src/site/"
     * @required
     */
    private File siteDirectory;

    /**
     * @parameter expression="${project}"
     * @required
     * @readonly
     */
    private MavenProject project;

    /**
     * @parameter
     */
    private Map taglibs;
        
    /**
     * @parameter expression="${project.build.directory}/generated-resources/myfaces-builder-plugin"
     */
    private File buildDirectory;

    /**
     * Injected name of file generated by earlier run of BuildMetaDataMojo goal.
     * 
     * @parameter
     */
    private String metadataFile = "META-INF/myfaces-metadata.xml";
    
    /**
     * @parameter expression="src/main/resources/META-INF"
     */
    private File templateSourceDirectory;
    
    /**
     * @parameter expression="src/main/tagdoc"
     */    
    private File baseFilesSourceDirectory;
    
    /**
     * @parameter
     */
    private List modelIds;
    
    /**
     * @parameter expression="xdoc-component.vm"
     */
    private String templateComponent;
    
    /**
     * @parameter expression="xdoc-converter.vm"
     */
    private String templateConverter;
    
    /**
     * @parameter expression="xdoc-validator.vm"
     */
    private String templateValidator;

    /**
     * @since 1.0.6
     * @parameter expression="xdoc-behavior.vm"
     */
    private String templateBehavior;
    
    /**
     * @parameter expression="xdoc-tag.vm"
     */
    private String templateTag;
    
    /**
     * @since 1.0.4
     * @parameter expression="xdoc-facelet-tag.vm"
     */
    private String templateFaceletTag;
    
    /**
     * 
     * @since 1.0.10
     * @parameter expression="xdoc-facelet-functions.vm"
     */
    private String templateFaceletFunctions;
    
    /**
     * Defines the jsf version (1.1, 1.2 or 2.0), used to pass it and add default 
     * properties for converters or validators in jsf 2.0.
     * 
     * @parameter
     */
    private String jsfVersion;

    static private final String _DOC_SUBDIRECTORY = "tagdoc";

    public void execute() throws MojoExecutionException, MojoFailureException
    {
        if (modelIds == null)
        {
            modelIds = new ArrayList();
            modelIds.add(project.getArtifactId());
        }
        
        if (taglibs == null)
        {
            taglibs = new HashMap();
            taglibs.put("t", "http://myfaces.apache.org/tomahawk");
        }
        
        try
        {
            _model = IOUtils.loadModel(new File(buildDirectory,
                    metadataFile));
            new Flattener(_model).flatten();            
            _generateTagDocs();
        }
        catch (Exception e)
        {
            throw new MojoExecutionException("Couldn't generate tagdoc", e);
        }        
    }
    
    public boolean canGenerate(ClassMeta component)
    {
        if ( modelIds.contains(component.getModelId()))
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    public boolean canGenerate(FaceletFunctionMeta component)
    {
        if (modelIds.contains(component.getModelId()))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    
    public class CustomResourceManagerImpl extends ResourceManagerImpl
    {
        public CustomResourceManagerImpl()
        {
            super();
        }
    }
    
    private VelocityEngine initVelocity() throws MojoExecutionException
    {        
        VelocityEngine velocityEngine = new VelocityEngine();
                
        try
        {
            velocityEngine.setProperty( "resource.loader", "file, class" );
            velocityEngine.setProperty( "file.resource.loader.class",
                    "org.apache.velocity.runtime.resource.loader.FileResourceLoader");
            velocityEngine.setProperty( "file.resource.loader.path", templateSourceDirectory.getPath());
            velocityEngine.setProperty( "class.resource.loader.class",
                    "org.apache.myfaces.buildtools.maven2.plugin.builder.utils.RelativeClasspathResourceLoader" );
            velocityEngine.setProperty( "class.resource.loader.path", "META-INF");                    
            velocityEngine.setProperty( "velocimacro.library", "componentClassMacros11.vm");
            velocityEngine.setProperty( "velocimacro.permissions.allow.inline","true");
            velocityEngine.setProperty( "velocimacro.permissions.allow.inline.local.scope", "true");
            velocityEngine.setProperty( "directive.foreach.counter.initial.value","0");
            //velocityEngine.setProperty( RuntimeConstants.RUNTIME_LOG_LOGSYSTEM_CLASS,
            //"org.apache.myfaces.buildtools.maven2.plugin.builder.utils.ConsoleLogSystem" );

            velocityEngine.setProperty(RuntimeConstants.RUNTIME_LOG_LOGSYSTEM,
                    new MavenPluginConsoleLogSystem(this.getLog()));
            velocityEngine.init();
        }
        catch (Exception e)
        {
            throw new MojoExecutionException("Error creating VelocityEngine", e);
        }
        
        return velocityEngine;
                
    }
            
    private void _generateTagDocs() throws Exception
    {
        Model model = getModel();
        if (model.getComponents().size() == 0)
        {
            getLog().info("Nothing to generate - no components found");
            return;
        }
        
        VelocityEngine velocityEngine = initVelocity();
        
        VelocityContext baseContext = new VelocityContext();
        baseContext.put("utils", new MyfacesUtils());
        baseContext.put("tagdocUtils", new TagdocUtils());
        baseContext.put("model",getModel());
        baseContext.put("jsf20", new Boolean(_is20()));
        
        Iterator components = model.components();

        Iterator validators = model.validators();

        Iterator converters = model.converters();
        
        Iterator behaviors = model.behaviors();
        
        Iterator tags = model.tags();
        
        Iterator faceletTags = model.faceletTags();
        
        Iterator faceletFunctions = model.faceletFunctions();
        
        Map<String, List<FaceletFunctionMeta>> faceletFunctionByModelId = 
            new HashMap<String, List<FaceletFunctionMeta>>();
        
        Set componentPages = new TreeSet();
        Set converterPages = new TreeSet();
        Set validatorPages = new TreeSet();
        Set behaviorPages = new TreeSet();
        Set tagsPages = new TreeSet();
        Set faceletTagsPages = new TreeSet();
        Set faceletFunctionPages = new TreeSet();

        int count = 0;
        while (components.hasNext())
        {
            ComponentMeta component = (ComponentMeta) components.next();
            if (canGenerate(component))
            {
                String pageName = _generateComponentDoc(velocityEngine,baseContext,model,component);
                if (pageName != null)
                {
                    componentPages.add(pageName);
                    count++;
                }
            }
        }
        while (converters.hasNext())
        {
            ConverterMeta converter = (ConverterMeta) converters.next();
            if (canGenerate(converter))
            {
                String pageName = _generateConverterDoc(velocityEngine,baseContext,model,converter);
                if (pageName != null)
                {
                    converterPages.add(pageName);
                    count++;
                }
            }
        }
        while (validators.hasNext())
        {
            ValidatorMeta validator = (ValidatorMeta) validators.next();

            if (canGenerate(validator))
            {
                String pageName = _generateValidatorDoc(velocityEngine,baseContext,model,validator);
                if (pageName != null)
                {
                    validatorPages.add(pageName);
                    count++;
                }
            }
        }
        while (behaviors.hasNext())
        {
            BehaviorMeta behavior = (BehaviorMeta) behaviors.next();
            if (canGenerate(behavior))
            {
                String pageName = _generateBehaviorDoc(velocityEngine,baseContext,model,behavior);
                if (pageName != null)
                {
                    behaviorPages.add(pageName);
                    count++;
                }
            }
        }
        while (tags.hasNext())
        {
            TagMeta tag = (TagMeta) tags.next();
            
            if (canGenerate(tag))
            {
                String pageName = _generateTagDoc(velocityEngine,baseContext,model,tag);
                if (pageName != null)
                {
                    tagsPages.add(pageName);
                    count++;
                }                
            }
        }
        while (faceletTags.hasNext())
        {
            FaceletTagMeta faceletTag = (FaceletTagMeta) faceletTags.next();
            
            if (canGenerate(faceletTag))
            {
                String pageName = _generateFaceletTagDoc(velocityEngine,baseContext,model,faceletTag);
                if (pageName != null)
                {
                    faceletTagsPages.add(pageName);
                    count++;
                }
            }
        }
        
        for (int i = 0; i < modelIds.size(); i++)
        {
            String modelId = (String) modelIds.get(i);
            
            faceletFunctionByModelId.put(modelId, new ArrayList<FaceletFunctionMeta>());
        }

        while (faceletFunctions.hasNext())
        {
            FaceletFunctionMeta faceletFunction = (FaceletFunctionMeta) faceletFunctions.next();
            
            if (canGenerate(faceletFunction))
            {
                String pageName = _generateFaceletFunctionDoc(velocityEngine, baseContext, model, faceletFunction);
                if (pageName != null)
                {
                    faceletFunctionPages.add(pageName);
                    count++;
                }
            }
        }

        Set otherPages = _gatherOtherTags();

        getLog().info("Generated " + count + " page(s)");
    }

    private Set _gatherOtherTags()
    {
        TreeSet set = new TreeSet();
        String subDir = _platformAgnosticPath(_platformAgnosticPath("xdoc/"
                + _DOC_SUBDIRECTORY));
        File siteSubDir = new File(siteDirectory, subDir);
        if (siteSubDir.exists())
        {
            String[] files = siteSubDir.list();
            for (int i = 0; i < files.length; i++)
            {
                String file = files[i];
                if (file.endsWith(".xml"))
                {
                    set.add(file.substring(0, file.length() - 4));
                }
            }
        }

        return set;
    }

    public boolean usePageLinkBar()
    {
        return false;
    }

    private String _toPageName(String qName)
    {
        return MyfacesUtils.getTagPrefix(qName) + "_" + MyfacesUtils.getTagName(qName);
    }

    private String _generateComponentDoc(VelocityEngine velocityEngine, 
            VelocityContext baseContext, Model model, ComponentMeta component)
            throws Exception
    {
        if (component.getName() == null)
        {
            return null;
        }
        String pageName = _toPageName(component.getName());
        
        Context context = new VelocityContext(baseContext);
        context.put("component", component);
        context.put("jsf20", new Boolean(_is20()));
        FaceletTagMeta faceletTag = model.findFaceletTagByName(component.getName());
        if (faceletTag == null && component.getTagHandler() != null)
        {
            faceletTag = model.findFaceletTagByClassName(component.getTagHandler());
        }
        if (faceletTag != null)
        {
            context.put("faceletTag", faceletTag);
        }
        
        String baseContent = "";
        
        File xmlBaseFile = new File(baseFilesSourceDirectory, 
                _platformAgnosticPath(pageName + "-base.xml"));
        
        if (xmlBaseFile != null && xmlBaseFile.exists())
        {
            if (getLog().isDebugEnabled())
            {
                getLog().debug("using base content file: "+xmlBaseFile.getPath());
            }
            
            Reader reader = null;
            try
            {
                reader = new FileReader(xmlBaseFile);
                Xpp3Dom root = Xpp3DomBuilder.build(reader);
                
                StringWriter writer = new StringWriter();
                
                Xpp3Dom [] children = root.getChild("body").getChildren();
                
                for (int i = 0; i< children.length; i++)
                {
                    Xpp3Dom dom = children[i];
                    Xpp3DomWriter.write(writer, dom);
                }
                baseContent = writer.toString();
                writer.close();
            }
            catch (XmlPullParserException e)
            {
                throw new MojoExecutionException(
                        "Error parsing base file: " + e.getMessage(), e);
            }
            finally
            {
                reader.close();
            }
        }
        
        baseContext.put("baseContent", baseContent);        
        
        Writer out = null;
        
        try
        {        
            File targetDir = new File(outputDirectory.getParentFile(),
                    _platformAgnosticPath("generated-site/xdoc/"
                            + _DOC_SUBDIRECTORY));
            
            if ( !targetDir.exists() )
            {
                targetDir.mkdirs();
            }
            File targetFile = new File(targetDir, pageName + ".xml");
    
            out = new OutputStreamWriter(new FileOutputStream(targetFile),
                    "UTF-8");
            
            Template template = velocityEngine.getTemplate(getTemplateComponent());
            
            template.merge(context, out);
            
            out.flush();
        }
        catch (Exception e)
        {
            throw new MojoExecutionException(
                    "Error merging velocity templates: " + e.getMessage(), e);
        }
        finally
        {
            IOUtil.close(out);
            out = null;
        }

        return pageName;
    }

    private String _generateConverterDoc(VelocityEngine velocityEngine, 
            VelocityContext baseContext, Model model, ConverterMeta converter)
            throws Exception
    {
        if (converter.getName() == null)
        {
            return null;
        }

        String pageName = _toPageName(converter.getName());
        
        Context context = new VelocityContext(baseContext);
        context.put("converter", converter);
        context.put("jsf20", new Boolean(_is20()));
        FaceletTagMeta faceletTag = model.findFaceletTagByName(converter.getName());
        if (faceletTag == null && converter.getTagHandler() != null)
        {
            faceletTag = model.findFaceletTagByClassName(converter.getTagHandler());
        }
        if (faceletTag != null)
        {
            context.put("faceletTag", faceletTag);
        }
        
        String baseContent = "";
        
        File xmlBaseFile = new File(baseFilesSourceDirectory, 
                _platformAgnosticPath(pageName + "-base.xml"));
        
        if (xmlBaseFile != null && xmlBaseFile.exists())
        {
            if (getLog().isDebugEnabled())
            {
                getLog().debug("using base content file: "+xmlBaseFile.getPath());
            }
            
            Reader reader = null;
            try
            {
                reader = new FileReader(xmlBaseFile);
                Xpp3Dom root = Xpp3DomBuilder.build(reader);
                
                StringWriter writer = new StringWriter();
                
                Xpp3Dom [] children = root.getChild("body").getChildren();
                
                for (int i = 0; i< children.length; i++)
                {
                    Xpp3Dom dom = children[i];
                    Xpp3DomWriter.write(writer, dom);
                }
                baseContent = writer.toString();
                writer.close();
            }
            catch (XmlPullParserException e)
            {
                throw new MojoExecutionException(
                        "Error parsing base file: " + e.getMessage(), e);
            }
            finally
            {
                reader.close();
            }
        }
        
        baseContext.put("baseContent", baseContent);        
        
        Writer out = null;
        
        try
        {        
            File targetDir = new File(outputDirectory.getParentFile(),
                    _platformAgnosticPath("generated-site/xdoc/"
                            + _DOC_SUBDIRECTORY));
            
            if ( !targetDir.exists() )
            {
                targetDir.mkdirs();
            }
            File targetFile = new File(targetDir, pageName + ".xml");
    
            out = new OutputStreamWriter(new FileOutputStream(targetFile),
                    "UTF-8");
            
            Template template = velocityEngine.getTemplate(getTemplateConverter());
            
            template.merge(context, out);
            
            out.flush();
        }
        catch (Exception e)
        {
            throw new MojoExecutionException(
                    "Error merging velocity templates: " + e.getMessage(), e);
        }
        finally
        {
            IOUtil.close(out);
            out = null;
        }

        return pageName;
    }

    private String _generateValidatorDoc(VelocityEngine velocityEngine, 
            VelocityContext baseContext, Model model, ValidatorMeta validator)
            throws Exception
    {
        if (validator.getName() == null)
        {
            return null;
        }

        String pageName = _toPageName(validator.getName());
        
        Context context = new VelocityContext(baseContext);
        context.put("validator", validator);
        context.put("jsf20", new Boolean(_is20()));
        FaceletTagMeta faceletTag = model.findFaceletTagByName(validator.getName());
        if (faceletTag == null && validator.getTagHandler() != null)
        {
            faceletTag = model.findFaceletTagByClassName(validator.getTagHandler());
        }
        if (faceletTag != null)
        {
            context.put("faceletTag", faceletTag);
        }
        
        String baseContent = "";
        
        File xmlBaseFile = new File(baseFilesSourceDirectory, 
                _platformAgnosticPath(pageName + "-base.xml"));
        
        if (xmlBaseFile != null && xmlBaseFile.exists())
        {
            if (getLog().isDebugEnabled())
            {
                getLog().debug("using base content file: "+xmlBaseFile.getPath());
            }
            
            Reader reader = null;
            try
            {
                reader = new FileReader(xmlBaseFile);
                Xpp3Dom root = Xpp3DomBuilder.build(reader);
                
                StringWriter writer = new StringWriter();
                
                Xpp3Dom [] children = root.getChild("body").getChildren();
                
                for (int i = 0; i< children.length; i++)
                {
                    Xpp3Dom dom = children[i];
                    Xpp3DomWriter.write(writer, dom);
                }
                baseContent = writer.toString();
                writer.close();
            }
            catch (XmlPullParserException e)
            {
                throw new MojoExecutionException(
                        "Error parsing base file: " + e.getMessage(), e);
            }
            finally
            {
                reader.close();
            }
        }
        
        baseContext.put("baseContent", baseContent);        
        
        Writer out = null;
        
        try
        {        
            File targetDir = new File(outputDirectory.getParentFile(),
                    _platformAgnosticPath("generated-site/xdoc/"
                            + _DOC_SUBDIRECTORY));
            
            if ( !targetDir.exists() )
            {
                targetDir.mkdirs();
            }
            File targetFile = new File(targetDir, pageName + ".xml");
    
            out = new OutputStreamWriter(new FileOutputStream(targetFile),
                    "UTF-8");
            
            Template template = velocityEngine.getTemplate(getTemplateValidator());
            
            template.merge(context, out);
            
            out.flush();
        }
        catch (Exception e)
        {
            throw new MojoExecutionException(
                    "Error merging velocity templates: " + e.getMessage(), e);
        }
        finally
        {
            IOUtil.close(out);
            out = null;
        }

        return pageName;
    }
    
    private String _generateBehaviorDoc(VelocityEngine velocityEngine, 
            VelocityContext baseContext, Model model, BehaviorMeta behavior)
            throws Exception
    {
        if (behavior.getName() == null)
        {
            return null;
        }

        String pageName = _toPageName(behavior.getName());
        
        Context context = new VelocityContext(baseContext);
        context.put("behavior", behavior);
        context.put("jsf20", new Boolean(_is20()));
        FaceletTagMeta faceletTag = model.findFaceletTagByName(behavior.getName());
        if (faceletTag != null)
        {
            context.put("faceletTag", faceletTag);
        }
        
        String baseContent = "";
        
        File xmlBaseFile = new File(baseFilesSourceDirectory, 
                _platformAgnosticPath(pageName + "-base.xml"));
        
        if (xmlBaseFile != null && xmlBaseFile.exists())
        {
            if (getLog().isDebugEnabled())
            {
                getLog().debug("using base content file: "+xmlBaseFile.getPath());
            }
            
            Reader reader = null;
            try
            {
                reader = new FileReader(xmlBaseFile);
                Xpp3Dom root = Xpp3DomBuilder.build(reader);
                
                StringWriter writer = new StringWriter();
                
                Xpp3Dom [] children = root.getChild("body").getChildren();
                
                for (int i = 0; i< children.length; i++)
                {
                    Xpp3Dom dom = children[i];
                    Xpp3DomWriter.write(writer, dom);
                }
                baseContent = writer.toString();
                writer.close();
            }
            catch (XmlPullParserException e)
            {
                throw new MojoExecutionException(
                        "Error parsing base file: " + e.getMessage(), e);
            }
            finally
            {
                reader.close();
            }
        }
        
        baseContext.put("baseContent", baseContent);        
        
        Writer out = null;
        
        try
        {        
            File targetDir = new File(outputDirectory.getParentFile(),
                    _platformAgnosticPath("generated-site/xdoc/"
                            + _DOC_SUBDIRECTORY));
            
            if ( !targetDir.exists() )
            {
                targetDir.mkdirs();
            }
            File targetFile = new File(targetDir, pageName + ".xml");
    
            out = new OutputStreamWriter(new FileOutputStream(targetFile),
                    "UTF-8");
            
            Template template = velocityEngine.getTemplate(getTemplateBehavior());
            
            template.merge(context, out);
            
            out.flush();
        }
        catch (Exception e)
        {
            throw new MojoExecutionException(
                    "Error merging velocity templates: " + e.getMessage(), e);
        }
        finally
        {
            IOUtil.close(out);
            out = null;
        }

        return pageName;
    }
    
    private String _generateTagDoc(VelocityEngine velocityEngine, 
            VelocityContext baseContext, Model model, TagMeta tag)
            throws Exception
    {
        if (tag.getName() == null)
        {
            return null;
        }

        String pageName = _toPageName(tag.getName());
        
        Context context = new VelocityContext(baseContext);
        context.put("tag", tag);
        context.put("jsf20", new Boolean(_is20()));
        FaceletTagMeta faceletTag = model.findFaceletTagByName(tag.getName());
        if (faceletTag == null && tag.getTagHandler() != null)
        {
            faceletTag = model.findFaceletTagByClassName(tag.getTagHandler());
        }
        if (faceletTag != null)
        {
            context.put("faceletTag", faceletTag);
        }
        
        String baseContent = "";
        
        File xmlBaseFile = new File(baseFilesSourceDirectory, 
                _platformAgnosticPath(pageName + "-base.xml"));
        
        if (xmlBaseFile != null && xmlBaseFile.exists())
        {
            if (getLog().isDebugEnabled())
            {
                getLog().debug("using base content file: "+xmlBaseFile.getPath());
            }
            
            Reader reader = null;
            try
            {
                reader = new FileReader(xmlBaseFile);
                Xpp3Dom root = Xpp3DomBuilder.build(reader);
                
                StringWriter writer = new StringWriter();
                
                Xpp3Dom [] children = root.getChild("body").getChildren();
                
                for (int i = 0; i< children.length; i++)
                {
                    Xpp3Dom dom = children[i];
                    Xpp3DomWriter.write(writer, dom);
                }
                baseContent = writer.toString();
                writer.close();
            }
            catch (XmlPullParserException e)
            {
                throw new MojoExecutionException(
                        "Error parsing base file: " + e.getMessage(), e);
            }
            finally
            {
                reader.close();
            }
        }
        
        baseContext.put("baseContent", baseContent);        
        
        Writer out = null;
        
        try
        {        
            File targetDir = new File(outputDirectory.getParentFile(),
                    _platformAgnosticPath("generated-site/xdoc/"
                            + _DOC_SUBDIRECTORY));
            
            if ( !targetDir.exists() )
            {
                targetDir.mkdirs();
            }
            File targetFile = new File(targetDir, pageName + ".xml");
    
            out = new OutputStreamWriter(new FileOutputStream(targetFile),
                    "UTF-8");
            
            Template template = velocityEngine.getTemplate(getTemplateTag());
            
            template.merge(context, out);
            
            out.flush();
        }
        catch (Exception e)
        {
            throw new MojoExecutionException(
                    "Error merging velocity templates: " + e.getMessage(), e);
        }
        finally
        {
            IOUtil.close(out);
            out = null;
        }

        return pageName;
    }
    
    private String _generateFaceletFunctionDoc(
            VelocityEngine velocityEngine, 
            VelocityContext baseContext, 
            Model model, FaceletFunctionMeta faceletFunction)
    throws Exception
    {
        String pageName = _toPageName(faceletFunction.getName());
        
        Context context = new VelocityContext(baseContext);
        context.put("faceletFunction", faceletFunction);
        context.put("jsf20", new Boolean(_is20()));
        
        String baseContent = "";
        
        File xmlBaseFile = new File(baseFilesSourceDirectory, 
                _platformAgnosticPath(pageName + "-base.xml"));
        
        if (xmlBaseFile != null && xmlBaseFile.exists())
        {
            if (getLog().isDebugEnabled())
            {
                getLog().debug("using base content file: "+xmlBaseFile.getPath());
            }
            
            Reader reader = null;
            try
            {
                reader = new FileReader(xmlBaseFile);
                Xpp3Dom root = Xpp3DomBuilder.build(reader);
                
                StringWriter writer = new StringWriter();
                
                Xpp3Dom [] children = root.getChild("body").getChildren();
                
                for (int i = 0; i< children.length; i++)
                {
                    Xpp3Dom dom = children[i];
                    Xpp3DomWriter.write(writer, dom);
                }
                baseContent = writer.toString();
                writer.close();
            }
            catch (XmlPullParserException e)
            {
                throw new MojoExecutionException(
                        "Error parsing base file: " + e.getMessage(), e);
            }
            finally
            {
                reader.close();
            }
        }
        
        baseContext.put("baseContent", baseContent);        
        
        Writer out = null;
        
        try
        {        
            File targetDir = new File(outputDirectory.getParentFile(),
                    _platformAgnosticPath("generated-site/xdoc/"
                            + _DOC_SUBDIRECTORY));
            
            if ( !targetDir.exists() )
            {
                targetDir.mkdirs();
            }
            File targetFile = new File(targetDir, pageName + ".xml");
    
            out = new OutputStreamWriter(new FileOutputStream(targetFile),
                    "UTF-8");
            
            Template template = velocityEngine.getTemplate(getTemplateFaceletFunctions());
            
            template.merge(context, out);
            
            out.flush();
        }
        catch (Exception e)
        {
            throw new MojoExecutionException(
                    "Error merging velocity templates: " + e.getMessage(), e);
        }
        finally
        {
            IOUtil.close(out);
            out = null;
        }

        return pageName;
    }
    
    private String _generateFaceletTagDoc(VelocityEngine velocityEngine, 
            VelocityContext baseContext, Model model, FaceletTagMeta faceletTag)
            throws Exception
    {
        String name = faceletTag.getName(); 
        if (name == null)
        {
            return null;
        }
        
        if (faceletTag.getComponentClass() != null)
        {
            ComponentMeta comp = model.findComponentByClassName(faceletTag.getComponentClass());
            if (name.equals(comp.getName()))
            {
                //Exists in jsp and in facelets, but has specific facelets properties
                return null;
            }
        }
        if (faceletTag.getConverterClass() != null)
        {
            ConverterMeta comp = model.findConverterByClassName(faceletTag.getConverterClass());
            if (name.equals(comp.getName()))
            {
                //Exists in jsp and in facelets, but has specific facelets properties
                return null;
            }            
        }
        if (faceletTag.getValidatorClass() != null)
        {
            ValidatorMeta comp = model.findValidatorByClassName(faceletTag.getValidatorClass());
            if (name.equals(comp.getName()))
            {
                //Exists in jsp and in facelets, but has specific facelets properties
                return null;
            }            
        }
        if (faceletTag.getBehaviorClass() != null)
        {
            BehaviorMeta comp = model.findBehaviorByClassName(faceletTag.getBehaviorClass());
            if (name.equals(comp.getName()))
            {
                //Exists in jsp and in facelets, but has specific facelets properties
                return null;
            }
        }
        if (faceletTag.getTagClass() != null)
        {
            TagMeta comp = model.findTagByClassName(faceletTag.getTagClass());
            if (name.equals(comp.getName()))
            {
                //Exists in jsp and in facelets, but has specific facelets properties
                return null;
            }
        }

        String pageName = _toPageName(faceletTag.getName());
        
        Context context = new VelocityContext(baseContext);
        context.put("faceletTag", faceletTag);
        context.put("jsf20", new Boolean(_is20()));
        
        String baseContent = "";
        
        File xmlBaseFile = new File(baseFilesSourceDirectory, 
                _platformAgnosticPath(pageName + "-base.xml"));
        
        if (xmlBaseFile != null && xmlBaseFile.exists())
        {
            if (getLog().isDebugEnabled())
            {
                getLog().debug("using base content file: "+xmlBaseFile.getPath());
            }
            
            Reader reader = null;
            try
            {
                reader = new FileReader(xmlBaseFile);
                Xpp3Dom root = Xpp3DomBuilder.build(reader);
                
                StringWriter writer = new StringWriter();
                
                Xpp3Dom [] children = root.getChild("body").getChildren();
                
                for (int i = 0; i< children.length; i++)
                {
                    Xpp3Dom dom = children[i];
                    Xpp3DomWriter.write(writer, dom);
                }
                baseContent = writer.toString();
                writer.close();
            }
            catch (XmlPullParserException e)
            {
                throw new MojoExecutionException(
                        "Error parsing base file: " + e.getMessage(), e);
            }
            finally
            {
                reader.close();
            }
        }
        
        baseContext.put("baseContent", baseContent);        
        
        Writer out = null;
        
        try
        {        
            File targetDir = new File(outputDirectory.getParentFile(),
                    _platformAgnosticPath("generated-site/xdoc/"
                            + _DOC_SUBDIRECTORY));
            
            if ( !targetDir.exists() )
            {
                targetDir.mkdirs();
            }
            File targetFile = new File(targetDir, pageName + ".xml");
    
            out = new OutputStreamWriter(new FileOutputStream(targetFile),
                    "UTF-8");
            
            Template template = velocityEngine.getTemplate(getTemplateFaceletTag());
            
            template.merge(context, out);
            
            out.flush();
        }
        catch (Exception e)
        {
            throw new MojoExecutionException(
                    "Error merging velocity templates: " + e.getMessage(), e);
        }
        finally
        {
            IOUtil.close(out);
            out = null;
        }

        return pageName;
    }    

    static private final String _platformAgnosticPath(String path)
    {
        return path.replace('/', File.separatorChar);
    }

    protected MavenProject getProject()
    {
        return project;
    }

    protected String getOutputDirectory()
    {
        return outputDirectory.getAbsolutePath();
    }

    public String getName(Locale locale)
    {
        return "JSF Tag Documentation";
    }

    public String getDescription(Locale locale)
    {
        return "Documentation for JSF Tags";
    }

    public String getOutputName()
    {
        return "tagdoc";
    }

    protected Model getModel()
    {
        return _model;
    }

    protected List getMasterConfigs(MavenProject project)
            throws MavenReportException
    {
        String resourcePath = "META-INF/maven-faces-plugin/faces-config.xml";
        return getCompileDependencyResources(project, resourcePath);
    }

    protected List getCompileDependencyResources(MavenProject project,
            String resourcePath) throws MavenReportException
    {
        try
        {
            ClassLoader cl = createCompileClassLoader(project);
            Enumeration e = cl.getResources(resourcePath);
            List urls = new ArrayList();
            while (e.hasMoreElements())
            {
                URL url = (URL) e.nextElement();
                urls.add(url);
            }
            return Collections.unmodifiableList(urls);
        }
        catch (IOException e)
        {
            throw new MavenReportException("Unable to get resources for path "
                    + "\"" + resourcePath + "\"", e);
        }

    }

    private ClassLoader createCompileClassLoader(MavenProject project)
            throws MavenReportException
    {
        Thread current = Thread.currentThread();
        ClassLoader cl = current.getContextClassLoader();

        try
        {
            List classpathElements = project.getCompileClasspathElements();
            if (!classpathElements.isEmpty())
            {
                String[] entries = (String[]) classpathElements
                        .toArray(new String[0]);
                URL[] urls = new URL[entries.length];
                for (int i = 0; i < urls.length; i++)
                {
                    urls[i] = new File(entries[i]).toURL();
                }
                cl = new URLClassLoader(urls, cl);
            }
        }
        catch (DependencyResolutionRequiredException e)
        {
            throw new MavenReportException("Error calculating scope classpath",
                    e);
        }
        catch (MalformedURLException e)
        {
            throw new MavenReportException("Error calculating scope classpath",
                    e);
        }

        return cl;
    }

    static public class URLCreationFactory extends
            AbstractObjectCreationFactory
    {
        public Object createObject(Attributes attributes)
                throws MalformedURLException
        {
            String href = attributes.getValue("href");
            if (href == null)
            {
                throw new IllegalStateException("Missing href attribute");
            }

            URL master = (URL) digester.getRoot();
            return new URL(master, href);
        }
    }

    public String getTemplateComponent()
    {
        return templateComponent;
    }

    public String getTemplateConverter()
    {
        return templateConverter;
    }

    public String getTemplateBehavior()
    {
        return templateBehavior;
    }

    public String getTemplateValidator()
    {
        return templateValidator;
    }

    public String getTemplateTag()
    {
        return templateTag;
    }

    public String getTemplateFaceletTag()
    {
        return templateFaceletTag;
    }
    
    public String getTemplateFaceletFunctions()
    {
        return templateFaceletFunctions;
    }
    
    private boolean _is12()
    {
        return "1.2".equals(jsfVersion) || "12".equals(jsfVersion);
    }
    
    private boolean _is20()
    {
        return "2.0".equals(jsfVersion) || "20".equals(jsfVersion);
    }
}