/*
    * Version 1.0 based on Apache Software License 1.1
    *
    * Copyright (C) 2005 Rob Manning
    * manningr@users.sourceforge.net
    *
    * 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 following disclaimer.
   *
   * 2. 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.
   *
   * 3. The end-user documentation included with the redistribution, if any,
   *    must include the following acknowledgment:
   *
   *    "This product includes software developed by DBMonster developers
   *    (http://dbmonster.kernelpanic.pl/)."
   *
   *  Alternately, this acknowledgment may appear in the software itself,
   *  if and wherever such third-party acknowledgments normally appear.
   *
   * 4. The name "DBMonster" must not be used to endorse or promote products
   *    derived from this software without prior written permission. For
   *    written permission, please contact pm@jcake.com.
   *
   * 5. Products derived from this software may not be called "DBMonster",
   *    nor may "DBMonster" appear in their name, without prior written
   *    permission of Piotr Maj.
   *
   * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED 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 DBMONSTER DEVELOPERS 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 pl.kernelpanic.dbmonster.generator;
  
  import java.io.ByteArrayOutputStream;
  import java.io.DataInputStream;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.Random;
  
  import org.apache.commons.logging.Log;
  
  import pl.kernelpanic.dbmonster.DBMonster;
  import pl.kernelpanic.dbmonster.DBMonsterContext;
  
  public class BinaryGenerator extends BasicDataGenerator implements Initializable {
  
      /*** pointer into the fileList to keep track of which file to use next */
      private int currentIndex = -1;
      
      /*** holds the list of files that are used to populate binary columns */
      private ArrayList fileList = new ArrayList();
      
      /*** Random number generator. */
      private Random random = null;
      
      /*** logger for this class */
      private Log log = null;
      
      /*** the maximum length of any column */
      private int maxLength = 0;
      /***
       * Initializes a class with <code>DBMonsterContext</code>.
       *
       * @param ctx context
       *
       * @throws Exception if initialization fails
       */    
      public void initialize(DBMonsterContext ctx) 
          throws Exception
      {
          random = (Random) ctx.getProperty(DBMonster.RANDOM_KEY);
          log = (Log) ctx.getProperty(DBMonster.LOGGER_KEY);
      }
      
      /***
       * Generates byte[] from the next file in our list of configured files.
       *
       * @return value.
       */    
      public Object generate() throws Exception {
          if (nulls != 0 && random.nextInt(101) <= nulls) {
              return null;
         }
 
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
         DataInputStream is = null;
         String filename = (String)fileList.get(getNextIndex());
         try {
             File f = new File(filename);
             is = new DataInputStream(new FileInputStream(f));
             byte[] buffer = new byte[8192];
             int result = is.read(buffer);
             int bytesWritten = result;
             while (result != -1) {
                 baos.write(buffer);
                 result = is.read(buffer);
                 bytesWritten += result;
             }
             if (log.isDebugEnabled()) {
                 StringBuffer sb = new StringBuffer();
                 sb.append("generate: bytesWritten=");
                 sb.append(bytesWritten);
                 sb.append(" for file=");
                 sb.append(filename);
                 log.debug(sb.toString());
             }
         } catch (IOException e) {
             log.error("Unable to build inputstream for input file="+filename, e);
         } finally {
             if (is != null) try { is.close(); } catch (IOException e) {}
         }
         byte[] result = baos.toByteArray();
         // shrink the array if it exceeds the maxLength 
         if (maxLength > 0 && result.length > maxLength) {
             byte[] newresult = new byte[maxLength];
             for (int i = 0; i < maxLength; i++) {
                 newresult[i] = result[i];
             }
             result = newresult;
         }
         return result;
     }
     
     public void reset() {
         currentIndex = 0;
     }
 
     /***
      * Sets a filename containing content to be used as a field value in the 
      * database.
      * 
      * @param value the absolute path to a file that will be read in and stored
      *              in a table column. 
      */
     public void setFile(String value) {
         fileList.add(value);
     }
     
     /***
      * Returns the maximal length of the string.
      *
      * @return the maximal value of generated string
      */
     public int getMaxLength() {
         return maxLength;
     }
 
     /***
      * Sets the maximal length of the string.
      *
      * @param length maximal length
      */
     public void setMaxLength(int length) {
         maxLength = length;
     }
 
     /***
      * Loop around to 0 if we've reached the end of the list.
      * @return
      */
     private int getNextIndex() {
         currentIndex++;
         if (currentIndex >= fileList.size()) {
             currentIndex = 0;
         }
         return currentIndex;
     }
 }