/*

 * Copyright 2005-2008 Sun Microsystems, Inc.  All Rights Reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package com.sun.jmx.mbeanserver;

import static com.sun.jmx.mbeanserver.Util.*;

import static com.sun.jmx.mbeanserver.MXBeanIntrospector.typeName;

import static javax.management.openmbean.SimpleType.*;

import com.sun.jmx.remote.util.EnvHelp;

import java.beans.ConstructorProperties;

import java.io.InvalidObjectException;

import java.lang.annotation.ElementType;

import java.lang.ref.WeakReference;

import java.lang.reflect.Array;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.GenericArrayType;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

import java.lang.reflect.ParameterizedType;

import java.lang.reflect.Proxy;

import java.lang.reflect.Type;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.BitSet;

import java.util.Collection;

import java.util.Comparator;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.SortedMap;

import java.util.SortedSet;

import java.util.TreeSet;

import java.util.WeakHashMap;

import javax.management.JMX;

import javax.management.ObjectName;

import javax.management.openmbean.ArrayType;

import javax.management.openmbean.CompositeData;

import javax.management.openmbean.CompositeDataInvocationHandler;

import javax.management.openmbean.CompositeDataSupport;

import javax.management.openmbean.CompositeDataView;

import javax.management.openmbean.CompositeType;

import javax.management.openmbean.OpenDataException;

import javax.management.openmbean.OpenType;

import javax.management.openmbean.SimpleType;

import javax.management.openmbean.TabularData;

import javax.management.openmbean.TabularDataSupport;

import javax.management.openmbean.TabularType;

/**

 *   <p>A converter between Java types and the limited set of classes

 *   defined by Open MBeans.</p>

 *

 *   <p>A Java type is an instance of java.lang.reflect.Type.  For our

 *   purposes, it is either a Class, such as String.class or int.class;

 *   or a ParameterizedType, such as List<String> or Map<Integer,

 *   String[]>.  On J2SE 1.4 and earlier, it can only be a Class.</p>

 *

 *   <p>Each Type is associated with an DefaultMXBeanMappingFactory.  The

 *   DefaultMXBeanMappingFactory defines an OpenType corresponding to the Type, plus a

 *   Java class corresponding to the OpenType.  For example:</p>

 *

 *   <pre>

 *   Type                     Open class     OpenType

 *   ----                     ----------     --------

 *   Integer                Integer        SimpleType.INTEGER

 *   int                            int            SimpleType.INTEGER

 *   Integer[]              Integer[]      ArrayType(1, SimpleType.INTEGER)

 *   int[]                  Integer[]      ArrayType(SimpleType.INTEGER, true)

 *   String[][]             String[][]     ArrayType(2, SimpleType.STRING)

 *   List<String>                   String[]       ArrayType(1, SimpleType.STRING)

 *   ThreadState (an Enum)    String         SimpleType.STRING

 *   Map<Integer, String[]>   TabularData          TabularType(

 *                                           CompositeType(

 *                                             {"key", SimpleType.INTEGER},

 *                                             {"value",

 *                                               ArrayType(1,

 *                                                SimpleType.STRING)}),

 *                                           indexNames={"key"})

 *   </pre>

 *

 *   <p>Apart from simple types, arrays, and collections, Java types are

 *   converted through introspection into CompositeType.  The Java type

 *   must have at least one getter (method such as "int getSize()" or

 *   "boolean isBig()"), and we must be able to deduce how to

 *   reconstruct an instance of the Java class from the values of the

 *   getters using one of various heuristics.</p>

 *

 * @since 1.6

 */

public class DefaultMXBeanMappingFactory extends MXBeanMappingFactory {

    static abstract class NonNullMXBeanMapping extends MXBeanMapping {

        NonNullMXBeanMapping(Type javaType, OpenType<?> openType) {

            super(javaType, openType);

        }

        @Override

        public final Object fromOpenValue(Object openValue)

        throws InvalidObjectException {

            if (openValue == null)

                return null;

            else

                return fromNonNullOpenValue(openValue);

        }

        @Override

        public final Object toOpenValue(Object javaValue) throws OpenDataException {

            if (javaValue == null)

                return null;

            else

                return toNonNullOpenValue(javaValue);

        }

        abstract Object fromNonNullOpenValue(Object openValue)

        throws InvalidObjectException;

        abstract Object toNonNullOpenValue(Object javaValue)

        throws OpenDataException;

        /**

         * <p>True if and only if this MXBeanMapping's toOpenValue and

         * fromOpenValue methods are the identity function.</p>

         */

        boolean isIdentity() {

            return false;

        }

    }

    static boolean isIdentity(MXBeanMapping mapping) {

        return (mapping instanceof NonNullMXBeanMapping &&

                ((NonNullMXBeanMapping) mapping).isIdentity());

    }

    private static final class Mappings

        extends WeakHashMap<Type, WeakReference<MXBeanMapping>> {}

        WeakReference<MXBeanMapping> wr = mappings.get(type);

        return (wr == null) ? null : wr.get();

    }

        WeakReference<MXBeanMapping> wr =

            new WeakReference<MXBeanMapping>(mapping);

        mappings.put(type, wr);

    }

    static {

        /* Set up the mappings for Java types that map to SimpleType.  */

        final OpenType<?>[] simpleTypes = {

            BIGDECIMAL, BIGINTEGER, BOOLEAN, BYTE, CHARACTER, DATE,

            DOUBLE, FLOAT, INTEGER, LONG, OBJECTNAME, SHORT, STRING,

            VOID,

        };

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

            final OpenType<?> t = simpleTypes[i];

            Class<?> c;

            try {

                c = Class.forName(t.getClassName(), false,

                                  ObjectName.class.getClassLoader());

            } catch (ClassNotFoundException e) {

                // the classes that these predefined types declare must exist!

                throw new Error(e);

            }

            final MXBeanMapping mapping = new IdentityMapping(c, t);

            if (c.getName().startsWith("java.lang.")) {

                try {

                    final Field typeField = c.getField("TYPE");

                    final Class<?> primitiveType = (Class<?>) typeField.get(null);

                    final MXBeanMapping primitiveMapping =

                        new IdentityMapping(primitiveType, t);

                    if (primitiveType != void.class) {

                        final Class<?> primitiveArrayType =

                            Array.newInstance(primitiveType, 0).getClass();

                        final OpenType<?> primitiveArrayOpenType =

                            ArrayType.getPrimitiveArrayType(primitiveArrayType);

                        final MXBeanMapping primitiveArrayMapping =

                            new IdentityMapping(primitiveArrayType,

                                                primitiveArrayOpenType);

                    }

                } catch (NoSuchFieldException e) {

                    // OK: must not be a primitive wrapper

                } catch (IllegalAccessException e) {

                    // Should not reach here

                    assert(false);

                }

            }

        }

    }

    /** Get the converter for the given Java type, creating it if necessary. */

    @Override

    public synchronized MXBeanMapping mappingForType(Type objType,

                                                     MXBeanMappingFactory factory)

            throws OpenDataException {

        if (inProgress.containsKey(objType)) {

            throw new OpenDataException(

                    "Recursive data structure, including " + typeName(objType));

        }

        MXBeanMapping mapping;

        if (mapping != null)

            return mapping;

        inProgress.put(objType, objType);

        try {

            mapping = makeMapping(objType, factory);

        } catch (OpenDataException e) {

            throw openDataException("Cannot convert type: " + typeName(objType), e);

        } finally {

            inProgress.remove(objType);

        }

        return mapping;

    }

    private MXBeanMapping makeMapping(Type objType, MXBeanMappingFactory factory)

    throws OpenDataException {

        /* It's not yet worth formalizing these tests by having for example

           an array of factory classes, each of which says whether it

           recognizes the Type (Chain of Responsibility pattern).  */

        if (objType instanceof GenericArrayType) {

            Type componentType =

                ((GenericArrayType) objType).getGenericComponentType();

            return makeArrayOrCollectionMapping(objType, componentType, factory);

        } else if (objType instanceof Class<?>) {

            Class<?> objClass = (Class<?>) objType;

            if (objClass.isEnum()) {

                // Huge hack to avoid compiler warnings here.  The ElementType

                // parameter is ignored but allows us to obtain a type variable

                // T that matches <T extends Enum<T>>.

                return makeEnumMapping((Class<?>) objClass, ElementType.class);

            } else if (objClass.isArray()) {

                Type componentType = objClass.getComponentType();

                return makeArrayOrCollectionMapping(objClass, componentType,

                        factory);

            } else if (JMX.isMXBeanInterface(objClass)) {

                return makeMXBeanRefMapping(objClass);

            } else {

                return makeCompositeMapping(objClass, factory);

            }

        } else if (objType instanceof ParameterizedType) {

            return makeParameterizedTypeMapping((ParameterizedType) objType,

                                                factory);

        } else

            throw new OpenDataException("Cannot map type: " + objType);

    }

    private static <T extends Enum<T>> MXBeanMapping

            makeEnumMapping(Class<?> enumClass, Class<T> fake) {

        return new EnumMapping<T>(Util.<Class<T>>cast(enumClass));

    }

    /* Make the converter for an array type, or a collection such as

     * List<String> or Set<Integer>.  We never see one-dimensional

     * primitive arrays (e.g. int[]) here because they use the identity

     * converter and are registered as such in the static initializer.

     */

    private MXBeanMapping

        makeArrayOrCollectionMapping(Type collectionType, Type elementType,

                                     MXBeanMappingFactory factory)

            throws OpenDataException {

        final MXBeanMapping elementMapping = factory.mappingForType(elementType, factory);

        final OpenType<?> elementOpenType = elementMapping.getOpenType();

        final ArrayType<?> openType = ArrayType.getArrayType(elementOpenType);

        final Class<?> elementOpenClass = elementMapping.getOpenClass();

        final Class<?> openArrayClass;

        final String openArrayClassName;

        if (elementOpenClass.isArray())

            openArrayClassName = "[" + elementOpenClass.getName();

        else

            openArrayClassName = "[L" + elementOpenClass.getName() + ";";

        try {

            openArrayClass = Class.forName(openArrayClassName);

        } catch (ClassNotFoundException e) {

            throw openDataException("Cannot obtain array class", e);

        }

        if (collectionType instanceof ParameterizedType) {

            return new CollectionMapping(collectionType,

                                         openType, openArrayClass,

                                         elementMapping);

        } else {

            if (isIdentity(elementMapping)) {

                return new IdentityMapping(collectionType,

                                           openType);

            } else {

                return new ArrayMapping(collectionType,

                                          openType,

                                          openArrayClass,

                                          elementMapping);

            }

        }

    }

    private static final String[] keyArray = {"key"};

    private static final String[] keyValueArray = {"key", "value"};

    private MXBeanMapping

        makeTabularMapping(Type objType, boolean sortedMap,

                           Type keyType, Type valueType,

                           MXBeanMappingFactory factory)

            throws OpenDataException {

        final String objTypeName = typeName(objType);

        final MXBeanMapping keyMapping = factory.mappingForType(keyType, factory);

        final MXBeanMapping valueMapping = factory.mappingForType(valueType, factory);

        final OpenType<?> keyOpenType = keyMapping.getOpenType();

        final OpenType<?> valueOpenType = valueMapping.getOpenType();

        final CompositeType rowType =

            new CompositeType(objTypeName,

                              objTypeName,

                              keyValueArray,

                              keyValueArray,

                              new OpenType<?>[] {keyOpenType, valueOpenType});

        final TabularType tabularType =

            new TabularType(objTypeName, objTypeName, rowType, keyArray);

        return new TabularMapping(objType, sortedMap, tabularType,

                                    keyMapping, valueMapping);

    }

    /* We know how to translate List<E>, Set<E>, SortedSet<E>,

       Map<K,V>, SortedMap<K,V>, and that's it.  We don't accept

       subtypes of those because we wouldn't know how to deserialize

       them.  We don't accept Queue<E> because it is unlikely people

       would use that as a parameter or return type in an MBean.  */

    private MXBeanMapping

            makeParameterizedTypeMapping(ParameterizedType objType,

                                         MXBeanMappingFactory factory)

            throws OpenDataException {

        final Type rawType = objType.getRawType();

        if (rawType instanceof Class<?>) {

            Class<?> c = (Class<?>) rawType;

            if (c == List.class || c == Set.class || c == SortedSet.class) {

                Type[] actuals = objType.getActualTypeArguments();

                assert(actuals.length == 1);

                if (c == SortedSet.class)

                    mustBeComparable(c, actuals[0]);

                return makeArrayOrCollectionMapping(objType, actuals[0], factory);

            } else {

                boolean sortedMap = (c == SortedMap.class);

                if (c == Map.class || sortedMap) {

                    Type[] actuals = objType.getActualTypeArguments();

                    assert(actuals.length == 2);

                    if (sortedMap)

                        mustBeComparable(c, actuals[0]);

                    return makeTabularMapping(objType, sortedMap,

                            actuals[0], actuals[1], factory);

                }

            }

        }

        throw new OpenDataException("Cannot convert type: " + objType);

    }

    private static MXBeanMapping makeMXBeanRefMapping(Type t)

            throws OpenDataException {

        return new MXBeanRefMapping(t);

    }

    private MXBeanMapping makeCompositeMapping(Class<?> c,

                                               MXBeanMappingFactory factory)

            throws OpenDataException {

        // For historical reasons GcInfo implements CompositeData but we

        // shouldn't count its CompositeData.getCompositeType() field as

        // an item in the computed CompositeType.

        final boolean gcInfoHack =

            (c.getName().equals("com.sun.management.GcInfo") &&

                c.getClassLoader() == null);

        final List<Method> methods =

                MBeanAnalyzer.eliminateCovariantMethods(Arrays.asList(c.getMethods()));

        final SortedMap<String,Method> getterMap = newSortedMap();

        /* Select public methods that look like "T getX()" or "boolean

           isX()", where T is not void and X is not the empty

           string.  Exclude "Class getClass()" inherited from Object.  */

        for (Method method : methods) {

            final String propertyName = propertyName(method);

            if (propertyName == null)

                continue;

            if (gcInfoHack && propertyName.equals("CompositeType"))

                continue;

            Method old =

                getterMap.put(decapitalize(propertyName),

                            method);

            if (old != null) {

                final String msg =

                    "Class " + c.getName() + " has method name clash: " +

                    old.getName() + ", " + method.getName();

                throw new OpenDataException(msg);

            }

        }

        final int nitems = getterMap.size();

        if (nitems == 0) {

            throw new OpenDataException("Can't map " + c.getName() +

                                        " to an open data type");

        }

        final Method[] getters = new Method[nitems];

        final String[] itemNames = new String[nitems];

        final OpenType<?>[] openTypes = new OpenType<?>[nitems];

        int i = 0;

        for (Map.Entry<String,Method> entry : getterMap.entrySet()) {

            itemNames[i] = entry.getKey();

            final Method getter = entry.getValue();

            getters[i] = getter;

            final Type retType = getter.getGenericReturnType();

            openTypes[i] = factory.mappingForType(retType, factory).getOpenType();

            i++;

        }

        CompositeType compositeType =

            new CompositeType(c.getName(),

                              c.getName(),

                              itemNames, // field names

                              itemNames, // field descriptions

                              openTypes);

        return new CompositeMapping(c,

                                    compositeType,

                                    itemNames,

                                    getters,

                                    factory);

    }

    /* Converter for classes where the open data is identical to the

       original data.  This is true for any of the SimpleType types,

       and for an any-dimension array of those.  It is also true for

       primitive types as of JMX 1.3, since an int[]

       can be directly represented by an ArrayType, and an int needs no mapping

       because reflection takes care of it.  */

    private static final class IdentityMapping extends NonNullMXBeanMapping {

        IdentityMapping(Type targetType, OpenType<?> openType) {

            super(targetType, openType);

        }

        boolean isIdentity() {

            return true;

        }

        @Override

        Object fromNonNullOpenValue(Object openValue)

        throws InvalidObjectException {

            return openValue;

        }

        @Override