/*

  * 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.javaflow.utils;

 import java.io.ByteArrayInputStream;

 import java.io.ByteArrayOutputStream;

 import java.io.IOException;

 import java.io.ObjectInputStream;

 import java.io.ObjectOutputStream;

 import java.lang.reflect.Field;

 import java.lang.reflect.Method;

 import java.util.HashMap;

 import java.util.Map;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

 /**

  * @author tcurdt

  *

  */

 public final class ReflectionUtils {

     private final static Log log = LogFactory.getLog(ReflectionUtils.class);

         public interface Matcher {

         boolean matches(final String pName);

     }

     public interface Indexer {

         void put(final Map pMap, final String pKey, final Object pObject);

     }

     private static Indexer defaultIndexer = new DefaultIndexer();

     private static Matcher defaultMatcher = new DefaultMatcher();

     public static class DefaultMatcher implements Matcher {

         public boolean matches(final String pName) {

             return true;

         }

     }

     public static class DefaultIndexer implements Indexer {

         public void put(final Map pMap, final String pKey, final Object pObject) {

             pMap.put(pKey, pObject);

         }

     }

     public static Map discoverFields(

             final Class pClazz,

             final Matcher pMatcher

             ) {

         return discoverFields(pClazz, pMatcher, defaultIndexer);

     }

     public static Map discoverFields(

             final Class pClazz

             ) {

         return discoverFields(pClazz, defaultMatcher, defaultIndexer);

     }

     public static Map discoverFields(

             final Class pClazz,

             final Matcher pMatcher,

             final Indexer pIndexer

             ) {

         log.debug("discovering fields on " + pClazz.getName());

         final Map result = new HashMap();

         Class current = pClazz;

         do {

             final Field[] fields = current.getDeclaredFields();

             for (int i = 0; i < fields.length; i++) {

                 final String fname = fields[i].getName();

                 if (pMatcher.matches(fname)) {

                     pIndexer.put(result, fname, fields[i]);

                     log.debug("discovered field " + fname + " -> " + fields[i]);

                 }

             }

             current = current.getSuperclass();

         } while(current != null);

         return result;

     }    

     public static Map discoverMethods(

             final Class pClazz,

             final Matcher pMatcher

             ) {

         return discoverMethods(pClazz, pMatcher, defaultIndexer);

     }

     public static Map discoverMethods(

             final Class pClazz

             ) {

         return discoverMethods(pClazz, defaultMatcher, defaultIndexer);

     }

     public static Map discoverMethods(

             final Class pClazz,

             final Matcher pMatcher,

             final Indexer pIndexer

             ) {

         log.debug("discovering methods on " + pClazz.getName());

         final Map result = new HashMap();

         Class current = pClazz;

         do {

             final Method[] methods = current.getDeclaredMethods();

             for (int i = 0; i < methods.length; i++) {

                 final String mname = methods[i].getName();

                 if (pMatcher.matches(mname)) {

                     pIndexer.put(result, mname, methods[i]);

                     log.debug("discovered method " + mname + " -> " + methods[i]);

                 }

             }

             current = current.getSuperclass();

         } while(current != null);

         return result;

     }    

     public static Object cast(Object o) throws IOException, ClassNotFoundException {

         final ByteArrayOutputStream buffer = new ByteArrayOutputStream();

         final ObjectOutputStream oos = new ObjectOutputStream(buffer);

         oos.writeObject(o);

         oos.flush();

         final ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(buffer.toByteArray()));

         return ois.readObject();

       }

     public static String getClassName(final Object o) {

         if (o == null) {

             return "unknown";

         }

         return o.getClass().getName() + "@" + o.hashCode();

     }

     public static String getClassLoaderName(final Object o) {

         if (o == null) {

             return "unknown";

         }

         return getClassName(o.getClass().getClassLoader());

     }

 }