/*
    * Copyright (c) 2004, RV Test Team
    * All rights reserved.
    *
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions are met:
    *
    * Redistributions of source code must retain the above copyright notice, this
    * list of conditions and the following disclaimer.
   *
   * 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.
   *
   * Neither the name of the "RV Test Team" nor the names of its contributors may
   * be used to endorse or promote products derived from this software without
   * specific prior written permission.
   *
   * 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.
   *
   */
  /*
   * Copyright (c) 2002, Reuters All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions are met:
   *
   * Redistributions of source code must retain the above copyright notice, this
   * list of conditions and the following disclaimer. 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. Neither the name of the Reuters nor the names of its
   * contributors may be used to endorse or promote products derived from this
   * software without specific prior written permission.
   *
   * 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 com.reuters.msgtest.load;
  
  import com.reuters.msgtest.RvRecorder;
  import com.reuters.msgtest.RvTestCase;
  import com.reuters.msgtest.RvTestException;
  import com.reuters.msgtest.fixture.Response;
  import com.reuters.msgtest.fixture.Stimuli;
  import com.reuters.msgtest.fixture.Stimulus;
  import com.reuters.msgtest.load.config.KeyField;
  import com.reuters.msgtest.load.config.LoadStimulus;
  import com.reuters.msgtest.load.config.LoadTestFixture;
  import com.reuters.msgtest.load.output.LoadTestOutput;
  import com.reuters.msgtest.load.value.IntRangeValueGenerator;
  import com.reuters.msgtest.load.value.ValueGenerator;
  import com.reuters.msgtest.load.value.ValueSet;
  import com.tibco.tibrv.TibrvException;
  import com.tibco.tibrv.TibrvMsg;
  import com.tibco.tibrv.TibrvTransport;
  import java.io.BufferedWriter;
  import java.io.File;
  import java.io.FileWriter;
  import java.io.IOException;
  import java.io.Writer;
  import java.lang.reflect.Constructor;
  import java.lang.reflect.InvocationTargetException;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Random;
  
  
  public abstract class LoadTest extends RvTestCase {
      public static final Random RANDOM = new Random(System.currentTimeMillis());
      public final TibrvMsg NULL_TIBRV_MESSAGE = new TibrvMsg();
      protected TibrvMsgFieldMutator fieldMutator = new TibrvMsgFieldMutator();
      protected LoadTestResults loadTestResults;
      private LoadTestFixture loadTestFixture;
      private RvRecorder recorder;
  
      public LoadTest(String name, File file) {
          super(name);
         setLoadTestFixture(new LoadTestFixture(getRvTestConfiguration(), file));
         setLoadTestResults(new LoadTestResults(getLoadTestFixture()
                                                    .getLoadTestConfig().getName()));
     }
 
     public void testLoad() throws Exception {
         assertNotNull("Load Test Result Object has to be instantiated",
             getLoadTestResults());
         startRecording();
         processStimuli();
         getResponses();
         printResults();
     }
 
     abstract public void getResponses() throws RvTestException;
 
     abstract public void processStimuli() throws RvTestException;
 
     public void startRecording() throws TibrvException {
         setRecorder(new RvRecorder(getRvTestConfiguration().getTransport()));
         getRecorder().start();
 
         for (Iterator iter = getLoadTestFixture().getResponses().iterator();
                 iter.hasNext();) {
             Response response = (Response) iter.next();
             String subject = response.getTibrvMsg().getSendSubject();
             assertNotNull(subject);
             recorder.record(subject);
         }
     }
 
     public Writer createResultFileWriter() throws RvTestException {
         String outputFileName = getLoadTestFixture().getLoadTestConfig()
                                     .getOutputFileName();
 
         if ((outputFileName == null) || (outputFileName.length() < 1)) {
             outputFileName = "output.txt";
         }
 
         try {
             return new BufferedWriter(new FileWriter(new File(outputFileName),
                     true));
         } catch (IOException e) {
             throw new RvTestException("Could not create output file", e);
         }
     }
 
     public LoadTestFixture getLoadTestFixture() {
         return loadTestFixture;
     }
 
     public void setLoadTestFixture(LoadTestFixture loadTestFixture) {
         this.loadTestFixture = loadTestFixture;
     }
 
     public RvRecorder getRecorder() {
         return recorder;
     }
 
     public void setRecorder(RvRecorder recorder) {
         this.recorder = recorder;
     }
 
     public LoadTestResults getLoadTestResults() {
         return loadTestResults;
     }
 
     public void setLoadTestResults(LoadTestResults loadTestResults) {
         this.loadTestResults = loadTestResults;
     }
 
     protected TibrvTransport getTibrvTransport() throws RvTestException {
         try {
             return getRvTestConfiguration().getTransport().getRvdTransport();
         } catch (TibrvException e) {
             throw new RvTestException("Could not aquire transport object.", e);
         }
     }
 
     protected ValueGenerator createValueGenerator(LoadStimulus loadStimulus) {
         // TODO: we are directly referencing index, 
         ValueSet valueSet = (ValueSet) loadStimulus.getValueSetList().get(0);
 
         // TODO: make sure other types (besides Integer Range) are implemented
         IntRangeValueGenerator valueGenerator = new IntRangeValueGenerator(valueSet);
 
         return valueGenerator;
     }
 
     protected TibrvMsg getStimuliMessage() {
         Stimuli stimuli = getLoadTestFixture().getStimuli();
 
         //TODO directly referncing Stimulus using index
         Stimulus stimulus = stimuli.getStimulus(0);
         TibrvMsg templateMessage = stimulus.getMsg();
 
         return templateMessage;
     }
 
     protected void modifyMessageFields(TibrvMsg msg, List keyFields,
         ValueGenerator valueGenerator) throws RvTestException {
         if (keyFields == null) {
             return;
         }
 
         for (Iterator iter = keyFields.iterator(); iter.hasNext();) {
             KeyField fieldToModify = (KeyField) iter.next();
             String value = valueGenerator.getCurrentValue(fieldToModify.getFillpattern());
             fieldMutator.updateField(msg, fieldToModify.getName(), value);
         }
     }
 
     protected List createMessagesToSend(final TibrvMsg templateMessage,
         LoadStimulus loadStimulus) throws RvTestException {
         ValueGenerator valueGenerator = createValueGenerator(loadStimulus);
         List messages = new LinkedList();
         List keyFields = loadStimulus.getKeyFieldList();
 
         for (int i = 0; i < loadStimulus.getNumberOfMsgs(); i++) {
             try {
                 TibrvMsg msg = new TibrvMsg(templateMessage);
                 modifyMessageFields(msg, keyFields, valueGenerator);
                 messages.add(msg);
             } catch (TibrvException e) {
                 throw new RvTestException("Could prepare messages to send.", e);
             }
 
             valueGenerator.changeValue();
         }
 
         return messages;
     }
 
     public void printResults() throws RvTestException {
         String outputterClassName = getLoadTestFixture().getLoadTestConfig()
                                         .getOutputPrinter();
         LoadTestOutput outputter = createPrinterObj(outputterClassName);
         outputter.outputResults(loadTestResults, createResultFileWriter());
     }
 
     protected void setSendSubject(TibrvMsg message, String subjectToSend)
         throws RvTestException {
         try {
             message.setSendSubject(subjectToSend);
         } catch (TibrvException e) {
             throw new RvTestException("Could not set message send subject.", e);
         }
     }
 
     protected void delay(int delayTime) {
         if (delayTime > 0) {
             try {
                 Thread.sleep(delayTime);
             } catch (InterruptedException e) {
             }
         }
     }
 
     protected LoadTestOutput createPrinterObj(String outputterName)
         throws RvTestException {
         try {
             Class clazz = CustomStimuliLoadTestCase.class.getClassLoader()
                                                          .loadClass(outputterName);
             Constructor constructor = clazz.getDeclaredConstructor(new Class[] {  });
 
             return (LoadTestOutput) constructor.newInstance(new Object[] {  });
         } catch (ClassNotFoundException e) {
             throw new RvTestException("Could not load a class " +
                 outputterName, e);
         } catch (NoSuchMethodException e) {
             throw new RvTestException("Error printing load test results.", e);
         } catch (IllegalArgumentException e) {
             throw new RvTestException("Error printing load test results.", e);
         } catch (InstantiationException e) {
             throw new RvTestException("Error printing load test results.", e);
         } catch (IllegalAccessException e) {
             throw new RvTestException("Error printing load test results.", e);
         } catch (InvocationTargetException e) {
             throw new RvTestException("Error printing load test results.", e);
         }
     }
 }