/* 
    * Copyright (c) 2007, Fraunhofer-Gesellschaft
    * All rights reserved.
    * 
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions are
    * met:
    * 
    * (1) Redistributions of source code must retain the above copyright
   *     notice, this list of conditions and the disclaimer at the end.
   *     Redistributions in binary form must reproduce the above copyright
   *     notice, this list of conditions and the following disclaimer in
   *     the documentation and/or other materials provided with the
   *     distribution.
   * 
   * (2) Neither the name of Fraunhofer nor the names of its
   *     contributors may be used to endorse or promote products derived
   *     from this software without specific prior written permission.
   * 
   * DISCLAIMER
   * 
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   *  
   */
  package org.ogf.graap.wsag.client.wsrf;
  
  import java.util.Properties;
  
  import org.apache.xmlbeans.XmlObject;
  import org.ogf.graap.wsag.api.AgreementOffer;
  import org.ogf.graap.wsag.api.WsagConstants;
  import org.ogf.graap.wsag.api.exceptions.AgreementFactoryException;
  import org.ogf.graap.wsag.api.exceptions.NegotiationFactoryException;
  import org.ogf.graap.wsag.api.exceptions.ResourceUnavailableException;
  import org.ogf.graap.wsag.api.exceptions.ResourceUnknownException;
  import org.ogf.graap.wsag.api.security.ISecurityProperties;
  import org.ogf.graap.wsag.client.api.AgreementClient;
  import org.ogf.graap.wsag.client.api.AgreementFactoryClient;
  import org.ogf.graap.wsag.client.api.NegotiationClient;
  import org.ogf.graap.wsag.client.api.RemoteClient;
  import org.ogf.graap.wsag.client.wsrf.impl.WsrfAgreementFactoryService;
  import org.ogf.graap.wsag.client.wsrf.impl.WsrfAgreementRegistryService;
  import org.ogf.graap.wsag.client.wsrf.impl.WsrfResourceClient;
  import org.ogf.schemas.graap.wsAgreement.AgreementFactoryPropertiesDocument;
  import org.ogf.schemas.graap.wsAgreement.AgreementFactoryPropertiesType;
  import org.ogf.schemas.graap.wsAgreement.AgreementTemplateType;
  import org.ogf.schemas.graap.wsAgreement.negotiation.NegotiationContextType;
  import org.w3.x2005.x08.addressing.EndpointReferenceDocument;
  import org.w3.x2005.x08.addressing.EndpointReferenceType;
  import org.w3c.dom.Element;
  
  /**
   * RemoteAgreementFactoryClientImpl
   * 
   * @author Oliver Waeldrich
   * 
   */
  public class WsrfAgreementFactoryClient extends RemoteClient
      implements AgreementFactoryClient
  {
  
      //
      // client for invoking WS-Agreement factory methods
      //
      private final WsrfAgreementFactoryService factoryClient;
  
      //
      // client for invoking WSSRF service group methods
      //
      private final WsrfAgreementRegistryService registryClient;
  
      /**
       * Creates a new agreement factory client for a given endpoint using the given security properties.
       * 
       * @param epr
       *            the agreement factory endpoint
       * 
       * @param securityProperties
       *            the client security properties
       */
      public WsrfAgreementFactoryClient( EndpointReferenceType epr, Properties properties,
                                         ISecurityProperties securityProperties )
      {
          super( epr, properties, securityProperties );
          try
          {
              //
              // generate the endpoint references for the registry service
              //
             String factoryURI = epr.getAddress().getStringValue();
             String registryURI =
                 factoryURI.substring( 0, factoryURI.indexOf( WsagConstants.AGREEMENT_FACTORY_SERVICE_URI ) )
                     + WsagConstants.AGREEMENT_REGISTRY_SERVICE_URI;
 
             EndpointReferenceDocument registryEPR = EndpointReferenceDocument.Factory.newInstance();
             registryEPR.addNewEndpointReference().addNewAddress().setStringValue( registryURI );
             registryEPR.getEndpointReference().addNewReferenceParameters().set( epr.getReferenceParameters() );
 
             //
             // initialize the service clients
             //
             factoryClient = new WsrfAgreementFactoryService( epr, getProperties(), getSecurityProperties() );
 
             registryClient =
                 new WsrfAgreementRegistryService( registryEPR.getEndpointReference(), getProperties(),
                     getSecurityProperties() );
         }
         catch ( Exception e )
         {
             throw new RuntimeException( e );
         }
 
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public AgreementFactoryClient clone() throws CloneNotSupportedException
     {
         return new WsrfAgreementFactoryClient( getEndpoint(), getProperties(),
             getSecurityProperties().clone() );
     }
 
     /**
      * {@inheritDoc}
      */
     public RemoteClient getWebServiceClient()
     {
         return this;
     }
 
     /**
      * {@inheritDoc}
      */
     public EndpointReferenceType getEndpoint()
     {
         return getRemoteReference();
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see org.ogf.graap.wsag.client.api.AgreementFactoryClient#getRemoteClient()
      */
     public RemoteClient getRemoteClient()
     {
         return this;
     }
 
     /**
      * Returns the templates supported by this factory.
      * 
      * {@inheritDoc}
      */
     public AgreementTemplateType[] getTemplates()
         throws ResourceUnknownException, ResourceUnavailableException
     {
         return factoryClient.getTemplates();
     }
 
     /**
      * Creates a new agreement instance.
      * 
      * @param offer
      *            the offer to create the agreement for
      * 
      * @return the created agreement
      * 
      * @throws AgreementFactoryException
      *             the agreement offer was rejected by the factory
      * 
      * @throws ResourceUnavailableException
      *             the requested agreement factory resource is unavailable
      * 
      * @throws ResourceUnknownException
      *             the requested agreement factory resource is unknown
      */
     public AgreementClient createAgreement( AgreementOffer offer )
         throws AgreementFactoryException, ResourceUnknownException, ResourceUnavailableException
     {
         return factoryClient.createAgreement( offer );
     }
 
     /**
      * Creates a new pending agreement instance.
      * 
      * {@inheritDoc}
      */
     public AgreementClient createPendingAgreement( AgreementOffer offer )
         throws AgreementFactoryException, ResourceUnknownException, ResourceUnavailableException
     {
         return factoryClient.createPendingAgreement( offer );
     }
 
     /**
      * Creates a new pending agreement instance.
      * 
      * {@inheritDoc}
      */
     public AgreementClient createPendingAgreement( AgreementOffer offer, EndpointReferenceType acceptanceEPR )
         throws AgreementFactoryException, ResourceUnknownException, ResourceUnavailableException
     {
         return factoryClient.createPendingAgreement( offer, acceptanceEPR );
     }
 
     /**
      * Initiates a Negotiation.
      * 
      * {@inheritDoc}
      */
     public NegotiationClient initiateNegotiation( NegotiationContextType context )
         throws NegotiationFactoryException, ResourceUnknownException, ResourceUnavailableException
     {
         return factoryClient.initiateNegotiation( context );
     }
 
     /**
      * {@inheritDoc}
      */
     public String getResourceId() throws ResourceUnknownException, ResourceUnavailableException
     {
         return factoryClient.getResourceId();
     }
 
     /**
      * 
      * @return a template with the given name and id, or null if no appropriate template was found.
      * 
      *         {@inheritDoc}
      */
     public AgreementTemplateType getTemplate( String name, String id )
         throws ResourceUnknownException, ResourceUnavailableException
     {
         if ( name == null )
         {
             return null;
         }
 
         id = ( id != null ) ? id : "";
 
         AgreementTemplateType[] templates = getTemplates();
 
         for ( int i = 0; i < templates.length; i++ )
         {
             if ( name.equalsIgnoreCase( templates[i].getName() ) )
             {
 
                 String actualId =
                     ( templates[i].getTemplateId() != null ) ? templates[i].getTemplateId() : "";
 
                 if ( id.equalsIgnoreCase( actualId ) )
                 {
                     return templates[i];
                 }
             }
         }
 
         return null;
     }
 
     /**
      * Lists all agreements of this factory.
      * 
      * @return all agreement clients known by this factory
      * 
      * @throws ResourceUnavailableException
      *             the requested agreement factory resource is unavailable
      * 
      * @throws ResourceUnknownException
      *             the requested agreement factory resource is unknown
      */
     public AgreementClient[] listAgreements() throws ResourceUnknownException, ResourceUnavailableException
     {
         return registryClient.listAgreements();
     }
 
     /**
      * Turns trace on/off.
      * 
      * @param trace
      *            turns trace on/off.
      */
     @Override
     public void setTrace( boolean trace )
     {
         factoryClient.getWebServiceClient().setTrace( trace );
         registryClient.getWebServiceClient().setTrace( trace );
     }
 
     /**
      * @param properties
      *            The properties to set.
      */
     @Override
     public void setProperties( Properties properties )
     {
         super.setProperties( properties );
         factoryClient.getWebServiceClient().setProperties( properties );
         registryClient.getWebServiceClient().setProperties( properties );
     }
 
     /**
      * @return Returns the agreement factory client.
      */
     public WsrfAgreementFactoryService getAgreementFactoryClient()
     {
         return factoryClient;
     }
 
     /**
      * @return Returns the agreement registry client.
      */
     public WsrfAgreementRegistryService getAgreementRegistryClient()
     {
         return registryClient;
     }
 
     /**
      * {@inheritDoc}
      * 
      * @see org.ogf.graap.wsag.client.api.AgreementFactoryClient#getResourceProperties()
      */
     public AgreementFactoryPropertiesType getResourceProperties()
         throws ResourceUnknownException, ResourceUnavailableException
     {
         try
         {
             WsrfResourceClient wsrf = getAgreementFactoryClient().getWebServiceClient();
             Element doc = wsrf.getResourcePropertyDocument();
             AgreementFactoryPropertiesDocument propertiesDoc =
                 (AgreementFactoryPropertiesDocument) XmlObject.Factory.parse( doc );
             return propertiesDoc.getAgreementFactoryProperties();
         }
         catch ( Exception e )
         {
             throw new ResourceUnavailableException( "Failed to parse server response.", e );
         }
     }
 
 }