/*

 * Copyright (c) 2000, 2010, Oracle and/or its affiliates. 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.  Oracle designates this

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

 * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package java.beans;

import com.sun.beans.finder.PrimitiveWrapperMap;

import java.awt.AWTKeyStroke;

import java.awt.BorderLayout;

import java.awt.Dimension;

import java.awt.Color;

import java.awt.Font;

import java.awt.GridBagConstraints;

import java.awt.Insets;

import java.awt.Point;

import java.awt.Rectangle;

import java.awt.event.KeyEvent;

import java.awt.font.TextAttribute;

import java.lang.reflect.Array;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import java.lang.reflect.InvocationTargetException;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.util.*;

import javax.swing.Box;

import javax.swing.JLayeredPane;

import javax.swing.border.MatteBorder;

import javax.swing.plaf.ColorUIResource;

import sun.swing.PrintColorUIResource;

import java.util.Objects;

/*

 * Like the <code>Intropector</code>, the <code>MetaData</code> class

 * contains <em>meta</em> objects that describe the way

 * classes should express their state in terms of their

 * own public APIs.

 *

 * @see java.beans.Intropector

 *

 * @author Philip Milne

 * @author Steve Langley

 */

class NullPersistenceDelegate extends PersistenceDelegate {

    // Note this will be called by all classes when they reach the

    // top of their superclass chain.

    protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {

    }

    protected Expression instantiate(Object oldInstance, Encoder out) { return null; }

    public void writeObject(Object oldInstance, Encoder out) {

    // System.out.println("NullPersistenceDelegate:writeObject " + oldInstance);

    }

}

/**

 * The persistence delegate for <CODE>enum</CODE> classes.

 *

 * @author Sergey A. Malenkov

 */

class EnumPersistenceDelegate extends PersistenceDelegate {

    protected boolean mutatesTo(Object oldInstance, Object newInstance) {

        return oldInstance == newInstance;

    }

    protected Expression instantiate(Object oldInstance, Encoder out) {

        return new Expression(e, Enum.class, "valueOf", new Object[]{e.getDeclaringClass(), e.name()});

    }

}

class PrimitivePersistenceDelegate extends PersistenceDelegate {

    protected boolean mutatesTo(Object oldInstance, Object newInstance) {

        return oldInstance.equals(newInstance);

    }

    protected Expression instantiate(Object oldInstance, Encoder out) {

        return new Expression(oldInstance, oldInstance.getClass(),

                  "new", new Object[]{oldInstance.toString()});

    }

}

class ArrayPersistenceDelegate extends PersistenceDelegate {

    protected boolean mutatesTo(Object oldInstance, Object newInstance) {

        return (newInstance != null &&

                oldInstance.getClass() == newInstance.getClass() && // Also ensures the subtype is correct.

                Array.getLength(oldInstance) == Array.getLength(newInstance));

        }

    protected Expression instantiate(Object oldInstance, Encoder out) {

        // System.out.println("instantiate: " + type + " " + oldInstance);

        return new Expression(oldInstance, Array.class, "newInstance",

                   new Object[]{oldClass.getComponentType(),

                                new Integer(Array.getLength(oldInstance))});

        }

    protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {

        int n = Array.getLength(oldInstance);

        for (int i = 0; i < n; i++) {

            Object index = new Integer(i);

            // Expression oldGetExp = new Expression(Array.class, "get", new Object[]{oldInstance, index});

            // Expression newGetExp = new Expression(Array.class, "get", new Object[]{newInstance, index});

            Expression oldGetExp = new Expression(oldInstance, "get", new Object[]{index});

            Expression newGetExp = new Expression(newInstance, "get", new Object[]{index});

            try {

                Object oldValue = oldGetExp.getValue();

                Object newValue = newGetExp.getValue();

                out.writeExpression(oldGetExp);

                if (!Objects.equals(newValue, out.get(oldValue))) {

                    // System.out.println("Not equal: " + newGetExp + " != " + actualGetExp);

                    // invokeStatement(Array.class, "set", new Object[]{oldInstance, index, oldValue}, out);

                    DefaultPersistenceDelegate.invokeStatement(oldInstance, "set", new Object[]{index, oldValue}, out);

                }

            }

            catch (Exception e) {

                // System.err.println("Warning:: failed to write: " + oldGetExp);

                out.getExceptionListener().exceptionThrown(e);

            }

        }

    }

}

class ProxyPersistenceDelegate extends PersistenceDelegate {

    protected Expression instantiate(Object oldInstance, Encoder out) {

        java.lang.reflect.Proxy p = (java.lang.reflect.Proxy)oldInstance;

        // This unappealing hack is not required but makes the

        // representation of EventHandlers much more concise.

        java.lang.reflect.InvocationHandler ih = java.lang.reflect.Proxy.getInvocationHandler(p);

        if (ih instanceof EventHandler) {

            EventHandler eh = (EventHandler)ih;

            args.add(type.getInterfaces()[0]);

            args.add(eh.getTarget());

            args.add(eh.getAction());

            if (eh.getEventPropertyName() != null) {

                args.add(eh.getEventPropertyName());

            }

            if (eh.getListenerMethodName() != null) {

                args.setSize(4);

                args.add(eh.getListenerMethodName());

            }

            return new Expression(oldInstance,

                                  EventHandler.class,

                                  "create",

                                  args.toArray());

        }

        return new Expression(oldInstance,

                              java.lang.reflect.Proxy.class,

                              "newProxyInstance",

                              new Object[]{type.getClassLoader(),

                                           type.getInterfaces(),

                                           ih});

    }

}

// Strings

class java_lang_String_PersistenceDelegate extends PersistenceDelegate {

    protected Expression instantiate(Object oldInstance, Encoder out) { return null; }

    public void writeObject(Object oldInstance, Encoder out) {

        // System.out.println("NullPersistenceDelegate:writeObject " + oldInstance);

    }

}

// Classes

class java_lang_Class_PersistenceDelegate extends PersistenceDelegate {

    protected boolean mutatesTo(Object oldInstance, Object newInstance) {

        return oldInstance.equals(newInstance);

    }

    protected Expression instantiate(Object oldInstance, Encoder out) {

        // As of 1.3 it is not possible to call Class.forName("int"),

        // so we have to generate different code for primitive types.

        // This is needed for arrays whose subtype may be primitive.

        if (c.isPrimitive()) {

            Field field = null;

            try {

                field = PrimitiveWrapperMap.getType(c.getName()).getDeclaredField("TYPE");

            } catch (NoSuchFieldException ex) {

                System.err.println("Unknown primitive type: " + c);

            }

            return new Expression(oldInstance, field, "get", new Object[]{null});

        }

        else if (oldInstance == String.class) {

            return new Expression(oldInstance, "", "getClass", new Object[]{});

        }

        else if (oldInstance == Class.class) {

            return new Expression(oldInstance, String.class, "getClass", new Object[]{});

        }

        else {

            Expression newInstance = new Expression(oldInstance, Class.class, "forName", new Object[] { c.getName() });

            newInstance.loader = c.getClassLoader();

            return newInstance;

        }

    }

}

// Fields

class java_lang_reflect_Field_PersistenceDelegate extends PersistenceDelegate {

    protected boolean mutatesTo(Object oldInstance, Object newInstance) {

        return oldInstance.equals(newInstance);

    }

    protected Expression instantiate(Object oldInstance, Encoder out) {

        Field f = (Field)oldInstance;

        return new Expression(oldInstance,

                f.getDeclaringClass(),

                "getField",

                new Object[]{f.getName()});

    }

}

// Methods

class java_lang_reflect_Method_PersistenceDelegate extends PersistenceDelegate {

    protected boolean mutatesTo(Object oldInstance, Object newInstance) {

        return oldInstance.equals(newInstance);

    }

    protected Expression instantiate(Object oldInstance, Encoder out) {

        Method m = (Method)oldInstance;

        return new Expression(oldInstance,

                m.getDeclaringClass(),

                "getMethod",

                new Object[]{m.getName(), m.getParameterTypes()});

    }

}

// Dates

/**

 * The persistence delegate for <CODE>java.util.Date</CODE> classes.

 * Do not extend DefaultPersistenceDelegate to improve performance and

 * to avoid problems with <CODE>java.sql.Date</CODE>,

 * <CODE>java.sql.Time</CODE> and <CODE>java.sql.Timestamp</CODE>.

 *

 * @author Sergey A. Malenkov

 */

class java_util_Date_PersistenceDelegate extends PersistenceDelegate {

    protected boolean mutatesTo(Object oldInstance, Object newInstance) {

        if (!super.mutatesTo(oldInstance, newInstance)) {

            return false;

        }

        Date oldDate = (Date)oldInstance;

        Date newDate = (Date)newInstance;

        return oldDate.getTime() == newDate.getTime();

    }

    protected Expression instantiate(Object oldInstance, Encoder out) {

        Date date = (Date)oldInstance;

        return new Expression(date, date.getClass(), "new", new Object[] {date.getTime()});

    }

}

/**

 * The persistence delegate for <CODE>java.sql.Timestamp</CODE> classes.

 * It supports nanoseconds.

 *

 * @author Sergey A. Malenkov

 */

final class java_sql_Timestamp_PersistenceDelegate extends java_util_Date_PersistenceDelegate {

    private static final Method getNanosMethod = getNanosMethod();

    private static Method getNanosMethod() {

        try {

            Class<?> c = Class.forName("java.sql.Timestamp", true, null);

            return c.getMethod("getNanos");

        } catch (ClassNotFoundException e) {

            return null;

        } catch (NoSuchMethodException e) {

            throw new AssertionError(e);

        }

    }

    /**

     * Invoke Timstamp getNanos.

     */

    private static int getNanos(Object obj) {

        if (getNanosMethod == null)

            throw new AssertionError("Should not get here");

        try {

            return (Integer)getNanosMethod.invoke(obj);

        } catch (InvocationTargetException e) {

            Throwable cause = e.getCause();

            if (cause instanceof RuntimeException)

                throw (RuntimeException)cause;

            if (cause instanceof Error)

                throw (Error)cause;

            throw new AssertionError(e);

        } catch (IllegalAccessException iae) {

            throw new AssertionError(iae);

        }

    }

    protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {

        // assumes oldInstance and newInstance are Timestamps

        int nanos = getNanos(oldInstance);

        if (nanos != getNanos(newInstance)) {

            out.writeStatement(new Statement(oldInstance, "setNanos", new Object[] {nanos}));

        }

    }

}

// Collections

/*

The Hashtable and AbstractMap classes have no common ancestor yet may

be handled with a single persistence delegate: one which uses the methods

of the Map insterface exclusively. Attatching the persistence delegates

to the interfaces themselves is fraught however since, in the case of

the Map, both the AbstractMap and HashMap classes are declared to

implement the Map interface, leaving the obvious implementation prone

to repeating their initialization. These issues and questions around

the ordering of delegates attached to interfaces have lead us to

ignore any delegates attached to interfaces and force all persistence

delegates to be registered with concrete classes.

*/

/**

 * The base class for persistence delegates for inner classes

 * that can be created using {@link Collections}.

 *

 * @author Sergey A. Malenkov

 */

abstract class java_util_Collections extends PersistenceDelegate {

    protected boolean mutatesTo(Object oldInstance, Object newInstance) {

        if (!super.mutatesTo(oldInstance, newInstance)) {

            return false;

        }

        if ((oldInstance instanceof List) || (oldInstance instanceof Set) || (oldInstance instanceof Map)) {

            return oldInstance.equals(newInstance);

        }

        return (oldC.size() == newC.size()) && oldC.containsAll(newC);

    }

    static final class EmptyList_PersistenceDelegate extends java_util_Collections {

        protected Expression instantiate(Object oldInstance, Encoder out) {

            return new Expression(oldInstance, Collections.class, "emptyList", null);

        }

    }

    static final class EmptySet_PersistenceDelegate extends java_util_Collections {

        protected Expression instantiate(Object oldInstance, Encoder out) {

            return new Expression(oldInstance, Collections.class, "emptySet", null);

        }

    }

    static final class EmptyMap_PersistenceDelegate extends java_util_Collections {

        protected Expression instantiate(Object oldInstance, Encoder out) {

            return new Expression(oldInstance, Collections.class, "emptyMap", null);

        }

    }

    static final class SingletonList_PersistenceDelegate extends java_util_Collections {

        protected Expression instantiate(Object oldInstance, Encoder out) {

            return new Expression(oldInstance, Collections.class, "singletonList", new Object[]{list.get(0)});

        }

    }

    static final class SingletonSet_PersistenceDelegate extends java_util_Collections {

        protected Expression instantiate(Object oldInstance, Encoder out) {

            return new Expression(oldInstance, Collections.class, "singleton", new Object[]{set.iterator().next()});

        }

    }

    static final class SingletonMap_PersistenceDelegate extends java_util_Collections {

        protected Expression instantiate(Object oldInstance, Encoder out) {

            Object key = map.keySet().iterator().next();

            return new Expression(oldInstance, Collections.class, "singletonMap", new Object[]{key, map.get(key)});

        }

    }

    static final class UnmodifiableCollection_PersistenceDelegate extends java_util_Collections {

        protected Expression instantiate(Object oldInstance, Encoder out) {

            return new Expression(oldInstance, Collections.class, "unmodifiableCollection", new Object[]{list});

        }

    }

    static final class UnmodifiableList_PersistenceDelegate extends java_util_Collections {

        protected Expression instantiate(Object oldInstance, Encoder out) {

            return new Expression(oldInstance, Collections.class, "unmodifiableList", new Object[]{list});

        }

    }

    static final class UnmodifiableRandomAccessList_PersistenceDelegate extends java_util_Collections {

        protected Expression instantiate(Object oldInstance, Encoder out) {

            return new Expression(oldInstance, Collections.class, "unmodifiableList", new Object[]{list});

        }

    }

    static final class UnmodifiableSet_PersistenceDelegate extends java_util_Collections {

        protected Expression instantiate(Object oldInstance, Encoder out) {

            return new Expression(oldInstance, Collections.class, "unmodifiableSet", new Object[]{set});

        }

    }

    static final class UnmodifiableSortedSet_PersistenceDelegate extends java_util_Collections {

        protected Expression instantiate(Object oldInstance, Encoder out) {

            return new Expression(oldInstance, Collections.class, "unmodifiableSortedSet", new Object[]{set});

        }

    }

    static final class UnmodifiableMap_PersistenceDelegate extends java_util_Collections {

        protected Expression instantiate(Object oldInstance, Encoder out) {

            return new Expression(oldInstance, Collections.class, "unmodifiableMap", new Object[]{map});

        }

    }

    static final class UnmodifiableSortedMap_PersistenceDelegate extends java_util_Collections {

        protected Expression instantiate(Object oldInstance, Encoder out) {

            return new Expression(oldInstance, Collections.class, "unmodifiableSortedMap", new Object[]{map});

        }

    }

    static final class SynchronizedCollection_PersistenceDelegate extends java_util_Collections {

        protected Expression instantiate(Object oldInstance, Encoder out) {

            return new Expression(oldInstance, Collections.class, "synchronizedCollection", new Object[]{list});

        }

    }

    static final class SynchronizedList_PersistenceDelegate extends java_util_Collections {

        protected Expression instantiate(Object oldInstance, Encoder out) {

            return new Expression(oldInstance, Collections.class, "synchronizedList", new Object[]{list});

        }

    }

    static final class SynchronizedRandomAccessList_PersistenceDelegate extends java_util_Collections {

        protected Expression instantiate(Object oldInstance, Encoder out) {

            return new Expression(oldInstance, Collections.class, "synchronizedList", new Object[]{list});

        }

    }

    static final class SynchronizedSet_PersistenceDelegate extends java_util_Collections {

        protected Expression instantiate(Object oldInstance, Encoder out) {

            return new Expression(oldInstance, Collections.class, "synchronizedSet", new Object[]{set});

        }

    }

    static final class SynchronizedSortedSet_PersistenceDelegate extends java_util_Collections {

        protected Expression instantiate(Object oldInstance, Encoder out) {

            return new Expression(oldInstance, Collections.class, "synchronizedSortedSet", new Object[]{set});

        }

    }

    static final class SynchronizedMap_PersistenceDelegate extends java_util_Collections {

        protected Expression instantiate(Object oldInstance, Encoder out) {

            return new Expression(oldInstance, Collections.class, "synchronizedMap", new Object[]{map});

        }

    }

    static final class SynchronizedSortedMap_PersistenceDelegate extends java_util_Collections {

        protected Expression instantiate(Object oldInstance, Encoder out) {

            return new Expression(oldInstance, Collections.class, "synchronizedSortedMap", new Object[]{map});

        }

    }

    static final class CheckedCollection_PersistenceDelegate extends java_util_Collections {

        protected Expression instantiate(Object oldInstance, Encoder out) {

            Object type = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedCollection.type");

            return new Expression(oldInstance, Collections.class, "checkedCollection", new Object[]{list, type});

        }

    }

    static final class CheckedList_PersistenceDelegate extends java_util_Collections {

        protected Expression instantiate(Object oldInstance, Encoder out) {

            Object type = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedCollection.type");