/*
    * Copyright 2001-2004 The Apache Software Foundation.
    * 
    * Licensed 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.ws.scout.registry;
  
  import java.io.Serializable;
  import java.util.Properties;
  import java.util.Set;
  
  import javax.xml.registry.Connection;
  import javax.xml.registry.InvalidRequestException;
  import javax.xml.registry.JAXRException;
  import javax.xml.registry.RegistryService;
  
  import org.apache.commons.configuration.ConfigurationException;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.juddi.v3.client.config.UDDIClient;
  
  /**
   * Apache Scout Implementation of a JAXR Connection.
   * For futher details, look into the JAXR API Javadoc.
   *
   * @author Anil Saldhana  <anil@apache.org>
   * @author Tom Cunningham <tcunning@apache.org>
   */
  public class ConnectionImpl implements Connection, Serializable
  {
      public static final String JUDDI_CLIENT_CONFIG_FILE         = "scout.juddi.client.config.file";
      public static final String DEFAULT_JUDDI_CLIENT_CONFIG_FILE = "META-INF/jaxr-uddi.xml";
      public static final String DEFAULT_UDDI_VERSION             = "2.0";
      
  	private static final long serialVersionUID = 3542404895814764176L;
  	private static Log log = LogFactory.getLog(ConnectionImpl.class);
  	private boolean closed = false;
      private boolean synchronous = true;
      private Set credentials;
      private final IRegistryBase registry;
      private final String postalScheme;
      private final int maxRows;
      private String uddiVersion;
      UDDIClient manager = null;
  
      public ConnectionImpl(Properties properties) throws InvalidRequestException
      {
          postalScheme = properties.getProperty(ConnectionFactoryImpl.POSTALADDRESSSCHEME_PROPERTY);
          String val = properties.getProperty(ConnectionFactoryImpl.MAXROWS_PROPERTY);
          maxRows = (val == null) ? -1 : Integer.valueOf(val);
          uddiVersion = properties.getProperty(ConnectionFactoryImpl.UDDI_VERSION_PROPERTY, DEFAULT_UDDI_VERSION);
          //The TCK does not set the UDDI_VERSION, so if the lifecycle URL contains 'v3' we 
          //automagically set the version to be "3.0"
          if (!properties.contains(ConnectionFactoryImpl.UDDI_VERSION_PROPERTY) 
                  && (properties.contains(ConnectionFactoryImpl.LIFECYCLEMANAGER_PROPERTY)) 
                  && properties.getProperty(ConnectionFactoryImpl.LIFECYCLEMANAGER_PROPERTY).contains("v3") ) {
              properties.setProperty(ConnectionFactoryImpl.UDDI_VERSION_PROPERTY, "3.0");
              uddiVersion = "3.0";
              String securityManager = properties.getProperty(ConnectionFactoryImpl.LIFECYCLEMANAGER_PROPERTY).replace("publish", "security");
              properties.setProperty(ConnectionFactoryImpl.SECURITYMANAGER_PROPERTY, securityManager);
          }
       
          String uddiConfigFile      = properties.getProperty(JUDDI_CLIENT_CONFIG_FILE);// DEFAULT_JUDDI_CLIENT_CONFIG_FILE);
          if (isUDDIv3(uddiVersion)) {
              String nodeName = null;
              String managerName = null;
              if (manager==null && uddiConfigFile!=null) {
                  try {
                      manager = new UDDIClient(uddiConfigFile, properties);
                      manager.start();
                  } catch (ConfigurationException e) {
                      log.error(e.getMessage(),e);
                  }
              }
              if (manager !=null) {
                  try {
                      managerName = manager.getName();
                      nodeName = manager.getClientConfig().getHomeNode().getName();
                  } catch (ConfigurationException e) {
                      log.error(e.getMessage(),e);
                  }
              }
              registry = new RegistryV3Impl(properties, nodeName, managerName);
          } else {
              registry = new RegistryImpl(properties);           	
          }
  
          //this.postalScheme = postalScheme;
         //this.maxRows = maxRows;
 
     }
     
     private boolean isUDDIv3(String version) {
         if (version.startsWith("3")) return true;
         return false;
     }
 
     public RegistryService getRegistryService() throws JAXRException
     {
         RegistryServiceImplryServiceImpl.html#RegistryServiceImpl">RegistryServiceImpl reg = new RegistryServiceImpl(registry, postalScheme, maxRows, uddiVersion);
         reg.setConnection(this);
         return reg;
     }
 
     public void close()
     {
         closed = true;
     }
 
     public boolean isClosed()
     {
         return closed;
     }
 
     public Set getCredentials()
     {
         return credentials;
     }
 
     public void setCredentials(Set credentials)
     {
         this.credentials = credentials;
     }
 
     public boolean isSynchronous()
     {
         return synchronous;
     }
 
     public void setSynchronous(boolean synchronous)
     {
         this.synchronous = synchronous;
     }
 }