package org.apache.axis.message.addressing.tools.wsdl;
   
   import java.io.File;
   import java.io.IOException;
   import java.io.PrintWriter;
   import java.util.HashMap;
   import java.util.HashSet;
   import java.util.Map;
   import java.util.Set;
  
  import javax.wsdl.Binding;
  import javax.wsdl.Port;
  
  import org.apache.axis.wsdl.symbolTable.BindingEntry;
  import org.apache.axis.wsdl.symbolTable.ServiceEntry;
  import org.apache.axis.wsdl.symbolTable.SymbolTable;
  import org.apache.axis.wsdl.toJava.Emitter;
  import org.apache.axis.wsdl.toJava.JavaBindingWriter;
  import org.apache.axis.wsdl.toJava.JavaClassWriter;
  
  /**
   * Class writer that manages an imports clause list, so generated code can
   * be simplified.
   *
   * @author Rodrigo Ruiz
   * @version $Revision: 14 $
   */
  public abstract class JavaClassWithImportsWriter extends JavaClassWriter {
  
    /**
     * Service.
     */
    protected final ServiceEntry sEntry;
  
    /**
     * Symbol table.
     */
    protected final SymbolTable symbolTable;
  
  
    /**
     * Map of imported classes.
     */
    private final Map<String, String> imports = new HashMap<String, String>();
  
    /**
     * List of packages that are implicitly imported.
     */
    private final Set<String> implicits = new HashSet<String>();
  
    /**
     * Creates an instance.
     *
     * @param emitter      Emitter
     * @param sEntry       Service
     * @param symbolTable  Symbol table
     * @param entryName    Name of the generated entry
     * @param type         Entry type
     */
    protected JavaClassWithImportsWriter(Emitter emitter, ServiceEntry sEntry,
      SymbolTable symbolTable, String entryName, String type) {
      super(emitter, entryName, "service");
      this.sEntry = sEntry;
      this.symbolTable = symbolTable;
    }
  
    /**
     * {@inheritDoc}
     */
    @Override
    public void generate() throws IOException {
      initImports();
      super.generate();
    }
  
    /**
     * Populates the imports map.
     */
    protected void initImports() {
      implicits.add(getPackage());
      implicits.add("java.lang");
  
      addImport("org.apache.axis.message.addressing.EndpointReferenceType");
      addImport("javax.xml.rpc.ServiceException");
  
      // Port types
      Map<?, ?> ports = sEntry.getService().getPorts();
      for (Object item : ports.values()) {
        Port p = (Port)item;
        String className = getBindingType(p);
        if (className != null) {
          addImport(className);
        }
      }
    }
  
    /**
     * Adds an import clause.
     *
    * @param className Class to be imported
    */
   protected final void addImport(String className) {
     int pos = className.lastIndexOf('.');
     String packageName = className.substring(0, pos);
     String simpleName = className.substring(pos + 1);
 
     if (!implicits.contains(packageName)) {
       imports.put(className, simpleName);
     }
   }
 
   /**
    * Resolves a class name, and returns its simple name if it is imported.
    *
    * @param className Fully qualified class name
    * @return Simplified class name
    */
   protected final String resolve(String className) {
     String pkg = this.getPackage();
 
     int pos = className.lastIndexOf('.');
     String packageName = className.substring(0, pos);
     String simpleName = className.substring(pos + 1);
 
     if ("java.lang".equals(packageName)) {
       return simpleName;
     } else if (packageName.equals(pkg)) {
       return simpleName;
     } else {
       String resolved = imports.get(className);
       return (resolved == null) ? className : resolved;
     }
   }
 
   /**
    * Gets the name of the binding type associated to the specified Port.
    *
    * @param port Port to process
    * @return Binding class name
    */
   protected final String getBindingType(Port port) {
     Binding binding = port.getBinding();
 
     if (binding == null) {
       return null;
     }
 
     BindingEntry bEntry = symbolTable.getBindingEntry(binding.getQName());
 
     // If this isn't an SOAP binding, skip it
     if (bEntry == null || bEntry.getBindingType() != BindingEntry.TYPE_SOAP) {
       return null;
     }
 
     return (String) bEntry.getDynamicVar(JavaBindingWriter.INTERFACE_NAME);
 
   }
 
   /**
    * Writes the imports clauses.
    *
    * @param pw To print to
    */
   protected final void writeImports(PrintWriter pw) {
     for (String className : imports.keySet()) {
       pw.print("import ");
       pw.print(className);
       pw.println(';');
     }
     pw.println();
   }
 
   /**
    * {@inheritDoc}
    */
   @Override
   protected final void writeHeaderComments(PrintWriter pw) throws IOException {
     int pos = this.getFileName().lastIndexOf(File.separatorChar);
 
     pw.println("/*");
     pw.println(" * " + this.getFileName().substring(pos + 1));
     pw.println(" *");
     pw.println(" * This file was auto-generated from WSDL");
     pw.println(" * by the Addressing WSDL2Java emitter");
     pw.println(" */");
   }
 
   /**
    * {@inheritDoc}
    */
   @Override
   protected final void writeFileHeader(PrintWriter pw) throws IOException {
     writeHeaderComments(pw);
     writePackage(pw);
     writeImports(pw);
 
     writeClassComment(pw);
 
     StringBuffer sb = new StringBuffer();
     sb.append(getClassModifiers());
     sb.append(getClassText());
     sb.append(getClassName());
 
     String extendsText = getExtendsText();
     if (extendsText != null) {
       pw.println(sb);
       sb.setLength(0);
       sb.append("  ");
       sb.append(getExtendsText());
     }
 
     String implementsText = getImplementsText();
     if (implementsText != null) {
       pw.println(sb);
       sb.setLength(0);
       sb.append("  ");
       sb.append(getImplementsText());
     }
     sb.append(" {");
     pw.println(sb);
   }
 
   /**
    * Generates the generated class javadoc comment.
    *
    * @param pw Writer to print to
    * @throws IOException If an error occurs
    */
   protected abstract void writeClassComment(PrintWriter pw) throws IOException;
 }