/*
    * Copyright (c) 2004 International Decision Systems, Inc.  All Rights Reserved.
    *
    * By using this Software, You acknowledge that the Software is a valuable asset
    * and trade secret of either International Decision Systems, Inc. ("IDSI") or a
    * third party supplier of IDSI and constitutes confidential and proprietary
    * information.
    *
    * NEITHER IDSI NOR ANY AGENT OR PERSON ACTING FOR OR WITH IDSI HAS MADE OR DOES
   * MAKE ANY STATEMENTS, AFFIRMATIONS, REPRESENTATIONS OR WARRANTIES WHATSOEVER
   * TO YOU, WHETHER EXPRESS OR IMPLIED, AS TO THE SOFTWARE, THE QUALITY OR
   * CONDITION OF THE SOFTWARE, OR THE OPERATING CHARACTERISTICS OR RELIABILITY OF
   * THE SOFTWARE, OR ITS SUITABILITY FOR ANY GENERAL OR PARTICULAR PURPOSE, OR AS
   * TO ANY OTHER MATTER WHATSOEVER; ANY AND ALL OTHER WARRANTIES INCLUDING
   * WITHOUT LIMITATION ANY WARRANTIES IMPLIED BY LAW, SUCH AS THE IMPLIED
   * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND TITLE,
   * USE AND NON-INFRINGEMENT; ARE HEREBY EXPRESSLY DISCLAIMED AND EXCLUDED.
  */
  package net.sourceforge.addam.impexp;
  
  import org.apache.commons.codec.binary.Base64;
  import org.apache.tools.ant.BuildException;
  
  import java.lang.reflect.Constructor;
  import java.lang.reflect.Method;
  import java.util.HashMap;
  import java.util.Map;
  import java.sql.Blob;
  import java.sql.SQLException;
  import java.io.InputStream;
  
  /**
   * This class defines the codec standard used for data import/export.
   * The implementations are private.
   *
   * @author TIM3
   * @since Feb 17, 2005 12:47:30 PM
   */
  public abstract class DataCodec {
  
      abstract public String encode(Object o);
  
      abstract public Object decode(String s);
  
      static final Map decoders = new HashMap();
  
      static DataCodec getCodec(String className) throws NoSuchCodec {
          DataCodec decoder = (DataCodec) decoders.get(className);
          final Class STRINGPARAM[] = {java.lang.String.class};
          if (decoder == null) {
              // prefer standard java timestamp
              if (className.equals("oracle.sql.TIMESTAMP")) {
                  className = "java.sql.Timestamp";
              }
              if (className.equals("byte[]")) {
                  return new ByteArrayCodec();
              } else if (className.equals("oracle.sql.BLOB")) {
                  return new BlobCodec();
              } else  if (className.equals("java.sql.Blob")) {
                  return new BlobCodec();
              } else {
                  Class theClass = null;
                  Constructor constructor = null;
                  Method valueOfMethod = null;
  
                  try {
                      theClass = Class.forName(className);
                  } catch (ClassNotFoundException e) {
                      throw new NoSuchCodec(className);
                  }
  
                  try {
                      constructor = theClass.getConstructor(STRINGPARAM);
                  } catch (NoSuchMethodException e) {
                      // ignore constructor exception, try for static valueOf
                  }
  
                  if (constructor == null) {
                      try {
                          valueOfMethod = theClass.getMethod("valueOf", STRINGPARAM);
                      } catch (NoSuchMethodException e) {
                          throw new NoSuchCodec(className);
                      }
                      decoder = new StandardCodec(valueOfMethod);
                  } else {
                      decoder = new StandardCodec(constructor);
                  }
              }
          }
          return decoder;
      }
  
      // uses Base64 encoding to encode/decode a byte array
      static class BlobCodec extends DataCodec {
  
          public String encode(Object o) {
              Blob b = (Blob)o;
              String result;
              try {
                 if (b.length() > (1024*1024)) {
                     throw new BuildException("Blob is larger than 1 meg");
                 }
                 byte byteBuf[] = new byte[(int)b.length()];
                 InputStream s = b.getBinaryStream();
                 s.read(byteBuf);
                 byte[] encodedBytes = Base64.encodeBase64(byteBuf);
                 result = new String(encodedBytes);
             } catch (Exception e) {
                 throw new BuildException(e);
             }
             return result;
         }
 
         public Object decode(String s) {
             byte[] decodedBytes = Base64.decodeBase64(s.getBytes());
             return decodedBytes;
         }
     }
 
     // uses Base64 encoding to encode/decode a byte array
     static class ByteArrayCodec extends DataCodec {
 
         public String encode(Object o) {
             byte[] encodedBytes = Base64.encodeBase64((byte[]) o);
             return new String(encodedBytes);
         }
 
         public Object decode(String s) {
             byte[] decodedBytes = Base64.decodeBase64(s.getBytes());
             return decodedBytes;
         }
     }
 
     // relies on a static valueOf() and instance "toString()" methods
     static class StandardCodec extends DataCodec {
 
         final Constructor constructor;
         final Method valueOfMethod;
 
         StandardCodec(Constructor constructor) {
             this.constructor = constructor;
             this.valueOfMethod = null;
         }
 
         StandardCodec(Method valueOfMethod) {
             this.valueOfMethod = valueOfMethod;
             this.constructor = null;
         }
 
         public String encode(Object o) {
             return o == null ? "" : o.toString();
         }
 
         public Object decode(String s) {
             Object result = null;
 
             // return null for empty strings
             if (s != null && s.length() > 0) {
                 Object args[] = {s};
                 try {
                     if (constructor != null) {
                         // try the constructor
                         result = constructor.newInstance(args);
                     } else if (valueOfMethod != null) {
                         // when invoking static method, use null for the object
                         result = valueOfMethod.invoke(null, args);
                     } else {
                         // probably a clob... not much we can do but return the string
                         result = s;
                     }
                 } catch (Exception e) {
                     e.printStackTrace();
                     throw new BuildException(e);
                 }
             }
 
             return result;
         }
 
 
     }
 
     static class NoSuchCodec extends Exception {
         NoSuchCodec(String className) {
             super("no decoder for class " + className + " could be found");
         }
     }
 }