/*
 *  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.faces.generator.component;

import org.apache.maven.plugin.logging.Log;
import org.apache.myfaces.buildtools.maven2.plugin.faces.generator.GeneratorHelper;
import org.apache.myfaces.buildtools.maven2.plugin.faces.io.PrettyWriter;
import org.apache.myfaces.buildtools.maven2.plugin.faces.parse.*;
import org.apache.myfaces.buildtools.maven2.plugin.faces.util.FilteredIterator;
import org.apache.myfaces.buildtools.maven2.plugin.faces.util.PropertyFilter;
import org.apache.myfaces.buildtools.maven2.plugin.faces.util.SourceTemplate;
import org.apache.myfaces.buildtools.maven2.plugin.faces.util.Util;

import java.io.IOException;
import java.lang.reflect.Modifier;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public abstract class AbstractComponentGenerator implements ComponentGenerator
{

  private Log _log;
  boolean _is12;

  public AbstractComponentGenerator(Log log, boolean is12)
  {
    _log = log;
    _is12 = is12;
  }

  protected Log getLog()
  {
    return _log;
  }

  public void writeClassBegin(
      PrettyWriter out,
      String className,
      String superclassName,
      ComponentBean component,
      SourceTemplate template)
  {
    out.println("/**");

    // TODO: restore description (needs escaping?)
//    String description = component.getDescription();
//    if (description != null)
//    {
//      out.println(" *");
//      out.println(" * " + convertMultilineComment(description));
//    }

    String longDescription = component.getLongDescription();
    if (longDescription != null)
    {
      out.println(" *");
      out.println(" * " + convertMultilineComment(longDescription));
    }

    if (component.hasEvents(true))
    {
      // the events javadoc
      out.println(" *");
      out.println(" * <h4>Events:</h4>");
      out.println(" * <table border=\"1\" width=\"100%\" cellpadding=\"3\" summary=\"\">");
      out.println(" * <tr bgcolor=\"#CCCCFF\" class=\"TableHeadingColor\">");
      out.println(" * <th align=\"left\">Type</th>");
      out.println(" * <th align=\"left\">Phases</th>");
      out.println(" * <th align=\"left\">Description</th>");
      out.println(" * </tr>");
      Iterator events = component.events(true);
      while (events.hasNext())
      {
        EventRefBean eventRef = (EventRefBean) events.next();
        EventBean event = eventRef.resolveEventType();
        if (event != null)
        {
          String eventClass = event.getEventClass();
          String[] eventPhases = eventRef.getEventDeliveryPhases();
          String eventDescription = event.getDescription();
          out.println(" * <tr class=\"TableRowColor\">");
          out.println(" * <td valign=\"top\"><code>" + eventClass + "</code></td>");
          out.print(" * <td valign=\"top\" nowrap>");
          if (eventPhases != null)
          {
            for (int i = 0; i < eventPhases.length; i++)
            {
              if (i > 0)
                out.print("<br>");
              out.print(eventPhases[i]);
            }
          }
          out.println("</td>");
          out.println(" * <td valign=\"top\">" + eventDescription + "</td>");
          out.println(" * </tr>");
        }
      }
      out.println(" * </table>");
    }

    if (!component.hasChildren())
    {
      out.println(" * <p>");
      out.println(" * It does not support any children.");
    }

    out.println(" */");

    // TODO: eliminate <mfp:component-class-modifier> metadata
    int modifiers = component.getComponentClassModifiers();
    String classStart = Modifier.toString(modifiers);
    // TODO: use canonical ordering
    classStart = classStart.replaceAll("public abstract", "abstract public");
    out.println(classStart + " class " + className +
        " extends " + superclassName);

    Set interfaces = new HashSet();
    if (template != null)
      interfaces.addAll(template.getImplements());

    if (component.getComponentImplements() != null){
        StringTokenizer st = new StringTokenizer(component.getComponentImplements(),",",false);
        while (st.hasMoreTokens()){
            interfaces.add(st.nextToken());    
        }        
    }
    
    if (component.isNamingContainer())
      interfaces.add("javax.faces.component.NamingContainer");

    Iterator events = component.events();
    while (events.hasNext())
    {
      EventRefBean eventRef = (EventRefBean) events.next();
      EventBean event = eventRef.resolveEventType();
      if (event != null)
      {
        if (!eventRef.isIgnoreSourceInterface())
        {
          String source = event.getEventSourceInterface();
          if (source != null)
            interfaces.add(Util.getClassFromFullClass(source));
        }
      }
    }

    if (!interfaces.isEmpty())
    {
      Set implementsSet = new HashSet();
      for (Iterator iter = interfaces.iterator(); iter.hasNext();)
      {
        String fcqn = (String) iter.next();
        implementsSet.add(Util.getClassFromFullClass(fcqn));
      }

      // implements clause spans multiple lines
      char[] indent = new char[classStart.length() +
          " class ".length() +
          className.length() + 1];
      Arrays.fill(indent, ' ');
      out.print(indent);
      out.print("implements ");
      for (Iterator iter = implementsSet.iterator(); iter.hasNext();)
      {
        out.print((String) iter.next());
        if (iter.hasNext())
        {
          out.println(",");
          out.print(indent);
          out.print("           ");  // same length as "implements "
        }
      }
      out.println();
    }

    out.println("{");
    out.indent();
    
    //Write serialVersionUID
    if (component.getComponentSerialUID() != null &&
            !"".equals(component.getComponentSerialUID())){
        out.println();
        out.println("private static final long serialVersionUID = "+
                component.getComponentSerialUID()+";");
        out.println();
    }
  }

  public void writeClassEnd(
      PrettyWriter out)
  {
    out.unindent();
    out.println("}");
  }


  public void writeImports(PrettyWriter out, SourceTemplate template, String packageName, String fullSuperclassName,
                           String superclassName, Collection components)
  {
    throw new UnsupportedOperationException("not implemented");
  }

  public void writeImports(
      PrettyWriter out,
      SourceTemplate template,
      String packageName,
      String fullSuperclassName,
      String superclassName,
      ComponentBean component)
  {
    Set imports = new TreeSet();

    // Use the template imports
    if (template != null)
      imports.addAll(template.getImports());

    if (component.getComponentImplements() != null){
        StringTokenizer st = new StringTokenizer(component.getComponentImplements(),",",false);
        while (st.hasMoreTokens()){
            imports.add(st.nextToken());    
        }        
    }    
    
    // Detect NamingContainer
    if (component.isNamingContainer())
      imports.add("javax.faces.component.NamingContainer");

    Iterator properties = component.properties();
    properties = new FilteredIterator(properties, new NonVirtualFilter());
    // PropertyKey only needed if there are properties
    if (properties.hasNext())
    {
      while (properties.hasNext())
      {
        PropertyBean property = (PropertyBean) properties.next();
        String propertyClass = property.getPropertyClass();
        if (propertyClass != null)
        {
          imports.add(propertyClass);
          // Check for generics
          String[] types = property.getAttributeClassParameters();
          if (types != null)
          {
            for (int i = types.length - 1; i >= 0; i--)
            {
              addGenericImports(imports, types[i]);
            }
          }
        }
      }
    }

    Iterator facets = component.facets();
    // UIComponent needed if there are facets
    if (facets.hasNext())
      imports.add("javax.faces.component.UIComponent");

    Iterator events = component.events();
    while (events.hasNext())
    {
      EventRefBean eventRef = (EventRefBean) events.next();
      EventBean event = eventRef.resolveEventType();

      if (event == null)
      {
        getLog().warn("Unknown event type \"" + eventRef.getEventType() + "\"" +
            " in component:" + component.getComponentType());
      }
      else
      {
        String listenerClass = event.getEventListenerClass();
        if (listenerClass != null)
          imports.add(listenerClass);

        if (!eventRef.isIgnoreSourceInterface())
        {
          String sourceInterface = event.getEventSourceInterface();
          if (sourceInterface != null)
            imports.add(sourceInterface);
        }
      }
    }

    // Import causes a collision if className and superclassName are equal
    if (!superclassName.equals(fullSuperclassName))
    {
      String superPackageName = Util.getPackageFromFullClass(fullSuperclassName);
      // component superclass only needed if not in
      // same package as component class
      if (superPackageName != packageName)
        imports.add(fullSuperclassName);
    }

    // add other imports (generator specific)
    addSpecificImports(imports, component);

    // do not import implicit types!
    imports.removeAll(Util.PRIMITIVE_TYPES);

    GeneratorHelper.writeImports(out, packageName, imports);
  }

  protected void addSpecificImports(
      Set imports,
      ComponentBean component)
  {
    // nothing by default
  }

  public void addGenericImports(Set imports, String type)
  {
    Matcher matcher = _GENERIC_TYPE.matcher(type);
    if (matcher.matches())
    {
      // Generic type
      imports.add(matcher.group(1));
      String[] types = matcher.group(2).split(",");
      for (int i = types.length - 1; i >= 0; i--)
      {
        addGenericImports(imports, types[i]);
      }
    }
    else
    {
      // Non-generic type
      imports.add(type);
    }
  }

  public void writeGenericConstants(
      PrettyWriter out,
      String componentFamily,
      String componentType) throws IOException
  {
    out.println();
    out.println("static public final String COMPONENT_FAMILY =");
    out.println("  \"" + componentFamily + "\";");
    out.println("static public final String COMPONENT_TYPE =");
    out.println("  \"" + componentType + "\";");
  }

  public void writePropertyConstants(
      PrettyWriter out,
      String superclassName,
      ComponentBean component) throws IOException
  {
    // nothing
  }

  public void writePropertyValueConstants(
      PrettyWriter out,
      ComponentBean component) throws IOException
  {
    //  component property keys
    Iterator properties = component.properties();
    properties = new FilteredIterator(properties, new NonVirtualFilter());
    while (properties.hasNext())
    {
      PropertyBean property = (PropertyBean) properties.next();
      String[] propertyValues = property.getPropertyValues();

      if (propertyValues != null)
      {
        String propName = property.getPropertyName();

        for (int i = 0; i < propertyValues.length; i++)
        {
          String propValue = propertyValues[i];
          String propValueName = propName +
              Character.toUpperCase(propValue.charAt(0)) +
              propValue.substring(1);
          String propValueKey = Util.getConstantNameFromProperty(propValueName);

          out.println("static public final String " + propValueKey + " = \"" + propValue + "\";");
        }

      }
    }
  }

  public void writeFacetConstants(
      PrettyWriter out,
      ComponentBean component) throws IOException
  {
    Iterator facets = component.facets();
    while (facets.hasNext())
    {
      FacetBean facet = (FacetBean) facets.next();
      String facetName = facet.getFacetName();
      String facetKey = Util.getConstantNameFromProperty(facetName, "_FACET");
      out.println("static public final " +
          "String " + facetKey + " = \"" + facetName + "\";");
    }
  }

  protected String convertStringToBoxedLiteral(
      String className,
      String value)
  {
    if (value == null)
    {
      return null;
    }
    else if ("String".equals(className))
    {
      return "\"" + value.replaceAll("\'", "\\'") + "\"";
    }
    else if ("boolean".equals(className))
    {
      return ("true".equals(value)) ? "Boolean.TRUE" : "Boolean.FALSE";
    }
    else if ("char".equals(className))
    {
      return "Character.valueOf('" + value.replaceAll("\'", "\\'") + "')";
    }
    else if ("int".equals(className))
    {
      return "Integer.valueOf(" + value + ")";
    }
    else if ("double".equals(className))
    {
      return "Double.valueOf(" + value + ")";
    }
    else if ("float".equals(className))
    {
      return "Float.valueOf(" + value + ")";
    }
    else if ("Number".equals(className))
    {
      if(value.indexOf(".") == -1)
      {
        return "Integer.valueOf(" + value + ")";
      }
      else
      {
        return "Double.valueOf(" + value + ")";
      }
    }
    else
    {
      throw new IllegalStateException("property-class " + className + " not supported for auto-boxing");
    }
  }


  protected String convertVariableToBoxedForm(
    String  className,
    String  varName)
  {
    if ("boolean".equals(className))
    {
      return varName + " ? Boolean.TRUE : Boolean.FALSE";
    }
    else if ("char".equals(className))
    {
      return "Character.valueOf(" + varName + ")";
    }
    else if ("int".equals(className))
    {
      return "Integer.valueOf(" + varName + ")";
    }
    else if ("short".equals(className))
    {
      return "Short.valueOf(" + varName + ")";
    }
    else if ("long".equals(className))
    {
      return "Long.valueOf(" + varName + ")";
    }
    else if ("double".equals(className))
    {
      return "Double.valueOf(" + varName + ")";
    }
    else if ("float".equals(className))
    {
      return "Float.valueOf(" + varName + ")";
    }
    else
    {
      throw new IllegalStateException("property-class " + className + " not supported for auto-boxing");
    }
  }

  public void writeConstructor(
      PrettyWriter out,
      ComponentBean component,
      int modifiers) throws IOException
  {
    String fullClassName = component.getComponentClass();
    String className = Util.getClassFromFullClass(fullClassName);

    if (Modifier.isPublic(modifiers))
    {
      // TODO: eliminate this inconsistency
      if (!Modifier.isAbstract(component.getComponentClassModifiers()))
      {
        String rendererType = component.getRendererType();

        if (rendererType != null)
          rendererType = convertStringToBoxedLiteral("String", rendererType);

        out.println();
        out.println("/**");
        // TODO: restore this correctly phrased comment (tense vs. command)
        //out.println(" * Constructs an instance of " + className + ".");
        out.println(" * Construct an instance of the " + className + ".");
        out.println(" */");
        out.println("public " + className + "()");
        out.println("{");
        out.indent();

        writeConstructorContent(out, component, modifiers, rendererType);

        out.unindent();
        out.println("}");
      }
    }
    else if (Modifier.isProtected(modifiers))
    {
      out.println();
      out.println("/**");
      // TODO: restore this more descriptive comment with param docs
      //out.println(" * Construct an instance of the " + className);
      //out.println(" * with the specified renderer type.");
      //out.println(" * ");
      //out.println(" * @param rendererType  the renderer type");
      out.println(" * Construct an instance of the " + className + ".");
      out.println(" */");
      out.println("protected " + className + "(");
      out.indent();
      out.println("String rendererType");
      out.println(")");
      out.unindent();
      out.println("{");
      out.indent();

      writeConstructorContent(out, component, modifiers, "rendererType");

      out.unindent();
      out.println("}");

      // TODO: eliminate this inconsistency
      if (Modifier.isAbstract(component.getComponentClassModifiers()))
      {
        out.println();
        out.println("/**");
        // TODO: restore this correctly phrased comment (tense vs. command)
        //out.println(" * Constructs an instance of " + className + ".");
        out.println(" * Construct an instance of the " + className + ".");
        out.println(" */");
        out.println("protected " + className + "()");
        out.println("{");
        out.indent();
        out.println("this(null);");
        out.unindent();
        out.println("}");
      }
    }
  }

  protected abstract void writeConstructorContent(
      PrettyWriter out,
      ComponentBean component,
      int modifiers, String rendererType) throws IOException;

  public void writeGetFamily(
      PrettyWriter out) throws IOException
  {
    out.println();
    if (_is12){
        out.println("@Override");
    }
    out.println("public String getFamily()");
    out.println("{");
    out.indent();
    out.println("return COMPONENT_FAMILY;");
    out.unindent();
    out.println("}");
  }

  public void writePropertyMethods(
      PrettyWriter out,
      ComponentBean component) throws IOException
  {
    writePropertyMethods(out, component, null);
  }


  public void writePropertyMethods(PrettyWriter out, ComponentBean component, Collection ignoreList)
      throws IOException
  {
    Iterator properties = component.properties();
    properties = new FilteredIterator(properties, new NonVirtualFilter());
    while (properties.hasNext())
    {
      PropertyBean property = (PropertyBean) properties.next();
      if (property.isList())
        writePropertyListMethods(out, property, ignoreList);
      else
      {
        writePropertyDeclaration(out, property);
        writePropertyGet(out, property, ignoreList);
        writePropertySet(out, property, ignoreList);
        if (GeneratorHelper.isValidator(property, _is12))
        {
          writePropertyListMethods(out, property, ignoreList);
        }
      }
    }
  }

  abstract protected void writePropertyListMethods(
      PrettyWriter out,
      PropertyBean property,
      Collection inoreList) throws IOException;

  abstract protected void writePropertyListMethods(
      PrettyWriter out,
      PropertyBean property) throws IOException;

  static protected String getSingular(String plural)
  {
    if (plural.endsWith("s"))
      return plural.substring(0, plural.length() - 1);
    return plural;
  }

  protected abstract void writePropertyDeclaration(
      PrettyWriter out,
      PropertyBean property) throws IOException;

  protected void writePropertySet(
      PrettyWriter out,
      PropertyBean property,
      Collection ignoreList) throws IOException
  {
    String propertyClass = Util.getPropertyClass(property);
    writePropertySet(out, property, propertyClass, ignoreList);

    if (property.getAlternateClass() != null)
    {
      String alternateClass = Util.getAlternatePropertyClass(property);
      writePropertySet(out, property, alternateClass, ignoreList);
    }
  }

  protected void writePropertySet(
      PrettyWriter out,
      PropertyBean property,
      String propertyClass,
      Collection ignoreList) throws IOException
  {
    String propName = property.getPropertyName();
    String propVar = Util.getVariableFromName(propName);
    String description = property.getDescription();
    String setMethod = Util.getPrefixedPropertyName("set", propName);
    if (ignoreList != null && ignoreList.contains(setMethod))
    {
      return;
    }
    out.println();
    out.println("/**");
    if (description != null)
    {
      out.println(" * Sets " + convertMultilineComment(description));
    }

    if (property.isRequired())
    {
      out.println(" * <p>");
      out.println(" * This is a required property on the component.");
    }
    out.println(" * ");
    out.println(" * @param " + Util.getVariableFromName(propName) + "  the new " + propName + " value");
    if (property.isMethodBinding() && _is12)
    {
      out.println(" * @deprecated");
    }
    out.println(" */");

    if (isAccessorMethodFinal())
    {
      out.print("final ");
    }

    out.println("public void " + setMethod + "(" + propertyClass + " " + propVar + ")");
    out.println("{");
    out.indent();
    writePropertySetterMethodBody(out, property, propertyClass);
    out.unindent();
    out.println("}");
  }

  protected abstract void writePropertySetterMethodBody(
      PrettyWriter out,
      PropertyBean property,
      String propertyClass) throws IOException;

  protected void writePropertyGet(
      PrettyWriter out,
      PropertyBean property,
      Collection ignoreList) throws IOException
  {
    String propName = property.getPropertyName();
    String propertyFullClass = property.getPropertyClass();
    String propertyClass = Util.getClassFromFullClass(propertyFullClass);
    String description = property.getDescription();
    String getMethod = Util.getMethodReaderFromProperty(propName, propertyClass);
    if (ignoreList != null && ignoreList.contains(getMethod))
    {
      return;
    }
    boolean isUnchecked = false;
    String[] genericTypes = property.getPropertyClassParameters();
    if (genericTypes != null && genericTypes.length > 0)
    {
      isUnchecked = true;
      propertyClass = Util.getPropertyClass(property);
    }

    out.println();
    out.println("/**");
    if (description != null)
    {
      out.println(" * Gets " + convertMultilineComment(description));
    }
    if (property.isRequired())
    {
      out.println(" * <p>");
      out.println(" * This is a required property on the component.");
      out.println(" * </p>");
    }

    out.println(" *");
    out.println(" * @return  the new " + propName + " value");
    if (property.isMethodBinding() && _is12)
    {
      out.println(" * @deprecated");
    }
    out.println(" */");

    if (isUnchecked)
    {
      out.println("@SuppressWarnings(\"unchecked\")");
    }

    if (isAccessorMethodFinal())
    {
      out.print("final ");
    }

    out.println("public " + propertyClass + " " + getMethod + "()");
    out.println("{");
    out.indent();

    writePropertyGetterMethodBody(out, property);

    out.unindent();
    out.println("}");
  }

  /**
   * Whether the getters/setters have the final modifier
   *
   * @return true if the getters/setters are final
   */
  protected boolean isAccessorMethodFinal()
  {
    return false;
  }

  protected abstract void writePropertyGetterMethodBody(
      PrettyWriter out,
      PropertyBean property) throws IOException;

  public void writeFacetMethods(
      PrettyWriter out,
      ComponentBean component) throws IOException
  {
    Iterator facets = component.facets();
    while (facets.hasNext())
    {
      FacetBean facet = (FacetBean) facets.next();
      writeFacetGet(out, facet);
      writeFacetSet(out, facet);
    }
  }

  public void writeFacetSet(
      PrettyWriter out,
      FacetBean facet) throws IOException
  {
    String facetName = facet.getFacetName();
    // TODO: drop the unnecessary "Facet" suffix
    String facetVar = facetName + "Facet";
    String facetKey = Util.getConstantNameFromProperty(facetName, "_FACET");
    String setMethod = Util.getPrefixedPropertyName("set", facetName);
    String description = facet.getDescription();

    out.println();
    out.println("/**");
    if (description != null)
    {
      out.println(" * " + convertMultilineComment(description));
    }
    if (facet.isRequired())
    {
      out.println(" * <p>");
      out.println(" * This is a required facet on the component.");
    }
    // TODO: put this back in
    //out.println(" * ");
    //out.println(" * @param " + facetVar + "  the new " + facetName + " facet");
    out.println(" */");

    // Remove type safety warning since getFacets is not generics enabled
    // under JSF 1.1 spec
    // TODO: Remove this line when Trinidad switch to JSF 1.2
    out.println("@SuppressWarnings(\"unchecked\")");

    out.println("final public void " + setMethod + "(UIComponent " + facetVar + ")");
    out.println("{");
    out.indent();
    out.println("getFacets().put(" + facetKey + ", " + facetVar + ");");
    out.unindent();
    out.println("}");
  }

  public void writeFacetGet(
      PrettyWriter out,
      FacetBean facet) throws IOException
  {
    String facetName = facet.getFacetName();
    String facetKey = Util.getConstantNameFromProperty(facetName, "_FACET");
    String getMethod = Util.getPrefixedPropertyName("get", facetName);
    String description = facet.getDescription();

    out.println();
    out.println("/**");
    if (description != null)
    {
      out.println(" * " + convertMultilineComment(description));
    }
    if (facet.isRequired())
    {
      out.println(" * <p>");
      out.println(" * This is a required facet on the component.");
    }
    // TODO: put this back in
    //out.println(" * ");
    //out.println(" * @return  the " + facetName + " facet");
    out.println(" */");

    out.println("final public UIComponent " + getMethod + "()");
    out.println("{");
    out.indent();
    out.println("return getFacet(" + facetKey + ");");
    out.unindent();
    out.println("}");
  }

  public void writeListenerMethods(
      PrettyWriter out,
      ComponentBean component) throws IOException
  {
    Iterator events = component.events();
    while (events.hasNext())
    {
      EventRefBean eventRef = (EventRefBean) events.next();
      EventBean event = eventRef.resolveEventType();
      if (event != null)
      {
        writeListenerAdd(out, event);
        writeListenerRemove(out, event);
        writeListenersGet(out, event);
      }
    }
  }

  public void writeListenerAdd(
      PrettyWriter out,
      EventBean event) throws IOException
  {
    String listenerFullClass = event.getEventListenerClass();
    String listenerClass = Util.getClassFromFullClass(listenerFullClass);

    String eventName = event.getEventName();
    String addMethod = Util.getMethodNameFromEvent("add", eventName, "Listener");

    out.println();
    out.println("/**");
    out.println(" * Adds a " + eventName + " listener.");
    out.println(" *");
    out.println(" * @param listener  the " + eventName + " listener to add");
    out.println(" */");

    if (isAccessorMethodFinal())
    {
      out.print("final ");
    }
    out.println("public void " + addMethod + "(");
    out.indent();
    out.println(listenerClass + " listener)");
    out.unindent();
    out.println("{");
    out.indent();
    out.println("addFacesListener(listener);");
    out.unindent();
    out.println("}");
  }

  public void writeListenerRemove(
      PrettyWriter out,
      EventBean event) throws IOException
  {
    String listenerFullClass = event.getEventListenerClass();
    String listenerClass = Util.getClassFromFullClass(listenerFullClass);

    String eventName = event.getEventName();
    String removeMethod = Util.getMethodNameFromEvent("remove", eventName, "Listener");

    out.println();
    out.println("/**");
    out.println(" * Removes a " + eventName + " listener.");
    out.println(" *");
    out.println(" * @param listener  the " + eventName + " listener to remove");
    out.println(" */");

    if (isAccessorMethodFinal())
    {
      out.print("final ");
    }
    out.println("public void " + removeMethod + "(");
    out.indent();
    out.println(listenerClass + " listener)");
    out.unindent();
    out.println("{");
    out.indent();
    out.println("removeFacesListener(listener);");
    out.unindent();
    out.println("}");
  }

  public void writeListenersGet(
      PrettyWriter out,
      EventBean event) throws IOException
  {
    String listenerFullClass = event.getEventListenerClass();
    String listenerClass = Util.getClassFromFullClass(listenerFullClass);

    String eventName = event.getEventName();
    String getMethod = Util.getMethodNameFromEvent("get", eventName, "Listeners");

    out.println();
    out.println("/**");
    out.println(" * Returns an array of attached " + eventName + " listeners.");
    out.println(" *");
    out.println(" * @return  an array of attached " + eventName + " listeners.");
    out.println(" */");

    if (isAccessorMethodFinal())
    {
      out.print("final ");
    }
    out.println("public " + listenerClass + "[] " + getMethod + "()");
    out.println("{");
    out.indent();
    out.println("return (" + listenerClass + "[])" +
        "getFacesListeners(" + listenerClass + ".class);");
    out.unindent();
    out.println("}");
  }


  public abstract void writeStateManagementMethods(PrettyWriter out,
                                                   ComponentBean component) throws IOException;

  public void writeOther(
      PrettyWriter out, ComponentBean component) throws IOException
  {
    // nothing
  }

  protected String convertMultilineComment(
      String commentBody)
  {
    return commentBody.replaceAll("\n", "\n * ");
  }

  protected class ResolvableTypeFilter extends PropertyFilter
  {
    protected boolean accept(
        PropertyBean property)
    {
      String propertyClass = property.getPropertyClass();
      String resolvableType = resolveType(propertyClass);
      return (resolvableType != null);
    }
  }

  protected class NonVirtualFilter extends PropertyFilter
  {
    protected boolean accept(
        PropertyBean property)
    {
      return (!property.isVirtual());
    }
  }

  static protected String resolveType(
      String className)
  {
    return (String) _RESOLVABLE_TYPES.get(className);
  }


  static private Map _createResolvableTypes()
  {
    Map resolvableTypes = new HashMap();

    resolvableTypes.put("boolean", "Boolean");
    resolvableTypes.put("char", "Character");
    // TODO: put this back in
    //resolvableTypes.put("java.util.Date", "Date");
    resolvableTypes.put("int", "Integer");
    resolvableTypes.put("float", "Float");
    resolvableTypes.put("double", "Double");
    resolvableTypes.put("java.util.Locale", "Locale");
    resolvableTypes.put("long", "Long");
    resolvableTypes.put("java.lang.String", "String");
    resolvableTypes.put("java.lang.Number", "Number");
    // TODO: put this back in
    //resolvableTypes.put("java.lang.String[]", "StringArray");
    resolvableTypes.put("java.util.TimeZone", "TimeZone");

    return Collections.unmodifiableMap(resolvableTypes);
  }

  static private final Pattern _GENERIC_TYPE = Pattern.compile("([^<]+)<(.+)>");
  static final private Map _RESOLVABLE_TYPES = _createResolvableTypes();
}