/*******************************************************************************
 * Copyright (c) 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jst.ws.internal.consumption.ui.wizard;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.StringTokenizer;
import java.util.Vector;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jst.j2ee.internal.project.IEJBNatureConstants;
import org.eclipse.jst.ws.internal.common.ResourceUtils;
import org.eclipse.jst.ws.internal.consumption.fragments.ServicePreAssemblyFragment;
import org.eclipse.jst.ws.internal.consumption.fragments.ServicePreDeployFragment;
import org.eclipse.jst.ws.internal.consumption.fragments.ServicePreDevelopFragment;
import org.eclipse.jst.ws.internal.consumption.fragments.ServicePreInstallFragment;
import org.eclipse.jst.ws.internal.data.LabelsAndIds;
import org.eclipse.wst.command.internal.env.core.fragment.CommandFragmentFactoryFactory;
import org.eclipse.wst.command.internal.env.core.registry.CommandRegistry;
import org.eclipse.wst.command.internal.env.eclipse.EclipseLog;
import org.eclipse.wst.command.internal.env.ui.widgets.CanFinishRegistry;
import org.eclipse.wst.command.internal.env.ui.widgets.CommandWidgetBinding;
import org.eclipse.wst.command.internal.env.ui.widgets.CommandWidgetBindingList;
import org.eclipse.wst.command.internal.env.ui.widgets.WidgetRegistry;
import org.eclipse.wst.command.internal.provisional.env.core.common.Log;
import org.eclipse.wst.command.internal.provisional.env.core.data.DataMappingRegistry;
import org.eclipse.wst.command.internal.provisional.env.core.selection.SelectionList;
import org.eclipse.wst.command.internal.provisional.env.core.selection.SelectionListChoices;
import org.eclipse.wst.server.core.IServerType;
import org.eclipse.wst.server.core.ServerCore;

public class WebServiceServerRuntimeTypeRegistry implements CommandRegistry
{

  private static WebServiceServerRuntimeTypeRegistry instance_;

  private IConfigurationElement[] indexedConfigElems_;

  private HashMap webServiceServers;
  private HashMap webServiceRuntimes;
  private HashMap webServiceTypes;
  private HashMap webServiceServerRuntimeTypes;
 
  private Hashtable runtimesByType_;
  private Hashtable runtimeLabelById_;
  private Hashtable runtimeIdByLabel_;
  private Hashtable serversByType_;
  private Hashtable serverLabelByFactoryId_;
  private Hashtable serverFactoryIdByLabel_;

  private Hashtable configElemsById_;
  
  private DataMappingRegistry dataMappingRegistry_;
  private WidgetRegistry      widgetRegistry_;
  private CanFinishRegistry   canFinishRegistry_;
  private HashMap             factoryCache_;
  
  private SelectionListChoices serverToRuntimeToJ2EE_;
  private Log					log_;
  
  public WebServiceServerRuntimeTypeRegistry() {
    log_ = new EclipseLog();
  }
  //
  // Loads WebServiceServerRuntimeType objects into this registry.
  // This is done by querying the plugin registry for all extensions
  // hanging on the WebServiceServerRuntimeType extension point. Extensions
  // must implement the org.eclipse.jst.ws.ui.wizard.WebServiceServerRuntimeType
  // interface.
  //
  private void loadTypes ()
  {
    IExtensionRegistry reg = Platform.getExtensionRegistry();
    IConfigurationElement[] config = reg.getConfigurationElementsFor(
                                     "org.eclipse.jst.ws.consumption.ui",
                                     "webServiceServerRuntimeType");

    for(int idx=0; idx<config.length; idx++) 
    {
      IConfigurationElement elem = config[idx];
      try 
      {
        if (elem.getName().equals("webServiceServer"))
        { 
          WebServiceServer wss = new WebServiceServer(elem);
          webServiceServers.put(elem.getAttribute("id"), wss);
          String serverLabel = wss.getLabel();
          if (serverLabel != null && serverLabel.length()>0)
          {
            if (!serverLabelByFactoryId_.containsKey(wss.getFactoryId()));
              serverLabelByFactoryId_.put(wss.getFactoryId(), serverLabel);
            if (!serverFactoryIdByLabel_.containsKey(serverLabel));
              serverFactoryIdByLabel_.put(serverLabel, wss.getFactoryId());
          }
          
        }
        else if (elem.getName().equals("webServiceRuntime"))
        {
          WebServiceRuntime rt = new WebServiceRuntime(elem);
          webServiceRuntimes.put(elem.getAttribute("id"), rt);
          if(!runtimeLabelById_.containsKey(rt.getId()))
          	runtimeLabelById_.put(rt.getId(), rt.getLabel());
          if(!runtimeIdByLabel_.containsKey(rt.getLabel()))
          	runtimeIdByLabel_.put(rt.getLabel(), rt.getId());
          
        }
        else if (elem.getName().equals("webServiceType"))
        {
          WebServiceTypeImpl wst = new WebServiceTypeImpl(elem);
          webServiceTypes.put(elem.getAttribute("id"), wst);
        }
        else if (elem.getName().equals("webServiceServerRuntimeType"))
        {
          configElemsById_.put(elem.getAttribute("id"), elem);

          String typeId = elem.getAttribute("type");
          String serverId = elem.getAttribute("server");
          String runtimeId = elem.getAttribute("runtime");
          WebServiceServerRuntimeType_ wssrt = new WebServiceServerRuntimeType_(serverId, runtimeId, typeId, elem);
          webServiceServerRuntimeTypes.put(elem.getAttribute("id"), wssrt);

          setRuntimesByType(typeId,runtimeId);
          setServersByType(typeId, serverId);
        
        }

      } 
      catch (Exception e)
      {
        log_.log(Log.ERROR, 5058, this, "loadTypes", e);
      }
      
    }
  }


  /**
  * Sets the Web service runtimes and type from each extension 
  * in a Hashtable.  The type is the key, and value is a Vector containing 
  * each runtime supported in that Web service type.
  * @param runtime name
  * @param type name
  */
  private void setRuntimesByType(String typeId, String runtime)
  {
    if(runtimesByType_.get(typeId)!=null)
    {
      Vector v = (Vector)runtimesByType_.get(typeId);
      if (!v.contains(runtime.trim())) {
        v.add(runtime.trim());
      }
    }
    else
    {
      Vector vect = new Vector();
      vect.add(runtime.trim());
      runtimesByType_.put(typeId,vect);
    }
  }

  public WebServiceRuntime getRuntimeById( String id )
  {
    return (WebServiceRuntime)webServiceRuntimes.get( id ); 
  }
  
  /**
  * Gets the Web sevice runtimes vector given a type
  * @param Web service type
  * @return array of runtime labels
  */
  public String[] getRuntimesByType(String webServiceType) 
  {
    String[] runtimes;
    if (runtimesByType_.containsKey(webServiceType))
    {
      Vector vect =(Vector)runtimesByType_.get(webServiceType);
      runtimes = new String[vect.size()];
      for (int i=0; i<vect.size(); i++)
      {
        String runtimeId = (String)vect.elementAt(i);
        WebServiceRuntime wsr = (WebServiceRuntime)webServiceRuntimes.get(runtimeId);
        if (wsr!=null) {
          runtimes[i] = (String)wsr.getId();
        }
      }
      return runtimes;

    }
    else
    {
      log_.log(Log.ERROR, 5059, this, "getRuntimesByType", "runtimes not found for Web service type "+webServiceType);
      return null;
    }

  }
  
  public boolean isRuntimeSupportedForType(String webServiceTypeId, String runtimeId)
  {
  	String[] runtimes = getRuntimesByType(webServiceTypeId);
	for(int i=0;i<runtimes.length;i++)
	{
  		if (runtimes[i].equals(runtimeId))
  		  return true;
	}
  	return false;
  }

  public boolean doesRuntimeSupportJ2EELevel(String j2eeVersionId, String runtimeId)
  {
    IWebServiceRuntime wsr = (IWebServiceRuntime)webServiceRuntimes.get(runtimeId);
    String[] j2eeVersions = wsr.getJ2EEVersions();
    if (j2eeVersions==null || j2eeVersions.length==0) 
      return true;
    
    for(int i=0; i<j2eeVersions.length; i++)
    {
      if (j2eeVersions[i].equals(j2eeVersionId))
      {
      	return true;
      }
    }
    return false;
  }
  
  public boolean doesRuntimeSupportServerTarget(String serverTargetId, String runtimeId)
  {
    Iterator it = webServiceServerRuntimeTypes.values().iterator();
    while (it.hasNext()) 
    {
      WebServiceServerRuntimeType_ wssrt = (WebServiceServerRuntimeType_)it.next();
      if (wssrt!=null) {
        if (wssrt.runtimeId_.equals(runtimeId))
        {
          IWebServiceServer wsserver = getWebServiceServerById(wssrt.serverId_);
          String thisFactoryId = wsserver.getFactoryId();
          IServerType serverType = ServerCore.findServerType(thisFactoryId);
          if (serverType == null)
            continue;
          
          String thisServerTargetId = serverType.getRuntimeType().getId(); 
          if (thisServerTargetId.equals(serverTargetId))
            return true;
        }
      }
    } 
    return false;  
  }
  
  /**
  * Gets the server factoryIDs of all web service server runtime type
  * with an runtime ID equals to the input
  * @param runtime ID
  * @return array of factory IDs
  */
  public String[] getServerFactoryIDByRuntimeID(String runtimeID) {
    Vector v = new Vector();
    Iterator it = webServiceServerRuntimeTypes.values().iterator();
    while (it.hasNext()) {
      WebServiceServerRuntimeType_ wssrt = (WebServiceServerRuntimeType_)it.next();
      if (wssrt!=null) {
        if (wssrt.runtimeId_.equals(runtimeID))
          v.add(getWebServiceServerById(wssrt.serverId_).getFactoryId());

      }
    }
    String[] serverFactoryIDs = new String[v.size()];
    for (int i = 0; i < v.size(); i++) {
      serverFactoryIDs[i] = (String)v.get(i);
    }
    return serverFactoryIDs;
  }

  /**
  * Gets the runtime IDs of all web service server runtime type
  * with an server factory ID equals to the input
  * @param server factory ID
  * @return array of runtime IDs
  */
  public String[] getRuntimeIDsByServerFactoryID(String serverFactoryID) {
    Vector v = new Vector();
    Iterator it = webServiceServerRuntimeTypes.values().iterator();
    while (it.hasNext()) {
      WebServiceServerRuntimeType_ wssrt = (WebServiceServerRuntimeType_)it.next();
      if (wssrt!=null) {
      	IWebServiceServer wss = getWebServiceServerById(wssrt.serverId_);
      	String wssfId = wss.getFactoryId();
      	if (wssfId.equals(serverFactoryID))
      	{
      		if (!v.contains(wssrt.runtimeId_))
      		{
      			v.add(wssrt.runtimeId_);	
      		}      		
      	}
        /*if (getWebServiceServerById(wssrt.serverId_).getFactoryId().equals(serverFactoryID))
          v.add(getWebServiceRuntimeById(wssrt.runtimeId_).getId());*/
      }
    }
    String[] runtimeIDs = new String[v.size()];
    for (int i = 0; i < v.size(); i++) {
      runtimeIDs[i] = (String)v.get(i);
    }
    return runtimeIDs;
  }
  
  /**
  * Sets the Web service servers and type from each extension 
  * in a Hashtable.  The type is the key, and value is a Vector containing 
  * each runtime supported in that Web service type.
  * @param server name
  * @param type name
  */
  private void setServersByType(String typeId, String server)
  {
    if(serversByType_.get(typeId)!=null)
    {
      Vector v = (Vector)serversByType_.get(typeId);
      if (!v.contains(server.trim())) 
      {
        v.add(server.trim());      
      }
    }
    else
    {
      Vector vect = new Vector();
      vect.add(server.trim());
      serversByType_.put(typeId, vect);
    }

  }

  /**
  * Gets the Web service servers vector given a type
  * @param Web service type
  * @return array of server factory Ids
  */
  public String[] getServerFactoryIdsByType(String webServiceType) 
  {
    String[] servers; 
    if (serversByType_.containsKey(webServiceType))
    {
      Vector vect = (Vector)serversByType_.get(webServiceType);
      servers = new String[vect.size()];
      for (int i=0; i<vect.size(); i++)
      {
        String serverId = (String)vect.elementAt(i);
        WebServiceServer wss = (WebServiceServer)webServiceServers.get(serverId);
        if (wss!=null) {
          servers[i] = (String)wss.getFactoryId(); //Note: returning server factory Ids
        }
      }
      return servers;
    }
    else
    {     
      log_.log(Log.ERROR, 5060, this, "getServerByType", "Web service server not found for Web service type "+webServiceType);
      return null;
    }

  }

  public IWebServiceRuntime getWebServiceRuntimeByLabel(String runtimeLabel)
  {
    Iterator iter = webServiceRuntimes.values().iterator();
    while (iter.hasNext())
    {
      WebServiceRuntime wsr = (WebServiceRuntime)iter.next();
      if (wsr!=null) {
        if (runtimeLabel.equals(wsr.getLabel()))
          return wsr;
      }
    }
    return null;      
  }
  
  public IWebServiceRuntime getWebServiceRuntimeById(String runtimeId)
  {
    return (IWebServiceRuntime)webServiceRuntimes.get(runtimeId); 
  }

  public IWebServiceServer getWebServiceServerByFactoryId(String serverFactoryId)
  {
    if (serverFactoryId==null)
      return null;

    Iterator iter = webServiceServers.values().iterator();
    while (iter.hasNext())
    {
      WebServiceServer wss = (WebServiceServer)iter.next();
      if (wss!=null && wss.getFactoryId()!=null) {
        if (serverFactoryId.equals(wss.getFactoryId())) {
          return wss;
        }
      }
    }
    return null;    
    
  }

  public IWebServiceServer getWebServiceServerByLabel(String serverLabel)
  {
    if (serverLabel==null) 
      return null;
    
    Iterator iter = webServiceServers.values().iterator();
    while (iter.hasNext())
    {
      WebServiceServer wss = (WebServiceServer)iter.next();
      if (wss!=null) {
        if (serverLabel.equals(wss.getLabel()))
          return wss;
      }
    }
    return null;    
    
  }
  
  public IWebServiceServer getWebServiceServerById(String serverId)
  {
    return (IWebServiceServer)webServiceServers.get(serverId);
  }

  public IWebServiceType getWebServiceTypeByLabel(String typeLabel)
  {
    Iterator iter = webServiceTypes.values().iterator();
    while (iter.hasNext())
    {
      WebServiceTypeImpl wst = (WebServiceTypeImpl)iter.next();
      if (wst!=null) {
        if (typeLabel.equals(wst.getLabel()))
          return wst;
      }
    }
    return null;
  }

  public IWebServiceType getWebServiceTypeById(String typeId)
  {
    if (webServiceTypes.get(typeId)!= null)
      return (WebServiceTypeImpl)webServiceTypes.get(typeId);
    return null;
  }

  /**
   * Returns true if an EJB project is needed to host a Web service
   * of the type identified by typeId. If multiple natureIds are specified in the 
   * "includeNatures" attribute, only the first one is checked. If no natureIds are specified, 
   * false is returned.
   * 
   * @deprecated  
   * 	Should be refactored in future 
   */
  public boolean requiresEJBProject(String typeId)
  {
    IWebServiceType wst = WebServiceServerRuntimeTypeRegistry.getInstance().getWebServiceTypeById(typeId);
    if (wst != null)
    {
      IConfigurationElement elem = wst.getConfigurationElement();
      String includedNatures = elem.getAttribute("includeNatures");
      if (includedNatures==null || includedNatures.length()==0)
      {
        return false;
      }
      else
      {
        StringTokenizer st = new StringTokenizer(includedNatures);
        if(st.hasMoreTokens())
        {
          String firstIncludedNature = st.nextToken();
          if (firstIncludedNature.equals(IEJBNatureConstants.NATURE_ID))
            return true;
        }
      }
    }
    return false;
  }
  
  /**
   * Returns a list of valid projects for the Web service type with an id of typeId.
   * In the case where the Web service type extension does not specify which project
   * natures are included, a array of all Web and EJB projects in the workspace will
   * be returned.
   * @param typeId
   * @return IProject[] an array of valid projects
   */
  public IProject[] getProjectsByWebServiceType(String typeId)
  {
    IProject[] projects = ResourcesPlugin.getWorkspace().getRoot().getProjects();
    ArrayList validProjects = new ArrayList();
//    IWebServiceType wst = WebServiceServerRuntimeTypeRegistry.getInstance().getWebServiceTypeById(typeId);
//    if (wst != null)
//    {

		//TODO: This section needs to be refactored to filter ArtifactEdits
		// and uphold project topology described in the extension
		
//      IConfigurationElement elem = wst.getConfigurationElement();
//      String includedNatures = elem.getAttribute("includeNatures");
//      String excludedNatures = elem.getAttribute("excludeNatures");
//      if (includedNatures!=null && includedNatures.length()>0)
//      {
//        for (int i = 0; i < projects.length; i++)
//        {
//          if (include(projects[i], includedNatures) && exclude(projects[i], excludedNatures))
//            validProjects.add(projects[i]);
//        }
//        return (IProject[])validProjects.toArray(new IProject[0]);
//      }
//    }
    
    //If wst was null or the extension didn't specify which project natures are
    // to be included, revert to the old behaviour
    for (int j = 0; j < projects.length; j++)
    {
      if (ResourceUtils.isWebProject(projects[j]) || ResourceUtils.isEJBProject(projects[j]))
        validProjects.add(projects[j]);
    }    
    return (IProject[])validProjects.toArray(new IProject[0]);
  }
  
  private boolean include(IProject project, String include)
  {
    StringTokenizer st = new StringTokenizer(include);
    while(st.hasMoreTokens())
    {
      try
      {
        if (project.hasNature(st.nextToken()))
          return true;
      }
      catch (CoreException ce)
      {
      }
    }
    return false;
  }

  private boolean exclude(IProject project, String exclude)
  {
    StringTokenizer st = new StringTokenizer(exclude);
    while(st.hasMoreTokens())
    {
      try
      {
        if (project.hasNature(st.nextToken()))
          return false;
      }
      catch (CoreException ce)
      {
      }
    }
    return true;
  }
  
  //
  // Loads WebServiceServerRuntimeType objects into this registry.
  // See method getInstance().
  //
  private void load ()
  {
    runtimesByType_ = new Hashtable();
    serversByType_ = new Hashtable();
    configElemsById_ = new Hashtable();
    runtimeIdByLabel_ = new Hashtable();
    runtimeLabelById_ = new Hashtable();
    serverFactoryIdByLabel_ = new Hashtable();
    serverLabelByFactoryId_ = new Hashtable();

    webServiceServers = new HashMap();
    webServiceRuntimes = new HashMap();
    webServiceTypes = new HashMap();
    
    webServiceServerRuntimeTypes = new HashMap();
    
    loadTypes();
  }

  /**
  * Returns a singleton instance of this class.
  * @return A singleton WebServiceServerRuntimeTypeRegistry object.
  */
  public static WebServiceServerRuntimeTypeRegistry getInstance ()
  {
    if (instance_ == null)
    {
      instance_ = new WebServiceServerRuntimeTypeRegistry();
      instance_.load();
    }
    return instance_;
  }

  /**
  * Returns the Web Service type names of all registered <code>WebServiceServerRuntimeType</code>
  * objects.
  * @return The Web Service type names of all registered <code>WebServiceServerRuntimeType</code>
  * objects.
  */
  public String[] getWebServiceTypeNames()
  {
    
    String[] types = new String[webServiceTypes.size()];

    int i=0;
    Iterator iter = webServiceTypes.values().iterator();
    while (iter.hasNext())
    {
      WebServiceTypeImpl wst = (WebServiceTypeImpl)iter.next();
      if (wst!=null) {
        types[i] = wst.getLabel();
        i++;
      }
    }
    return types;
  }
  
  public LabelsAndIds getServiceTypeLabels()
  {
    LabelsAndIds labelIds = new LabelsAndIds();
    Iterator     iterator = webServiceTypes.values().iterator();
    int          size     = webServiceTypes.size();
    String[]     labels   = new String[size];
    String[]     ids      = new String[size];
    int          index    = 0;
    
    labelIds.setLabels_( labels );
    labelIds.setIds_( ids );
    
    while( iterator.hasNext() ) 
    {
      WebServiceTypeImpl type = (WebServiceTypeImpl)iterator.next();
      
      ids[index]    = type.getId();
      labels[index] = type.getLabel();
      index++;
    }    
    
    return labelIds;
  }
  
  /**
  * Returns the IConfigurationElement given the server, runtime, and type attributes
  * The benefit of getting the IConfigurationElement is that the corresponding class
  * file and plugin are not loaded immediately.
  * @param server label
  * @param runtime label
  * @param type label
  * @return IConfiguration element
  */
  public IConfigurationElement getConfigurationElementFor(String serverId, String runtimeId, String typeId)
  {
    if (serverId==null || runtimeId==null || typeId==null)
        return null;
    Iterator iter = webServiceServerRuntimeTypes.values().iterator();
    while (iter.hasNext())
    {
      WebServiceServerRuntimeType_ wssrt = (WebServiceServerRuntimeType_)iter.next();
      if (wssrt!=null ) {
        if (wssrt.getConfigurationElementFor(serverId, runtimeId, typeId)!=null)
          return wssrt.getConfigurationElementFor(serverId, runtimeId,typeId);
      }
    }
    return null;    
  }
  
  public IConfigurationElement getConfigElementFor(String factoryId, String runtimeId, String typeId)
  {
    Iterator iter = webServiceServerRuntimeTypes.values().iterator();
    while (iter.hasNext())
    {
      WebServiceServerRuntimeType_ wssrt = (WebServiceServerRuntimeType_)iter.next();
        if (wssrt.hasConfigElementFor(factoryId, runtimeId, typeId)) {
          return wssrt.element_;
      }
    }
    return null;    
  }

  public boolean requiresWebModuleFor(String server, String runtime, String type)
  {
    IConfigurationElement elem = getConfigurationElementFor(server, runtime, type);
    if (elem==null)
    {
      return false;  // report error here instead
    }
    return Boolean.valueOf(elem.getAttribute("requireWebModule")).booleanValue();
  }

  public boolean requiresEJBModuleFor(String server, String runtime, String type)
  {
    IConfigurationElement elem = getConfigurationElementFor(server, runtime, type);    
    if (elem==null)
    {
      return false;
    }
    return Boolean.valueOf(elem.getAttribute("requireEJBModule")).booleanValue();
  }

  /**
  * Returns the id of the <code>WebServiceServerRuntimeType</code> corresponding to the Server,
  * Runtime, and Web Service Type.
  */
  public boolean webServiceServerRuntimeTypeExists(String serverID, String runtimeID, String typeID) 
  {
    return (getConfigurationElementFor(serverID, runtimeID, typeID) != null);
  }

  /**
  * Returns the id of the <code>WebServiceServerRuntimeType</code> corresponding to the Server,
  * Runtime, and Web Service Type.
  */
  public String getWebServiceServerRuntimeTypeName(String server, String runtime, String type) 
  {
    IConfigurationElement elem = (IConfigurationElement)getConfigurationElementFor(server, runtime, type);
    return (elem==null ? null : elem.getAttribute("id"));
  }

  /**
  * Returns the <code>WebServiceServerRuntimeType</code> corresponding to the Server, 
  * Runtime, and Web Service type. This will return the <code>WebServiceServerRuntimeType</code>
  * object and set the properties found in the manifest file. i.e. isWebModuleRequired, isEJBModuleRequired
  * @param server label
  * @param runtime label
  * @param Web service type
  * @return WebServiceServerRuntimeType object
  */
  public WebServiceServerRuntimeType getWebServiceServerRuntimeType(String server, String runtime, String type)
  {

    WebServiceServerRuntimeType wssrt = null;
    String serverId = getWebServiceServerByFactoryId(server).getId();
    IConfigurationElement elem = getConfigurationElementFor(server, runtime, type);
   
    if( elem == null )
    {
      // We couldn't find the server and runtime specified so we will
      // find the default server and runtime.
      
      server  = getDefaultServerValueFor(type);
      runtime = getDefaultRuntimeValueFor(type);

      elem = getConfigurationElementFor(server, runtime, type);
      
    }
   
    return wssrt;

  }


  /**
  * Returns the <code>WebServiceServerRuntimeType</code> given the type name.
  * @param type name
  * @retrun WebServiceServerRuntimeType object
  */
  public WebServiceServerRuntimeType getWebServiceServerRuntimeTypeById(String id)
  {
    WebServiceServerRuntimeType wssrt = null;
    if (configElemsById_.containsKey(id))
    {
      try {
        IConfigurationElement elem = (IConfigurationElement)configElemsById_.get(id);
        Object webServiceType = elem.createExecutableExtension("class");
        if (webServiceType instanceof WebServiceServerRuntimeType) 
        {
          wssrt = (WebServiceServerRuntimeType)webServiceType;
          wssrt.setServerLabel(elem.getAttribute("server"));
          wssrt.setRuntimeLabel(elem.getAttribute("runtime"));
          wssrt.setWebModuleRequired( Boolean.valueOf(elem.getAttribute("requireWebModule")).booleanValue() );
          wssrt.setEJBModuleRequired( Boolean.valueOf(elem.getAttribute("requireEJBModule")).booleanValue() );
        }
        else
        {
          String implementedInterface = "org.eclipse.jst.ws.ui.wizard.WebServiceServerRuntimeType ";
          String errMsg = "Extensions of the WebServiceServerRuntimeTypes extension point must implement the ";
          errMsg = errMsg + implementedInterface + "interface.";
          log_.log(Log.ERROR, 5061, this, "getWebServiceServerRuntimeTypeById", errMsg);
        }
      }
      catch (CoreException ce)
      {
        log_.log(Log.ERROR, 5062, this, "getWebServiceServerRuntimeTypeById", ce);
      }
    }

    return wssrt;
  }

  public String[] getWebServiceTypeBySelection(IStructuredSelection selection)
  {

    TypeSelectionFilter tsf = new TypeSelectionFilter();
    String[] wst = tsf.getWebServiceTypeByInitialSelection(selection, webServiceTypes);
    return wst == null ? null : wst;

  }

  public IWebServiceType getWebServiceTypeByTypeLabel(String webServiceTypeLabel)
  {

    Iterator iter = webServiceTypes.values().iterator();
    while (iter.hasNext())
    {
      WebServiceTypeImpl wst = (WebServiceTypeImpl)iter.next();
      if (wst!=null) {
        if (wst.getLabel().equals(webServiceTypeLabel)) {
          return wst; 
        }
      }
    }
    return null;
  }

  public boolean isInitialSelectionValidForChosenType(IStructuredSelection selection, String typeName)
  {
    String[] supportedTypes = getWebServiceTypeBySelection(selection);
    if (supportedTypes!=null)
    {
      for (int i=0; i<supportedTypes.length; i++)
      {
        if (supportedTypes[i].equals(typeName))
          return true;
      }
    }
    return false;

  }

  public boolean isServerSupportedForChosenType(String typeId, String serverID)
  {
    if (serversByType_.containsKey(typeId))
    {
      Vector vect = (Vector)serversByType_.get(typeId);
      for (int i=0; i<vect.size(); i++)
      {
        WebServiceServer wss = (WebServiceServer)webServiceServers.get((String)vect.elementAt(i));
        if (serverID!=null) {
          if (serverID.equalsIgnoreCase(wss.getFactoryId()))
            return true;
        }
      }
    }
    return false;
  }
  
  public boolean isServerRuntimeTypeSupported(String server, String runtime, String type)  {

      WebServiceServerRuntimeType wssrt = null;
      IConfigurationElement elem = getConfigurationElementFor(server, runtime, type);
      return elem == null ? false : true; 
          
  }
  
  public String getDefaultServerValueFor(String typeId)
  {
    String[] servers; 
    if (serversByType_.containsKey(typeId))
    {
      Vector vect = (Vector)serversByType_.get(typeId);
      servers = new String[vect.size()];
      for (int i=0; i<vect.size(); i++)
      {
        String serverId = (String)vect.elementAt(i);
        WebServiceServer wss = (WebServiceServer)webServiceServers.get(serverId);
        servers[i] = (String)wss.getId();
      }
      return servers[0];
    }
    else
    {
      log_.log(Log.ERROR, 5063, this, "getServerByType", "Unable to find default server for "+typeId);
      return null;
    }

  }

  public String getDefaultRuntimeValueFor(String typeId)
  {
    String[] runtimeName = getRuntimesByType(typeId);
    for (int i=0; i<runtimeName.length; i++)
    {
        WebServiceRuntime wsr = (WebServiceRuntime)webServiceRuntimes.get(runtimeName[i]);
        if (wsr.getIsDefault())
        	return runtimeName[i];
    }   
    return runtimeName[0];
  }
  
  public String getServerIdForFactoryId(String factoryId) {

    Iterator iter = webServiceServers.values().iterator();
    while (iter.hasNext()) {
      WebServiceServer wss = (WebServiceServer)iter.next();
      if (wss.getFactoryId().equals(factoryId)) {
        return wss.getId();
      }
    }
    return null;

  }
 
  public final class WebServiceServerRuntimeType_
  {
    
   public String typeId_;
   public String serverId_;
   public String runtimeId_;
   public IConfigurationElement element_;
   
   public WebServiceServerRuntimeType_(String serverId, String runtimeId,String typeId, IConfigurationElement elem)
   {
    this.typeId_ = typeId;
    this.serverId_ = serverId;
    this.runtimeId_ = runtimeId;
    this.element_ = elem;
   }
    
   public IConfigurationElement getConfigurationElementFor(String serverID, String runtimeID, String typeID)
   {
    if (this.typeId_.equals(typeID) && this.serverId_.equals(serverID) && this.runtimeId_.equals(runtimeID))
      return this.element_;
    return null;
   }
   
   public boolean hasConfigElementFor(String factoryID, String runtimeID, String typeID) 
   {
     String serverID = getServerIdForFactoryId( factoryID ); 
       
     if (typeId_.equalsIgnoreCase(typeID) &&
         serverId_.equalsIgnoreCase(serverID) &&
         runtimeId_.equalsIgnoreCase(runtimeID))
     {
        return true;
     }
     
     return false;
    }
    
    
  }

  public CommandFragmentFactoryFactory getFactoryFactory( String[] ids )
  {
    String                hashKey = ids[2] + "#" + ids[1] + "#" + ids[0];
    CommandWidgetBinding  binding = (CommandWidgetBinding)factoryCache_.get( hashKey );
    
    if( binding == null ) 
    {
      IConfigurationElement element = getConfigElementFor( ids[2], ids[1], ids[0] ); 
    
      if( element == null ) return null;
    
      binding = createBinding( element );
      
      factoryCache_.put( hashKey, binding );
      
      binding.registerDataMappings( dataMappingRegistry_ );
      
      if( widgetRegistry_ != null )
      {
        binding.registerWidgetMappings( widgetRegistry_ );
        binding.registerCanFinish( canFinishRegistry_ );
      }
    }
         
    return binding;    
  }
  
  private CommandWidgetBinding createBinding(IConfigurationElement element ) 
  {
    Vector bindings = new Vector(4);
    Vector fragments = new Vector(4);
    
    addBinding( element, "developBinding", bindings );
    addBinding( element, "assemblyBinding", bindings );
    addBinding( element, "deployBinding", bindings );
    addBinding( element, "installBinding", bindings );
    
    fragments.add( new ServicePreDevelopFragment() );
    fragments.add( new ServicePreAssemblyFragment() );
    fragments.add( new ServicePreDeployFragment() );
    fragments.add( new ServicePreInstallFragment() );
     
    return new CommandWidgetBindingList( bindings, fragments );
  }
  
  private void addBinding( IConfigurationElement element, String bindingName, Vector list )
  {
    Object binding = null;
    
    if( element.getAttribute( bindingName ) != null )
    {
      try
      {
        binding = element.createExecutableExtension( bindingName ); 
      }
      catch( CoreException exc )
      {
      }
    }
    
    list.add( binding );
  }
  
  public void setDataMappingRegistry( DataMappingRegistry registry )
  {
    dataMappingRegistry_ = registry;
    
    // We need to rebuild the factory cache each time we start the server
    // wizard.
    factoryCache_        = new HashMap();
  }
  
  public void setWidgetRegistry( WidgetRegistry registry )
  {
    widgetRegistry_ = registry;;  
  }
  
  public void setCanFinishRegistry( CanFinishRegistry registry )
  {
    canFinishRegistry_ = registry;
  }

  public String[] getAllServerFactoryIds()
  {
  	Object[] servers = webServiceServers.values().toArray();
  	String[] factoryIds = new String[servers.length];
  	for (int i=0; i<servers.length; i++)
  	{
  		WebServiceServer wss = (WebServiceServer)servers[i];
  		factoryIds[i] = wss.getFactoryId();
  	}
  	return factoryIds;
  }
  
  public String getServerFactoryIdFromServerId(String serverId)
  {
  	Object[] servers = webServiceServers.values().toArray();
  	for (int i=0; i<servers.length; i++)
  	{
  		WebServiceServer wss = (WebServiceServer)servers[i];
  		if (serverId == wss.getId())
  		{
  			return wss.getFactoryId();
  		}
  			
  	}
  	return null;
  }
  
  /*
   * Returns a cascading list of valid choices for server, runtime, and J2EE levels. 
   * This is an intersection of what is available for service and client. 
   */
  public SelectionListChoices getServerToRuntimeToJ2EE()
  {
  	if (serverToRuntimeToJ2EE_!=null)
  	{
  		return serverToRuntimeToJ2EE_;
  	}
  	
  	String[] servers = getStringArrayIntersection(getAllServerFactoryIds(), WebServiceClientTypeRegistry.getInstance().getAllClientServerFactoryIds());
    SelectionList serversList = new SelectionList(servers, 0);
    Vector choices = new Vector();
    for (int i=0; i<servers.length; i++)
    {
    	choices.add(getRuntimeChoices(servers[i]));
    }
    serverToRuntimeToJ2EE_ = new SelectionListChoices(serversList, choices);
    return serverToRuntimeToJ2EE_;
  	
  }
  
  private SelectionListChoices getRuntimeChoices(String serverFactoryId)
  {
  	String[] serviceRuntimes = getRuntimeIDsByServerFactoryID(serverFactoryId);
  	String[] clientRuntimes = WebServiceClientTypeRegistry.getInstance().getRuntimeIdsByServerFactoryId(serverFactoryId);
  	String[] runtimes = getStringArrayIntersection(serviceRuntimes, clientRuntimes);
  	SelectionList runtimesList = new SelectionList(runtimes, 0);
  	Vector choices = new Vector();
    for (int i=0; i<runtimes.length; i++)
    {
    	choices.add(getJ2EEChoices(runtimes[i]));
    }
    return new SelectionListChoices(runtimesList, choices);    
  }
  
  private SelectionListChoices getJ2EEChoices(String runtimeId)
  {
  	String[] serviceJ2EEVersions = getWebServiceRuntimeById(runtimeId).getJ2EEVersions();
  	String[] clientJ2EEVersions = WebServiceClientTypeRegistry.getInstance().getWebServiceRuntimeById(runtimeId).getJ2EEVersions();
  	String[] j2eeVersions = getStringArrayIntersection(serviceJ2EEVersions, clientJ2EEVersions);
  	SelectionList j2eeVersionsList = new SelectionList(j2eeVersions, 0);
  	return new SelectionListChoices(j2eeVersionsList, null);
  }
  
  public String getServerLabel(String factoryId)
  {
  	if (factoryId==null || factoryId.length()==0)
  		return null;
  	
  	if (serverLabelByFactoryId_.containsKey(factoryId))
  	{
  	  return (String)serverLabelByFactoryId_.get(factoryId);
  	}
  	else
  	{
  	  return null;
  	}
  }
  
  public String getServerFactoryId(String label)
  {
  	if (label==null || label.length()==0)
  		return null;
  	
  	if (serverFactoryIdByLabel_.containsKey(label))
  	{
  	  return (String)serverFactoryIdByLabel_.get(label);  
  	}
  	else
  	{
  	  return null;
  	}  	  	
  }
  
  public String getRuntimeLabel(String id)
  {
  	if (id==null || id.length()==0)
  		return null;
  	
  	return (String) runtimeLabelById_.get(id);
  }
  
  public String getRuntimeId(String label)
  {
  	if (label==null || label.length()==0)
  		return null;
  	
  	return (String)runtimeIdByLabel_.get(label);  	
  }  
  
  private String[] getStringArrayIntersection(String[] a1, String[] a2)
  {
  	Vector vf = new Vector();
  	if (a1==null || a2==null)
  	{
  		return convertToStringArray(vf.toArray());
  	}  	
  	
  	for (int i=0; i<a1.length; i++)
  	{
  		for (int j=0; j<a2.length; j++)
  		{
  			if (a1[i].equals(a2[j]))
  			{
  				vf.add(a1[i]);
  				break;
  			}
  		}
  	}
  	
  	return convertToStringArray(vf.toArray());
  }
  
  private String[] convertToStringArray(Object[] a)
  {
  	if (a==null) return new String[0];
  	
  	int length = a.length;
  	String[] sa = new String[length];
  	for (int i=0; i<length; i++)
  	{
  		Object obj = a[i];
  		if (obj instanceof String)
  		{
  			sa[i] = (String)obj;
  		}
  	}
  	return sa;
  }
}