/* 
    * 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.it.samples.negotiation;
  
  import java.util.Calendar;
  import java.util.GregorianCalendar;
  
  import org.apache.log4j.Logger;
  import org.apache.xmlbeans.XmlDateTime;
  import org.ggf.schemas.jsdl.x2005.x11.jsdl.JobDefinitionDocument;
  import org.ggf.schemas.jsdl.x2005.x11.jsdl.RangeValueType;
  import org.ggf.schemas.jsdl.x2005.x11.jsdl.ResourcesType;
  import org.ogf.graap.wsag.api.AgreementOffer;
  import org.ogf.graap.wsag.api.exceptions.NegotiationException;
  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.types.AgreementOfferType;
  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.it.AbstractIntegrationTest;
  import org.ogf.graap.wsag.samples.actions.SampleAgreementTemplate;
  import org.ogf.graap.wsag.samples.actions.SampleNegotiationOffer;
  import org.ogf.graap.wsag4j.types.scheduling.TimeConstraintDocument;
  import org.ogf.graap.wsag4j.types.scheduling.TimeConstraintType;
  import org.ogf.schemas.graap.wsAgreement.AgreementTemplateType;
  import org.ogf.schemas.graap.wsAgreement.OfferItemType.ItemConstraint;
  import org.ogf.schemas.graap.wsAgreement.ServiceDescriptionTermType;
  import org.ogf.schemas.graap.wsAgreement.negotiation.NegotiationConstraintSectionType;
  import org.ogf.schemas.graap.wsAgreement.negotiation.NegotiationContextDocument;
  import org.ogf.schemas.graap.wsAgreement.negotiation.NegotiationContextType;
  import org.ogf.schemas.graap.wsAgreement.negotiation.NegotiationOfferContextType;
  import org.ogf.schemas.graap.wsAgreement.negotiation.NegotiationOfferItemType;
  import org.ogf.schemas.graap.wsAgreement.negotiation.NegotiationOfferStateType;
  import org.ogf.schemas.graap.wsAgreement.negotiation.NegotiationOfferType;
  import org.ogf.schemas.graap.wsAgreement.negotiation.NegotiationRoleType;
  import org.ogf.schemas.graap.wsAgreement.negotiation.NegotiationType;
  
  /**
   * Sample Negotiator to demonstrate the Agreement Negotiation.
   * 
   * @author hrasheed
   * 
   */
  public class AbstractSampleNegotiatorTest extends AbstractIntegrationTest
  {
  
      /**
       * 
       */
      private static final int DURATION = 15;
  
      /**
       * 
       */
      private static final int STARTTIME_OFFSET = 10;
  
      /**
       * 
       */
      private static final int ENDTIME_OFFSET = 20;
  
      private static final Logger LOG = Logger.getLogger( AbstractSampleNegotiatorTest.class );
  
      private static final String FACTORY_RESOURCE_ID = "SAMPLE-INSTANCE-1";
  
     private static final String TEMPLATE_NAME = "SAMPLE-TEMPLATE";
 
     private static final String RESOURCES_SDT_NAME = "RESOURCE_SDT";
 
     private static final String TIME_CONSTRAINT_SDT_NAME = "TIME_CONSTRAINT_SDT";
 
     private static final int END_TIME_OFFSET = 45;
 
     /**
      * 
      * @param name
      *            the test case name
      */
     public AbstractSampleNegotiatorTest( String name )
     {
         super( name );
     }
 
     /**
      * Tests the negotiation of offers and counter offers.
      * 
      * @throws Exception
      *             indicates an error in the test case
      */
     public void testSampleNegotiator() throws Exception
     {
 
         //
         // initiate the negotiation instance
         //
         NegotiationClient negotiation = initiateNegotiation();
 
         try
         {
             //
             // retrieve the negotiable template
             //
             SampleAgreementTemplate negotiationTemplate = getNegotiableTemplate( negotiation );
 
             /******************************************************************
              * First round of the Negotiation
              ******************************************************************/
             //
             // This template includes the service description term 'RESOURCE_SDT' with a JSDL document
             // describing the available compute resources.
             //
             // NegotiationOffer_1: 05 resources for 15 minutes duration with a time frame as
             // startTime = current, endTime = startTime + 60
             //
             //
             NegotiationOfferType counterOffer1 = negotiateRound1( negotiation, negotiationTemplate );
 
             /******************************************************************
              * Second round of the Negotiation
              ******************************************************************/
             //
             // we receive 2 counter offers with different resource availability as
             //
             // CounterOffer_1: 05 resources for 20 minutes duration with a time fame as
             // startTime = current + 5, endTime = startTime + 20
             //
             // CounterOffer_2: 05 resources for 15 minutes duration with a time fame as
             // startTime = current + 10, endTime = startTime + 30
             //
             // Say that both counter offers are not sufficient with respect to time,
             // we create another negotiation offer with
             //
             // NegotiationOffer_2: 05 resources for 15 minutes duration with a time frame as
             // startTime = current + 10, endTime = startTime + 20
             //
             NegotiationOfferType selectedCounterOffer = negotiateRound2( negotiation, counterOffer1 );
 
             //
             // create agreement if negotiated offer satisfy the requirements
             //
             AgreementOffer offer = new AgreementOfferType( selectedCounterOffer );
             AgreementClient agreement =
                 getAgreementFactoryClient( FACTORY_RESOURCE_ID ).createAgreement( offer );
             assertNotNull( agreement );
             LOG.info( "negotiated agreement successfully created" );
 
             //
             // finally terminate the negotiation process
             //
             LOG.info( "terminating negotiated agreement" );
             negotiation.terminate();
 
         }
         catch ( NegotiationException e )
         {
             fail( "NegotiationException: " + e.getMessage() );
         }
         catch ( ResourceUnavailableException e )
         {
             fail( "ResourceUnavailableException: " + e.getMessage() );
         }
         catch ( ResourceUnknownException e )
         {
             fail( "ResourceUnknownException: " + e.getMessage() );
         }
         catch ( Exception e )
         {
             e.printStackTrace();
             fail( "sample-negotiator fails. Error: " + e.getMessage() );
         }
     }
 
     /**
      * @param negotiation
      * @param counterOffer1
      * @return
      * @throws Exception
      * @throws NegotiationException
      * @throws ResourceUnknownException
      * @throws ResourceUnavailableException
      */
     private NegotiationOfferType negotiateRound2( NegotiationClient negotiation,
                                                   NegotiationOfferType counterOffer1 ) throws Exception
     {
         /******************************************************************
          * Second round of the Negotiation
          ******************************************************************/
         //
         // we receive 2 counter offers with different resource availability as
         //
         // CounterOffer_1: 05 resources for 20 minutes duration with a time fame as
         // startTime = current + 5, endTime = startTime + 20
         //
         // CounterOffer_2: 05 resources for 15 minutes duration with a time fame as
         // startTime = current + 10, endTime = startTime + 30
         //
         // Say that both counter offers are not sufficient with respect to time,
         // we create another negotiation offer with
         //
         // NegotiationOffer_2: 05 resources for 15 minutes duration with a time frame as
         // startTime = current + 10, endTime = startTime + 20
         //
         SampleNegotiationOffer negotiationOffer2 = new SampleNegotiationOffer( counterOffer1 );
 
         ResourcesType jobResources2 = negotiationOffer2.getResourceDefinition();
 
         RangeValueType totalCountRange2 = RangeValueType.Factory.newInstance();
         totalCountRange2.addNewExact().setDoubleValue( 5 );
         jobResources2.setTotalResourceCount( totalCountRange2 );
 
         TimeConstraintType timeConstraint2 = negotiationOffer2.getTimeConstraint();
 
         Calendar startTime2 = (Calendar) timeConstraint2.getStartTime().clone();
         startTime2.add( Calendar.MINUTE, STARTTIME_OFFSET );
         Calendar endTime2 = (Calendar) startTime2.clone();
         endTime2.add( Calendar.MINUTE, ENDTIME_OFFSET );
         timeConstraint2.setStartTime( startTime2 );
         timeConstraint2.setEndTime( endTime2 );
         timeConstraint2.setDuration( DURATION );
 
         setResourcesSDT( negotiationOffer2, jobResources2 );
         setTimeConstraintSDT( negotiationOffer2, timeConstraint2 );
 
         NegotiationOfferType[] negotiationOfferTypes2 = { negotiationOffer2.getXMLObject() };
         if ( LOG.isTraceEnabled() )
         {
             for ( int i = 0; i < negotiationOfferTypes2.length; i++ )
             {
                 LOG.trace( "Iteration-2: negotiation offers: " + negotiationOfferTypes2[i].toString() );
             }
         }
 
         NegotiationOfferType[] counterOffers2 = negotiation.negotiate( negotiationOfferTypes2 );
         assertNotNull( counterOffers2 );
         assertEquals( 1, counterOffers2.length );
 
         LOG.info( "Iteration-2: Number of counter offers received: " + counterOffers2.length );
 
         if ( LOG.isTraceEnabled() )
         {
             for ( int i = 0; i < counterOffers2.length; i++ )
             {
                 LOG.trace( "Iteration-2: counter_offer: " + counterOffers2[i].xmlText() );
             }
         }
 
         LOG.info( "second iteration of negotiation is successful" );
 
         NegotiationOfferType selectedCounterOffer = counterOffers2[0];
 
         //
         // check whether the negotiation (counter) offer is rejected
         //
         if ( selectedCounterOffer.getNegotiationOfferContext().getState().isSetRejected() )
         {
             String message =
                 "Iteration-2: counter offer [" + selectedCounterOffer.getOfferId()
                     + "] is rejected. Reason: "
                     + selectedCounterOffer.getNegotiationOfferContext().getState().xmlText();
             LOG.error( message );
             fail( "Iteration-2: NegotiationException: " + message );
         }
         return selectedCounterOffer;
     }
 
     /**
      * @param negotiation
      * @param negotiationTemplate
      * @return
      * @throws Exception
      * @throws NegotiationException
      * @throws ResourceUnknownException
      * @throws ResourceUnavailableException
      */
     private NegotiationOfferType negotiateRound1( NegotiationClient negotiation,
                                                   SampleAgreementTemplate negotiationTemplate )
         throws Exception
     {
 
         /******************************************************************
          * First round of the Negotiation
          ******************************************************************/
         //
         // This template includes the service description term 'RESOURCE_SDT' with a JSDL document
         // describing the available compute resources.
         //
         // NegotiationOffer_1: 05 resources for 15 minutes duration with a time frame as
         // startTime = current, endTime = startTime + 60
         //
         //
         String offerID =
             negotiationTemplate.getContext().getTemplateId() + "-" + negotiationTemplate.getName();
 
         ResourcesType jobResources1 = negotiationTemplate.getResourceDefinition();
 
         RangeValueType totalCountRange1 = RangeValueType.Factory.newInstance();
         totalCountRange1.addNewExact().setDoubleValue( 5 );
         jobResources1.setTotalResourceCount( totalCountRange1 );
 
         //
         // The service description term 'TIME_CONSTRAINT_SDT' defines the time frame
         // during which the resources can be available.
         // The start and end time specified by a user is considered to be the earliest possible start time and
         // the
         // deadline
         // We need an advance reservation of the resources for 15 minutes effective duration, however,
         // within a same time frame as received from a resource provider
         //
         TimeConstraintType timeConstraint1 = negotiationTemplate.getTimeConstraint();
 
         Calendar startTime1 = (Calendar) timeConstraint1.getStartTime().clone();
         Calendar endTime1 = (Calendar) timeConstraint1.getEndTime().clone();
         timeConstraint1.setStartTime( startTime1 );
         timeConstraint1.setEndTime( endTime1 );
         timeConstraint1.setDuration( 15 );
 
         //
         // now we create negotiation offer from a negotiable template for the reservation of
         // required resources to fulfill the application execution requirements.
         //
         SampleNegotiationOffer negotiationOffer1 = negotiationTemplate.getNegotiationOffer();
         negotiationOffer1.setOfferId( offerID );
 
         //
         // creating negotiation offer context
         //
         NegotiationOfferContextType negOfferContext = NegotiationOfferContextType.Factory.newInstance();
         negOfferContext.setCreator( NegotiationRoleType.NEGOTIATION_INITIATOR );
         GregorianCalendar expireDate = new GregorianCalendar();
         expireDate.add( Calendar.MINUTE, 5 );
         negOfferContext.setExpirationTime( expireDate );
         NegotiationOfferStateType negOfferState = NegotiationOfferStateType.Factory.newInstance();
         negOfferState.addNewAdvisory();
         negOfferContext.setState( negOfferState );
         negOfferContext.setCounterOfferTo( offerID ); // a fully qualified name of the template
                                                       // (templateID-TemplateName)
 
         negotiationOffer1.setNegotiationOfferContext( negOfferContext );
 
         //
         // one negotiation constraint is added that basically define the preferred time frame window within
         // which
         // the user
         // would like to have the reservation of resources (say within first 45 minutes)
         //
         NegotiationConstraintSectionType constraints1 =
             addNeogtiationOfferConstraints( timeConstraint1.getStartTime() );
         negotiationOffer1.setNegotiationConstraints( constraints1 );
 
         //
         // Service description terms 'RESOURCE_SDT' and 'TIME_CONSTRAINT_SDT' are updated in a negotiation
         // offer.
         //
         setResourcesSDT( negotiationOffer1, jobResources1 );
         setTimeConstraintSDT( negotiationOffer1, timeConstraint1 );
 
         NegotiationOfferType[] negotiationOfferTypes1 = { negotiationOffer1.getXMLObject() };
         if ( LOG.isTraceEnabled() )
         {
             for ( int i = 0; i < negotiationOfferTypes1.length; i++ )
             {
                 LOG.trace( "Iteration-1: negotiation offers: " + negotiationOfferTypes1[i].toString() );
             }
         }
 
         //
         // invoking negotiate method from Negotiation instance and
         // in return counter offers are received
         //
         NegotiationOfferType[] counterOffers1 = negotiation.negotiate( negotiationOfferTypes1 );
         assertNotNull( counterOffers1 );
         assertEquals( 2, counterOffers1.length );
 
         LOG.info( "Iteration-1: Number of counter offers received: " + counterOffers1.length );
 
         if ( LOG.isTraceEnabled() )
         {
             for ( int i = 0; i < counterOffers1.length; i++ )
             {
                 LOG.trace( "Iteration-1: counter_offer: " + counterOffers1[i].xmlText() );
             }
         }
 
         //
         // first check whether the negotiation (counter) offer is rejected
         //
         NegotiationOfferType counterOffer1 = counterOffers1[0];
         if ( counterOffer1.getNegotiationOfferContext().getState().isSetRejected() )
         {
             String message =
                 "Iteration-1: counter offer [" + counterOffer1.getOfferId() + "] is rejected. Reason: "
                     + counterOffer1.getNegotiationOfferContext().getState().xmlText();
             LOG.error( message );
             fail( "Iteration-1: NegotiationException: " + message );
         }
 
         LOG.info( "first iteration of negotiation is successful" );
         return counterOffer1;
     }
 
     /**
      * @param negotiation
      * @return
      * @throws ResourceUnknownException
      * @throws ResourceUnavailableException
      */
     private SampleAgreementTemplate getNegotiableTemplate( NegotiationClient negotiation )
         throws ResourceUnknownException, ResourceUnavailableException
     {
         //
         // retrieve the agreement templates for which negotiation is supported,
         // and select the one with template name "SAMPLE-TEMPLATE".
         //
         LOG.info( "getting negotiable templates" );
 
         AgreementTemplateType[] negotiableTemplates = negotiation.getNegotiableTemplates();
         assertNotNull( negotiableTemplates );
 
         AgreementTemplateType template = null;
         for ( int i = 0; i < negotiableTemplates.length; i++ )
         {
             AgreementTemplateType agreementTemplate = negotiableTemplates[i];
             LOG.debug( "retrieved template: " + agreementTemplate.getName() + ":"
                 + agreementTemplate.getTemplateId() );
             LOG.trace( agreementTemplate.toString() );
             if ( agreementTemplate.getName().equals( TEMPLATE_NAME ) )
             {
                 template = agreementTemplate;
             }
         }
         assertEquals( TEMPLATE_NAME, template.getName() );
 
         //
         // The "SAMPLE-TEMPLATE" template exposes the current availability of computing resources by a
         // resource provider.
         //
         SampleAgreementTemplate negotiationTemplate = new SampleAgreementTemplate( template );
         if ( LOG.isTraceEnabled() )
         {
             LOG.trace( "negotiation-template: " + negotiationTemplate.getXMLObject().xmlText() );
         }
         return negotiationTemplate;
     }
 
     /**
      * @param factory
      * @param negotiation
      * @return
      */
     private NegotiationClient initiateNegotiation()
     {
         try
         {
             AgreementFactoryClient factory = getAgreementFactoryClient( FACTORY_RESOURCE_ID );
 
             //
             // Now creates a negotiation context that defines the roles and obligations
             // of the negotiating parties and specifies the type of the negotiation process.
             //
             NegotiationContextDocument negContextDoc = NegotiationContextDocument.Factory.newInstance();
             NegotiationContextType negContext = negContextDoc.addNewNegotiationContext();
             negContext.setAgreementFactoryEPR( factory.getRemoteClient().getRemoteReference() );
             negContext.setAgreementResponder( NegotiationRoleType.NEGOTIATION_RESPONDER );
             GregorianCalendar expireDate = new GregorianCalendar();
             expireDate.add( Calendar.HOUR, 1 );
             negContext.setExpirationTime( expireDate );
             //
             // set the nature of the negotiation process (e.g. negotiation or re-negotiation).
             //
             NegotiationType negotiationType = negContext.addNewNegotiationType();
             negotiationType.addNewNegotiation();
             //
             // creating negotiation instance based on a negotiation context from a selected agreement factory
             //
             NegotiationClient negotiation = factory.initiateNegotiation( negContext );
             assertNotNull( "the created negotiatin client is not null", negotiation );
 
             LOG.info( "negotiation instance is created successfully" );
 
             return negotiation;
         }
         catch ( NegotiationFactoryException e )
         {
             fail( "NegotiationFactoryException: " + e.getMessage() );
         }
         catch ( ResourceUnavailableException e )
         {
             fail( "ResourceUnavailableException: " + e.getMessage() );
         }
         catch ( ResourceUnknownException e )
         {
             fail( "ResourceUnknownException: " + e.getMessage() );
         }
         catch ( Exception e )
         {
             fail( "Could not create negotiation client instance. Error: " + e.getMessage() );
         }
 
         throw new RuntimeException( "test case implementation error" );
     }
 
     private void setResourcesSDT( SampleNegotiationOffer negotiationOffer, ResourcesType jobResources )
         throws Exception
     {
 
         ServiceDescriptionTermType resourcesSDT = null;
 
         ServiceDescriptionTermType[] sdts =
             negotiationOffer.getTerms().getAll().getServiceDescriptionTermArray();
 
         if ( sdts != null )
         {
             for ( int i = 0; i < sdts.length; i++ )
             {
                 if ( sdts[i].getName().equals( RESOURCES_SDT_NAME ) )
                 {
                     resourcesSDT = sdts[i];
                     break;
                 }
             }
         }
 
         String name = resourcesSDT.getName();
         String serviceName = resourcesSDT.getServiceName();
 
         JobDefinitionDocument resourcesDoc = JobDefinitionDocument.Factory.newInstance();
         resourcesDoc.addNewJobDefinition().addNewJobDescription().addNewResources();
         resourcesDoc.getJobDefinition().getJobDescription().getResources().set( jobResources );
 
         resourcesSDT.set( resourcesDoc );
         resourcesSDT.setName( name );
         resourcesSDT.setServiceName( serviceName );
     }
 
     private void setTimeConstraintSDT( SampleNegotiationOffer negotiationOffer,
                                        TimeConstraintType timeConstraint )
     {
 
         ServiceDescriptionTermType timeConstraintSDT = null;
 
         ServiceDescriptionTermType[] sdts =
             negotiationOffer.getTerms().getAll().getServiceDescriptionTermArray();
 
         if ( sdts != null )
         {
             for ( int i = 0; i < sdts.length; i++ )
             {
                 if ( sdts[i].getName().equals( TIME_CONSTRAINT_SDT_NAME ) )
                 {
                     timeConstraintSDT = sdts[i];
                     break;
                 }
             }
         }
 
         String name = timeConstraintSDT.getName();
         String serviceName = timeConstraintSDT.getServiceName();
 
         TimeConstraintDocument timeConstraintDoc = TimeConstraintDocument.Factory.newInstance();
         timeConstraintDoc.addNewTimeConstraint();
         timeConstraintDoc.getTimeConstraint().set( timeConstraint );
 
         timeConstraintSDT.set( timeConstraintDoc );
         timeConstraintSDT.setName( name );
         timeConstraintSDT.setServiceName( serviceName );
     }
 
     private NegotiationConstraintSectionType addNeogtiationOfferConstraints( Calendar startTime )
     {
 
         final String constraintItemName = "TimeConstraintSDT_TimeConstraint_START_TIME";
         final String constraintXpath =
             "declare namespace wsag-tc='http://schemas.wsag4j.org/2009/07/wsag4j-scheduling-extensions';"
                 + "declare namespace wsag='http://schemas.ggf.org/graap/2007/03/ws-agreement';"
                 + "$this/wsag:Terms/wsag:All/wsag:ServiceDescriptionTerm[@wsag:Name = 'TIME_CONSTRAINT_SDT']"
                 + "/wsag4jt:TimeConstraint";
 
         NegotiationConstraintSectionType constraints = NegotiationConstraintSectionType.Factory.newInstance();
 
         // add one item constraint
         NegotiationOfferItemType offerItem = constraints.addNewItem();
         offerItem.setName( constraintItemName );
         offerItem.setLocation( constraintXpath );
 
         ItemConstraint constraint = offerItem.addNewItemConstraint();
 
         constraint.addNewMinInclusive().setValue( XmlDateTime.Factory.newValue( startTime ) );
         Calendar preferredEndTime = (Calendar) startTime.clone();
         preferredEndTime.add( Calendar.MINUTE, END_TIME_OFFSET );
         constraint.addNewMaxInclusive().setValue( XmlDateTime.Factory.newValue( preferredEndTime ) );
 
         return constraints;
     }
 }