/*

 * Copyright (c) 2000, 2008, 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 sun.awt.datatransfer;

import java.awt.AWTError;

import java.awt.EventQueue;

import java.awt.Image;

import java.awt.Graphics;

import java.awt.datatransfer.DataFlavor;

import java.awt.datatransfer.FlavorMap;

import java.awt.datatransfer.FlavorTable;

import java.awt.datatransfer.Transferable;

import java.awt.datatransfer.UnsupportedFlavorException;

import java.io.BufferedReader;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.Reader;

import java.io.SequenceInputStream;

import java.io.StringReader;

import java.net.URI;

import java.net.URISyntaxException;

import java.nio.ByteBuffer;

import java.nio.CharBuffer;

import java.nio.charset.Charset;

import java.nio.charset.CharsetEncoder;

import java.nio.charset.IllegalCharsetNameException;

import java.nio.charset.UnsupportedCharsetException;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.security.PrivilegedActionException;

import java.security.PrivilegedExceptionAction;

import java.security.ProtectionDomain;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.SortedMap;

import java.util.SortedSet;

import java.util.Set;

import java.util.Stack;

import java.util.TreeMap;

import java.util.TreeSet;

import sun.util.logging.PlatformLogger;

import sun.awt.AppContext;

import sun.awt.SunToolkit;

import java.awt.image.BufferedImage;

import java.awt.image.ImageObserver;

import java.awt.image.RenderedImage;

import java.awt.image.WritableRaster;

import java.awt.image.ColorModel;

import javax.imageio.ImageIO;

import javax.imageio.ImageReader;

import javax.imageio.ImageReadParam;

import javax.imageio.ImageWriter;

import javax.imageio.ImageTypeSpecifier;

import javax.imageio.spi.ImageWriterSpi;

import javax.imageio.stream.ImageInputStream;

import javax.imageio.stream.ImageOutputStream;

import sun.awt.image.ImageRepresentation;

import sun.awt.image.ToolkitImage;

import java.io.FilePermission;

/**

 * Provides a set of functions to be shared among the DataFlavor class and

 * platform-specific data transfer implementations.

 *

 * The concept of "flavors" and "natives" is extended to include "formats",

 * which are the numeric values Win32 and X11 use to express particular data

 * types. Like FlavorMap, which provides getNativesForFlavors(DataFlavor[]) and

 * getFlavorsForNatives(String[]) functions, DataTransferer provides a set

 * of getFormatsFor(Transferable|Flavor|Flavors) and

 * getFlavorsFor(Format|Formats) functions.

 *

 * Also provided are functions for translating a Transferable into a byte

 * array, given a source DataFlavor and a target format, and for translating

 * a byte array or InputStream into an Object, given a source format and

 * a target DataFlavor.

 *

 * @author David Mendenhall

 * @author Danila Sinopalnikov

 *

 * @since 1.3.1

 */

public abstract class DataTransferer {

    /**

     * Cached value of Class.forName("[C");

     */

    public static final Class charArrayClass;

    /**

     * Cached value of Class.forName("[B");

     */

    public static final Class byteArrayClass;

    /**

     * The <code>DataFlavor</code> representing plain text with Unicode

     * encoding, where:

     * <pre>

     *     representationClass = java.lang.String

     *     mimeType            = "text/plain; charset=Unicode"

     * </pre>

     */

    public static final DataFlavor plainTextStringFlavor;

    /**

     * The <code>DataFlavor</code> representing a Java text encoding String

     * encoded in UTF-8, where

     * <pre>

     *     representationClass = [B

     *     mimeType            = "application/x-java-text-encoding"

     * </pre>

     */

    public static final DataFlavor javaTextEncodingFlavor;

    /**

     * Lazy initialization of Standard Encodings.

     */

    private static class StandardEncodingsHolder {

        private static final SortedSet<String> standardEncodings = load();

        private static SortedSet<String> load() {

            final Comparator comparator =

                    new CharsetComparator(IndexedComparator.SELECT_WORST);

            final SortedSet<String> tempSet = new TreeSet<String>(comparator);

            tempSet.add("US-ASCII");

            tempSet.add("ISO-8859-1");

            tempSet.add("UTF-8");

            tempSet.add("UTF-16BE");

            tempSet.add("UTF-16LE");

            tempSet.add("UTF-16");

            tempSet.add(getDefaultTextCharset());

            return Collections.unmodifiableSortedSet(tempSet);

        }

    }

    /**

     * Tracks whether a particular text/* MIME type supports the charset

     * parameter. The Map is initialized with all of the standard MIME types

     * listed in the DataFlavor.selectBestTextFlavor method comment. Additional

     * entries may be added during the life of the JRE for text/<other> types.

     */

    private static final Map textMIMESubtypeCharsetSupport;

    /**

     * Cache of the platform default encoding as specified in the

     * "file.encoding" system property.

     */

    private static String defaultEncoding;

    /**

     * A collection of all natives listed in flavormap.properties with

     * a primary MIME type of "text".

     */

    private static final Set textNatives =

        Collections.synchronizedSet(new HashSet());

    /**

     * The native encodings/charsets for the Set of textNatives.

     */

    private static final Map nativeCharsets =

        Collections.synchronizedMap(new HashMap());

    /**

     * The end-of-line markers for the Set of textNatives.

     */

    private static final Map nativeEOLNs =

        Collections.synchronizedMap(new HashMap());

    /**

     * The number of terminating NUL bytes for the Set of textNatives.

     */

    private static final Map nativeTerminators =

        Collections.synchronizedMap(new HashMap());

    /**

     * The key used to store pending data conversion requests for an AppContext.

     */

    private static final String DATA_CONVERTER_KEY = "DATA_CONVERTER_KEY";

    /**

     * The singleton DataTransferer instance. It is created during MToolkit

     * or WToolkit initialization.

     */

    private static DataTransferer transferer;

    private static final PlatformLogger dtLog = PlatformLogger.getLogger("sun.awt.datatransfer.DataTransfer");

    static {

        Class tCharArrayClass = null, tByteArrayClass = null;

        try {

            tCharArrayClass = Class.forName("[C");

            tByteArrayClass = Class.forName("[B");

        } catch (ClassNotFoundException cannotHappen) {

        }

        charArrayClass = tCharArrayClass;

        byteArrayClass = tByteArrayClass;

        DataFlavor tPlainTextStringFlavor = null;

        try {

            tPlainTextStringFlavor = new DataFlavor

                ("text/plain;charset=Unicode;class=java.lang.String");

        } catch (ClassNotFoundException cannotHappen) {

        }

        plainTextStringFlavor = tPlainTextStringFlavor;

        DataFlavor tJavaTextEncodingFlavor = null;

        try {

            tJavaTextEncodingFlavor = new DataFlavor

                ("application/x-java-text-encoding;class=\"[B\"");

        } catch (ClassNotFoundException cannotHappen) {

        }

        javaTextEncodingFlavor = tJavaTextEncodingFlavor;

        Map tempMap = new HashMap(17);

        tempMap.put("sgml", Boolean.TRUE);

        tempMap.put("xml", Boolean.TRUE);

        tempMap.put("html", Boolean.TRUE);

        tempMap.put("enriched", Boolean.TRUE);

        tempMap.put("richtext", Boolean.TRUE);

        tempMap.put("uri-list", Boolean.TRUE);

        tempMap.put("directory", Boolean.TRUE);

        tempMap.put("css", Boolean.TRUE);

        tempMap.put("calendar", Boolean.TRUE);

        tempMap.put("plain", Boolean.TRUE);

        tempMap.put("rtf", Boolean.FALSE);

        tempMap.put("tab-separated-values", Boolean.FALSE);

        tempMap.put("t140", Boolean.FALSE);

        tempMap.put("rfc822-headers", Boolean.FALSE);

        tempMap.put("parityfec", Boolean.FALSE);

        textMIMESubtypeCharsetSupport = Collections.synchronizedMap(tempMap);

    }

    /**

     * The accessor method for the singleton DataTransferer instance. Note

     * that in a headless environment, there may be no DataTransferer instance;

     * instead, null will be returned.

     */

    public static DataTransferer getInstance() {

        synchronized (DataTransferer.class) {

            if (transferer == null) {

                final String name = SunToolkit.getDataTransfererClassName();

                if (name != null) {

                    PrivilegedAction<DataTransferer> action = new PrivilegedAction<DataTransferer>()

                    {

                      public DataTransferer run() {

                          Class cls = null;

                          Method method = null;

                          DataTransferer ret = null;

                          try {

                              cls = Class.forName(name);

                          } catch (ClassNotFoundException e) {

                              ClassLoader cl = ClassLoader.

                                  getSystemClassLoader();

                              if (cl != null) {

                                  try {

                                      cls = cl.loadClass(name);

                                  } catch (ClassNotFoundException ee) {

                                      ee.printStackTrace();

                                      throw new AWTError("DataTransferer not found: " + name);

                                  }

                              }

                          }

                          if (cls != null) {

                              try {

                                  method = cls.getDeclaredMethod("getInstanceImpl");

                                  method.setAccessible(true);

                              } catch (NoSuchMethodException e) {

                                  e.printStackTrace();

                                  throw new AWTError("Cannot instantiate DataTransferer: " + name);

                              } catch (SecurityException e) {

                                  e.printStackTrace();

                                  throw new AWTError("Access is denied for DataTransferer: " + name);

                              }

                          }

                          if (method != null) {

                              try {

                                  ret = (DataTransferer) method.invoke(null);

                              } catch (InvocationTargetException e) {

                                  e.printStackTrace();

                                  throw new AWTError("Cannot instantiate DataTransferer: " + name);

                              } catch (IllegalAccessException e) {

                                  e.printStackTrace();

                                  throw new AWTError("Cannot access DataTransferer: " + name);

                              }

                          }

                          return ret;

                      }

                    };

                    transferer = AccessController.doPrivileged(action);

                }

            }

        }

        return transferer;

    }

    /**

     * Converts an arbitrary text encoding to its canonical name.

     */

    public static String canonicalName(String encoding) {

        if (encoding == null) {

            return null;

        }

        try {

            return Charset.forName(encoding).name();

        } catch (IllegalCharsetNameException icne) {

            return encoding;

        } catch (UnsupportedCharsetException uce) {

            return encoding;

        }

    }

    /**

     * If the specified flavor is a text flavor which supports the "charset"

     * parameter, then this method returns that parameter, or the default

     * charset if no such parameter was specified at construction. For non-

     * text DataFlavors, and for non-charset text flavors, this method returns

     * null.

     */

    public static String getTextCharset(DataFlavor flavor) {

        if (!isFlavorCharsetTextType(flavor)) {

            return null;

        }

        String encoding = flavor.getParameter("charset");

        return (encoding != null) ? encoding : getDefaultTextCharset();

    }

    /**

     * Returns the platform's default character encoding.

     */

    public static String getDefaultTextCharset() {

        if (defaultEncoding != null) {

            return defaultEncoding;

        }

        return defaultEncoding = Charset.defaultCharset().name();

    }

    /**

     * Tests only whether the flavor's MIME type supports the charset

     * parameter. Must only be called for flavors with a primary type of

     * "text".

     */

    public static boolean doesSubtypeSupportCharset(DataFlavor flavor) {

        if (dtLog.isLoggable(PlatformLogger.Level.FINE)) {

            if (!"text".equals(flavor.getPrimaryType())) {

                dtLog.fine("Assertion (\"text\".equals(flavor.getPrimaryType())) failed");

            }

        }

        String subType = flavor.getSubType();

        if (subType == null) {

            return false;

        }

        Object support = textMIMESubtypeCharsetSupport.get(subType);

        if (support != null) {

            return (support == Boolean.TRUE);

        }

        boolean ret_val = (flavor.getParameter("charset") != null);

        textMIMESubtypeCharsetSupport.put

            (subType, (ret_val) ? Boolean.TRUE : Boolean.FALSE);

        return ret_val;

    }

    public static boolean doesSubtypeSupportCharset(String subType,

                                                    String charset)

    {

        Object support = textMIMESubtypeCharsetSupport.get(subType);

        if (support != null) {

            return (support == Boolean.TRUE);

        }

        boolean ret_val = (charset != null);

        textMIMESubtypeCharsetSupport.put

            (subType, (ret_val) ? Boolean.TRUE : Boolean.FALSE);

        return ret_val;

    }

    /**

     * Returns whether this flavor is a text type which supports the

     * 'charset' parameter.

     */

    public static boolean isFlavorCharsetTextType(DataFlavor flavor) {

        // Although stringFlavor doesn't actually support the charset

        // parameter (because its primary MIME type is not "text"), it should

        // be treated as though it does. stringFlavor is semantically

        // equivalent to "text/plain" data.

        if (DataFlavor.stringFlavor.equals(flavor)) {

            return true;

        }

        if (!"text".equals(flavor.getPrimaryType()) ||

            !doesSubtypeSupportCharset(flavor))

        {

            return false;

        }

        Class rep_class = flavor.getRepresentationClass();

        if (flavor.isRepresentationClassReader() ||

            String.class.equals(rep_class) ||

            flavor.isRepresentationClassCharBuffer() ||

            DataTransferer.charArrayClass.equals(rep_class))

        {

            return true;

        }

        if (!(flavor.isRepresentationClassInputStream() ||

              flavor.isRepresentationClassByteBuffer() ||

              DataTransferer.byteArrayClass.equals(rep_class))) {

            return false;

        }

        String charset = flavor.getParameter("charset");

        return (charset != null)

            ? DataTransferer.isEncodingSupported(charset)

            : true; // null equals default encoding which is always supported

    }

    /**

     * Returns whether this flavor is a text type which does not support the

     * 'charset' parameter.

     */

    public static boolean isFlavorNoncharsetTextType(DataFlavor flavor) {

        if (!"text".equals(flavor.getPrimaryType()) ||

            doesSubtypeSupportCharset(flavor))

        {

            return false;

        }

        return (flavor.isRepresentationClassInputStream() ||

                flavor.isRepresentationClassByteBuffer() ||

                DataTransferer.byteArrayClass.

                    equals(flavor.getRepresentationClass()));

    }

    /**

     * Determines whether this JRE can both encode and decode text in the

     * specified encoding.

     */

    public static boolean isEncodingSupported(String encoding) {

        if (encoding == null) {

            return false;

        }

        try {

            return Charset.isSupported(encoding);

        } catch (IllegalCharsetNameException icne) {

            return false;

        }

    }

    /**

     * Returns {@code true} if the given type is a java.rmi.Remote.

     */

    public static boolean isRemote(Class<?> type) {

        return RMI.isRemote(type);

    }

    /**

     * Returns an Iterator which traverses a SortedSet of Strings which are