/* 
    * Copyright (c) 2005-2011, 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.it;
  
  import org.apache.log4j.Logger;
  import org.apache.xmlbeans.XmlObject;
  import org.ogf.graap.wsag.api.AgreementOffer;
  import org.ogf.graap.wsag.api.exceptions.AgreementFactoryException;
  import org.ogf.graap.wsag.api.exceptions.ResourceUnavailableException;
  import org.ogf.graap.wsag.api.exceptions.ResourceUnknownException;
  import org.ogf.graap.wsag.api.types.AgreementOfferType;
  import org.ogf.graap.wsag.client.api.AgreementClient;
  import org.ogf.graap.wsag.client.api.AgreementFactoryClient;
  import org.ogf.schemas.graap.wsAgreement.AgreementStateDefinition;
  import org.ogf.schemas.graap.wsAgreement.AgreementStateDefinition.Enum;
  import org.ogf.schemas.graap.wsAgreement.AgreementTemplateType;
  import org.ogf.schemas.graap.wsAgreement.ServiceDescriptionTermType;
  import org.w3.x2005.x08.addressing.EndpointReferenceDocument;
  import org.w3.x2005.x08.addressing.EndpointReferenceType;
  
  /**
   * Abstract test case for creation of pending agreements.
   * 
   * @author Oliver Waeldrich
   * 
   */
  public abstract class AbstractPendingAgreementFactoryTest extends AbstractIntegrationTest
  {
  
      /**
       * waiting time for doing the sub-contracting (pending agreement)
       */
      protected static final int SUBCONTRACTING_WAITING_TIME = 8000;
  
      private static final Logger LOG = Logger.getLogger( AbstractPendingAgreementFactoryTest.class );
  
      /**
       * 
       * @param name
       *            the test name
       */
      public AbstractPendingAgreementFactoryTest( String name )
      {
          super( name );
      }
  
      /**
       * Creates a pending agreement that is accepted after 1 second. The agreement is destroyed afterwards.
       */
      public void testCreatePendingAgreement()
      {
          try
          {
              LOG.info( "Entering TestCase: testCreatePendingAgreement" );
  
              AgreementFactoryClient[] factories = getAgreementFactoryClients();
              assertEquals( getDefaultFactoryCount(), factories.length );
  
              LOG.info( "Overview of the available factories and their templates." );
              for ( int i = 0; i < factories.length; i++ )
              {
                  LOG.info( "+ " + factories[i].getResourceId() );
  
                  AgreementTemplateType[] templates = factories[i].getTemplates();
                  LOG.info( "   + Num of templates: " + templates.length );
  
                  for ( int k = 0; k < templates.length; k++ )
                 {
                     LOG.info( "      + " + templates[k].getName() );
                 }
             }
 
             AgreementFactoryClient factory = factories[0];
 
             AgreementClient[] agreements;
 
             LOG.info( "Creating new Agreements" );
             AgreementTemplateType template = factory.getTemplate( "SAMPLE4-PENDING-AGREEMENT", "1" );
             AgreementOffer offer = new AgreementOfferType( template );
 
             LOG.info( "Create pending agreement" );
             AgreementClient agreement1 = factory.createPendingAgreement( offer );
 
             assertNotNull( "the created agreement must not be <null>", agreement1 );
 
             assertEquals( "The state of the pending agreement must be PENDING.",
                 AgreementStateDefinition.INT_PENDING, agreement1.getState().getState().intValue() );
 
             //
             // Waiting for acceptance
             //
             while ( agreement1.getState().getState() != AgreementStateDefinition.OBSERVED )
             {
                 Thread.sleep( 1000 );
             }
 
             LOG.info( "Destroy agreement 1" );
             agreement1.destroy();
             agreements = factory.listAgreements();
             assertEquals( 0, agreements.length );
 
         }
         catch ( AgreementFactoryException e )
         {
             fail( "AgreementFactoryException: " + e.getMessage() );
         }
         catch ( ResourceUnavailableException e )
         {
             fail( "ResourceUnavailableException: " + e.getMessage() );
         }
         catch ( ResourceUnknownException e )
         {
             fail( "ResourceUnknownException: " + e.getMessage() );
         }
         catch ( Exception e )
         {
             fail( "Could not create agreement factory instance. Error: " + e.getMessage() );
 
             if ( LOG.isDebugEnabled() )
             {
                 LOG.debug( e );
             }
         }
     }
 
     /**
      * Creates a pending agreement that is accepted after 1 second. On acceptance the creator is notified
      * using the agreement acceptance port type.
      * 
      * This implementation uses one factory instance.
      */
     public void testCreatePendingAgreementWithNotification()
     {
         try
         {
             LOG.info( "Entering TestCase: testCreatePendingAgreementWithNotification" );
 
             AgreementFactoryClient[] factories = getAgreementFactoryClients();
             assertEquals( getDefaultFactoryCount(), factories.length );
 
             LOG.info( "Overview of the available factories and their templates." );
             for ( int i = 0; i < factories.length; i++ )
             {
                 LOG.info( "+ " + factories[i].getResourceId() );
 
                 AgreementTemplateType[] templates = factories[i].getTemplates();
                 LOG.info( "   + Num of templates: " + templates.length );
 
                 for ( int k = 0; k < templates.length; k++ )
                 {
                     LOG.info( "      + " + templates[k].getName() );
                 }
             }
 
             AgreementFactoryClient factory = factories[0];
 
             AgreementClient[] agreements;
 
             /*
              * The agreement we create is a pending agreement. The agreement responder subcontracts another
              * factory with the service provisioning. If the subcontractor accepts the creation of the
              * agreement, it notifies the agreement responder via agreement acceptance. The responder than
              * changes the state of the agreement accordingly.
              */
             LOG.info( "Creating new Agreements" );
             AgreementTemplateType template =
                 factory.getTemplate( "SAMPLE5-PENDING-AGREEMENT-WITH-NOTIFICATION", "1" );
 
             //
             // update the subcontractor EPR for the offer
             //
             ServiceDescriptionTermType sdt = template.getTerms().getAll().getServiceDescriptionTermArray( 0 );
             XmlObject[] children =
                 sdt.selectChildren( EndpointReferenceDocument.type.getDocumentElementName() );
             EndpointReferenceType targetEPR = (EndpointReferenceType) children[0];
             targetEPR.set( factory.getRemoteClient().getRemoteReference() );
 
             AgreementOffer offer = new AgreementOfferType( template );
 
             LOG.info( "Create pending agreement" );
             AgreementClient agreement1 = factory.createPendingAgreement( offer );
 
             assertNotNull( "the created agreement must not be <null>", agreement1 );
 
             // assertEquals("The state of the pending agreement must be PENDING.",
             // AgreementStateDefinition.INT_PENDING, agreement1.getState().getState().intValue());
 
             //
             // The contractor accepts the agreement as soon the pending agreement with the subcontractor is
             // instantiated. The contractor will change the agreement state to complete when the subcontracted
             // agreement was accepted and the notification was recieved. The subcontractor needs 5 seconds for
             // decision making.
             //
             boolean accepted = false;
             boolean subcontractAccepted = false;
 
             for ( int i = 0; i < 5; i++ )
             {
                 Thread.sleep( SUBCONTRACTING_WAITING_TIME );
                 Enum state = agreement1.getState().getState();
 
                 accepted =
                     ( state == AgreementStateDefinition.OBSERVED )
                         || ( state == AgreementStateDefinition.COMPLETE );
 
                 subcontractAccepted = state == AgreementStateDefinition.COMPLETE;
 
                 if ( subcontractAccepted )
                 {
                     break;
                 }
             }
 
             assertTrue( "The pending agreement was not subcontracted.", accepted );
             assertTrue( "The notification for the subcontracted pending agreement was not received.",
                 subcontractAccepted );
 
             LOG.info( "Destroy agreement 1" );
             agreement1.destroy();
             agreements = factory.listAgreements();
 
             //
             // there must be still the sub-contracted agreement resource
             //
             assertEquals( 1, agreements.length );
         }
         catch ( AgreementFactoryException e )
         {
             fail( "AgreementFactoryException: " + e.getMessage() );
         }
         catch ( ResourceUnavailableException e )
         {
             fail( "ResourceUnavailableException: " + e.getMessage() );
         }
         catch ( ResourceUnknownException e )
         {
             fail( "ResourceUnknownException: " + e.getMessage() );
         }
         catch ( Exception e )
         {
             fail( "Could not create agreement factory instance. Error: " + e.getMessage() );
 
             if ( LOG.isDebugEnabled() )
             {
                 LOG.debug( e );
             }
         }
     }
 }