/* 
    * 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.samples.actions;
  
  import java.io.ByteArrayInputStream;
  import java.io.ByteArrayOutputStream;
  import java.text.MessageFormat;
  import java.util.Calendar;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  
  import org.apache.log4j.Logger;
  import org.apache.xmlbeans.GDate;
  import org.apache.xmlbeans.XmlObject;
  import org.apache.xmlbeans.XmlOptions;
  import org.ogf.graap.wsag.server.actions.AbstractGetTemplateAction;
  import org.ogf.graap.wsag.server.actions.ActionInitializationException;
  import org.ogf.graap.wsag.server.actions.impl.FileTemplate;
  import org.ogf.graap.wsag4j.types.configuration.FileTemplateConfigurationDocument;
  import org.ogf.graap.wsag4j.types.configuration.FileTemplateConfigurationType;
  import org.ogf.graap.wsag4j.types.configuration.ImplementationConfigurationType;
  import org.ogf.schemas.graap.wsAgreement.AgreementTemplateType;
  
  /**
   * SampleGetTemplateAction
   * 
   * @author hrasheed
   * 
   */
  public class SampleGetTemplateAction extends AbstractGetTemplateAction
  {
  
      /**
       * 
       */
      private static final int ENDTIME_OFFSET = 60;
  
      private static final Logger LOG = Logger.getLogger( SampleGetTemplateAction.class );
  
      private FileTemplate fileTemplate = null;
  
      private String templateFilename = "";
  
      private Map<String, Object> templateParameters = new HashMap<String, Object>();
  
      private AgreementTemplateType template;
  
      /**
       * {@inheritDoc}
       */
      public void initialize() throws ActionInitializationException
      {
  
          try
          {
              // START SNIPPET: DynamicTemplateGeneration0
              ImplementationConfigurationType handlerConfiguration =
                  getHandlerContext().getHandlerConfiguration();
              XmlObject[] children =
                  handlerConfiguration.selectChildren( FileTemplateConfigurationDocument.type.getDocumentElementName() );
              // END SNIPPET: DynamicTemplateGeneration0
  
              if ( children.length != 1 )
              {
                  String error =
                      "Invalid configuration for action $1. Expected one configuration section of type $1, but found $3";
                 String message =
                     error + getClass().getName()
                         + FileTemplateConfigurationDocument.type.getDocumentElementName().toString()
                         + Integer.toString( children.length );
                 LOG.error( message );
                 throw new ActionInitializationException( message );
             }
             // START SNIPPET: DynamicTemplateGeneration1
             FileTemplateConfigurationType config = (FileTemplateConfigurationType) children[0];
             setTemplateFilename( config.getFilename() );
             fileTemplate = new FileTemplate( getTemplateFilename() );
             // END SNIPPET: DynamicTemplateGeneration1
 
             Map<String, Object> parameters = getTemplateParameters();
             Iterator<String> keys = parameters.keySet().iterator();
 
             while ( keys.hasNext() )
             {
                 try
                 {
                     String key = keys.next();
                     fileTemplate.addParameter( key, parameters.get( key ) );
                 }
                 catch ( ClassCastException e )
                 {
                     LOG.error( "Invalid template parameter. Key value must be of type String." );
                 }
             }
             // START SNIPPET: DynamicTemplateGeneration2
             double totalResources = 10;
             fileTemplate.addParameter( "TOTALRESOURCES", totalResources );
             // END SNIPPET: DynamicTemplateGeneration2
 
             Calendar startTime = Calendar.getInstance();
             startTime.set( Calendar.SECOND, 0 );
             startTime.set( Calendar.MILLISECOND, 0 );
             Calendar endTime = (Calendar) startTime.clone();
             endTime.add( Calendar.MINUTE, ENDTIME_OFFSET );
 
             fileTemplate.addParameter( "STARTTIME", new GDate( startTime ) );
 
             fileTemplate.addParameter( "ENDTIME", new GDate( endTime ) );
 
             fileTemplate.addParameter( "DURATION", "60" );
 
             ByteArrayOutputStream out = new ByteArrayOutputStream();
             fileTemplate.processTemplate( out );
             ByteArrayInputStream in = new ByteArrayInputStream( out.toByteArray() );
 
             template =
                 AgreementTemplateType.Factory.parse( in,
                                                      new XmlOptions().setLoadReplaceDocumentElement( null ) );
 
         }
         catch ( Exception e )
         {
             e.printStackTrace();
             Object[] filler = new Object[] { e.getMessage() };
             String message = MessageFormat.format( "Error creating sample-template. Reason: {0}", filler );
             LOG.error( message );
             throw new ActionInitializationException( message );
         }
     }
 
     /**
      * {@inheritDoc}
      */
     public AgreementTemplateType getTemplate()
     {
         return template;
     }
 
     /**
      * 
      * @return the template filename
      */
     public String getTemplateFilename()
     {
         return templateFilename;
     }
 
     /**
      * 
      * @param templateFilename
      *            the template filename
      */
     public void setTemplateFilename( String templateFilename )
     {
         this.templateFilename = templateFilename;
     }
 
     /**
      * @return returns a map with the template parameters used for template creation
      */
     protected Map<String, Object> getTemplateParameters()
     {
         return templateParameters;
     }
 }