/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You under the Apache License, Version 2.0
    * (the "License"); you may not use this file except in compliance with
    * the License.  You may obtain a copy of the License at
    *
    *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.apache.commons.flatfile;
  
  import java.io.InputStream;
  import java.lang.reflect.InvocationHandler;
  import java.lang.reflect.Method;
  import java.lang.reflect.Proxy;
  import java.util.Arrays;
  import java.util.List;
  import java.util.Map;
  import java.util.WeakHashMap;
  
  import org.apache.commons.lang3.ClassUtils;
  
  /**
   * Immutable Entity factory, using Java 1.3 proxies.
   * @version $Revision: 1301232 $ $Date: 2012-03-15 17:03:25 -0500 (Thu, 15 Mar 2012) $
   */
  public class ImmutableEntity {
      private static class ImmutableEntityInvocationHandler implements InvocationHandler {
          // make sure this array stays sorted:
          private static final String[] ALLOWED_VOID = { "readFrom", "writeTo" };
          private static final String CLONE = "clone";
          private static final String EQUALS = "equals";
          private static final String READ_FROM = "readFrom";
          private static final String GET_CHILD = "getChild";
          private static final String GET_VALUE = "getValue";
          private static final String IS_SIZABLE = "isSizable";
          private static final byte[] READ_BUFFER = new byte[1024];
          private static final int BUF_LEN = READ_BUFFER.length;
  
          private Entity delegate;
  
          /**
           * Create a new ImmutableEntityInvocationHandler instance.
           * @param delegate Entity
           */
          private ImmutableEntityInvocationHandler(Entity delegate) {
              this.delegate = delegate;
          }
  
          /**
           * {@inheritDoc}
           */
          // TODO could we simplify/future-proof proxy definition by breaking Entity into smaller interfaces?
          public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
              String name = method.getName();
  
              // check allowed void methods; most would be intended to trigger a
              // change on the target
              if (method.getReturnType() == Void.TYPE && Arrays.binarySearch(ALLOWED_VOID, name) < 0) {
                  return null;
              }
              if (READ_FROM.equals(name)) {
                  InputStream is = (InputStream) args[0];
                  int remaining = delegate.length();
                  while (remaining > 0) {
                      int toread = remaining > BUF_LEN ? BUF_LEN : remaining;
                      int read = is.read(READ_BUFFER, 0, toread);
                      if (read < 0) {
                          break;
                      }
                      remaining -= read;
                  }
                  return null;
              }
              if (CLONE.equals(name)) {
                  // it should be safe to return the proxy itself as the clone of
                  // an IMMUTABLE entity
                  return proxy;
              }
              if (EQUALS.equals(name)) {
                  return Boolean.valueOf(proxy == args[0]);
              }
              if (IS_SIZABLE.equals(name)) {
                  return Boolean.FALSE;
              }
              Object result = method.invoke(delegate, args);
              if (GET_CHILD.equals(name)) { // return immutable children
                  result = of((Entity) result);
              }
              // if delegate returns same result 2x, that indicates it's the true
              // buffer, which we protect by copying:
              if (GET_VALUE.equals(name)) {
                 byte[] test = (byte[]) method.invoke(delegate, args);
                 if (result == test) {
                     result = new byte[test.length];
                     System.arraycopy(test, 0, (byte[]) result, 0, test.length);
                 }
             }
             return result;
         }
     }
 
     private static final Map<Entity, Entity> PROXIES = new WeakHashMap<Entity, Entity>();
 
     /**
      * Create a new ImmutableEntity instance.
      */
     private ImmutableEntity() {
     }
 
     /**
      * Get an immutable instance of <code>e</code>.
      * @param e Entity delegate
      * @return immutable Entity
      */
     public static Entity of(Entity e) {
         Entity result = PROXIES.get(e);
         if (result == null) {
             result = (Entity) Proxy.newProxyInstance(e.getClass().getClassLoader(),
                     getInterfaces(e), new ImmutableEntityInvocationHandler(e));
             PROXIES.put(e, result);
         }
         return result;
     }
 
     /**
      * Get the interfaces implemented by <code>o</code>.
      * @param o to inspect.
      * @return interface array
      */
     private static Class<?>[] getInterfaces(Object o) {
         final List<Class<?>> interfaces = ClassUtils.getAllInterfaces(o.getClass());
         return interfaces.toArray(new Class[interfaces.size()]);
     }
 }