/*

  * 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()]);

     }

 }