/*

 * Copyright (c) 2000, 2015, 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.EventQueue;

import java.awt.Graphics;

import java.awt.Image;

import java.awt.Toolkit;

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.StandardCharsets;

import java.nio.charset.UnsupportedCharsetException;

import java.lang.reflect.Constructor;

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

import sun.datatransfer.DataFlavorUtil;

import sun.awt.AppContext;

import sun.awt.ComponentFactory;

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;

import java.util.stream.Stream;

/**

 * 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 {

    /**

     * 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;

    /**

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

     * a primary MIME type of "text".

     */

    private static final Set<Long> textNatives =

            Collections.synchronizedSet(new HashSet<>());

    /**

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

     */

    private static final Map<Long, String> nativeCharsets =

            Collections.synchronizedMap(new HashMap<>());

    /**

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

     */

    private static final Map<Long, String> nativeEOLNs =

            Collections.synchronizedMap(new HashMap<>());

    /**

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

     */

    private static final Map<Long, Integer> 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";

    static {

        DataFlavor tJavaTextEncodingFlavor = null;

        try {

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

        } catch (ClassNotFoundException cannotHappen) {

        }

        javaTextEncodingFlavor = tJavaTextEncodingFlavor;

    }

    /**

     * 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 synchronized DataTransferer getInstance() {

        return ((ComponentFactory) Toolkit.getDefaultToolkit()).getDataTransferer();

    }

    /**

     * Converts a FlavorMap to a FlavorTable.

     */

    public static FlavorTable adaptFlavorMap(final FlavorMap map) {

        if (map instanceof FlavorTable) {

            return (FlavorTable)map;

        }

        return new FlavorTable() {

            @Override

            public Map<DataFlavor, String> getNativesForFlavors(DataFlavor[] flavors) {

                return map.getNativesForFlavors(flavors);

            }

            @Override

            public Map<String, DataFlavor> getFlavorsForNatives(String[] natives) {

                return map.getFlavorsForNatives(natives);

            }

            @Override

            public List<String> getNativesForFlavor(DataFlavor flav) {

                Map<DataFlavor, String> natives = getNativesForFlavors(new DataFlavor[]{flav});

                String nat = natives.get(flav);

                if (nat != null) {

                    return Collections.singletonList(nat);

                } else {

                    return Collections.emptyList();

                }

            }

            @Override

            public List<DataFlavor> getFlavorsForNative(String nat) {

                Map<String, DataFlavor> flavors = getFlavorsForNatives(new String[]{nat});

                DataFlavor flavor = flavors.get(nat);

                if (flavor != null) {

                    return Collections.singletonList(flavor);

                } else {

                    return Collections.emptyList();

                }

            }

        };

    }

    /**

     * Returns the default Unicode encoding for the platform. The encoding

     * need not be canonical. This method is only used by the archaic function

     * DataFlavor.getTextPlainUnicodeFlavor().

     */

    public abstract String getDefaultUnicodeEncoding();

    /**

     * This method is called for text flavor mappings established while parsing

     * the flavormap.properties file. It stores the "eoln" and "terminators"

     * parameters which are not officially part of the MIME type. They are

     * MIME parameters specific to the flavormap.properties file format.

     */

    public void registerTextFlavorProperties(String nat, String charset,

                                             String eoln, String terminators) {

        Long format = getFormatForNativeAsLong(nat);

        textNatives.add(format);

        nativeCharsets.put(format, (charset != null && charset.length() != 0)

                ? charset : Charset.defaultCharset().name());

        if (eoln != null && eoln.length() != 0 && !eoln.equals("\n")) {

            nativeEOLNs.put(format, eoln);

        }

        if (terminators != null && terminators.length() != 0) {

            Integer iTerminators = Integer.valueOf(terminators);

            if (iTerminators > 0) {

                nativeTerminators.put(format, iTerminators);

            }

        }

    }

    /**

     * Determines whether the native corresponding to the specified long format

     * was listed in the flavormap.properties file.

     */

    protected boolean isTextFormat(long format) {

        return textNatives.contains(Long.valueOf(format));

    }

    protected String getCharsetForTextFormat(Long lFormat) {

        return nativeCharsets.get(lFormat);

    }

    /**

     * Specifies whether text imported from the native system in the specified

     * format is locale-dependent. If so, when decoding such text,

     * 'nativeCharsets' should be ignored, and instead, the Transferable should

     * be queried for its javaTextEncodingFlavor data for the correct encoding.

     */

    public abstract boolean isLocaleDependentTextFormat(long format);

    /**

     * Determines whether the DataFlavor corresponding to the specified long

     * format is DataFlavor.javaFileListFlavor.

     */

    public abstract boolean isFileFormat(long format);

    /**

     * Determines whether the DataFlavor corresponding to the specified long

     * format is DataFlavor.imageFlavor.

     */

    public abstract boolean isImageFormat(long format);

    /**

     * Determines whether the format is a URI list we can convert to

     * a DataFlavor.javaFileListFlavor.

     */

    protected boolean isURIListFormat(long format) {

        return false;

    }

    /**

     * Returns a Map whose keys are all of the possible formats into which the

     * Transferable's transfer data flavors can be translated. The value of

     * each key is the DataFlavor in which the Transferable's data should be

     * requested when converting to the format.

     * <p>

     * The map keys are sorted according to the native formats preference

     * order.

     */

    public SortedMap<Long,DataFlavor> getFormatsForTransferable(Transferable contents,

                                                                FlavorTable map)

    {

        DataFlavor[] flavors = contents.getTransferDataFlavors();

        if (flavors == null) {

            return Collections.emptySortedMap();

        }

        return getFormatsForFlavors(flavors, map);

    }

    /**

     * Returns a Map whose keys are all of the possible formats into which data

     * in the specified DataFlavors can be translated. The value of each key

     * is the DataFlavor in which the Transferable's data should be requested

     * when converting to the format.

     * <p>

     * The map keys are sorted according to the native formats preference

     * order.

     *

     * @param flavors the data flavors

     * @param map the FlavorTable which contains mappings between

     *            DataFlavors and data formats

     * @throws NullPointerException if flavors or map is <code>null</code>

     */

    public SortedMap<Long, DataFlavor> getFormatsForFlavors(DataFlavor[] flavors,

                                                            FlavorTable map)

    {

        Map<Long,DataFlavor> formatMap = new HashMap<>(flavors.length);

        Map<Long,DataFlavor> textPlainMap = new HashMap<>(flavors.length);

        // Maps formats to indices that will be used to sort the formats

        // according to the preference order.

        // Larger index value corresponds to the more preferable format.

        Map<Long, Integer> indexMap = new HashMap<>(flavors.length);

        Map<Long, Integer> textPlainIndexMap = new HashMap<>(flavors.length);

        int currentIndex = 0;

        // Iterate backwards so that preferred DataFlavors are used over

        // other DataFlavors. (See javadoc for

        // Transferable.getTransferDataFlavors.)

        for (int i = flavors.length - 1; i >= 0; i--) {

            DataFlavor flavor = flavors[i];

            if (flavor == null) continue;

            // Don't explicitly test for String, since it is just a special

            // case of Serializable

            if (flavor.isFlavorTextType() ||

                flavor.isFlavorJavaFileListType() ||

                DataFlavor.imageFlavor.equals(flavor) ||

                flavor.isRepresentationClassSerializable() ||

                flavor.isRepresentationClassInputStream() ||

                flavor.isRepresentationClassRemote())

            {

                List<String> natives = map.getNativesForFlavor(flavor);

                currentIndex += natives.size();

                for (String aNative : natives) {

                    Long lFormat = getFormatForNativeAsLong(aNative);

                    Integer index = currentIndex--;

                    formatMap.put(lFormat, flavor);

                    indexMap.put(lFormat, index);

                    // SystemFlavorMap.getNativesForFlavor will return

                    // text/plain natives for all text/*. While this is good

                    // for a single text/* flavor, we would prefer that

                    // text/plain native data come from a text/plain flavor.

                    if (("text".equals(flavor.getPrimaryType()) &&

                            "plain".equals(flavor.getSubType())) ||

                            flavor.equals(DataFlavor.stringFlavor)) {

                        textPlainMap.put(lFormat, flavor);

                        textPlainIndexMap.put(lFormat, index);

                    }

                }

                currentIndex += natives.size();

            }

        }

        formatMap.putAll(textPlainMap);

        indexMap.putAll(textPlainIndexMap);

        // Sort the map keys according to the formats preference order.

        Comparator<Long> comparator = DataFlavorUtil.getIndexOrderComparator(indexMap).reversed();

        SortedMap<Long, DataFlavor> sortedMap = new TreeMap<>(comparator);

        sortedMap.putAll(formatMap);

        return sortedMap;

    }

    /**

     * Reduces the Map output for the root function to an array of the

     * Map's keys.

     */

    public long[] getFormatsForTransferableAsArray(Transferable contents,

                                                   FlavorTable map) {

        return keysToLongArray(getFormatsForTransferable(contents, map));

    }

    /**

     * Returns a Map whose keys are all of the possible DataFlavors into which

     * data in the specified formats can be translated. The value of each key

     * is the format in which the Clipboard or dropped data should be requested

     * when converting to the DataFlavor.

     */

    public Map<DataFlavor, Long> getFlavorsForFormats(long[] formats, FlavorTable map) {

        Map<DataFlavor, Long> flavorMap = new HashMap<>(formats.length);

        Set<AbstractMap.SimpleEntry<Long, DataFlavor>> mappingSet = new HashSet<>(formats.length);

        Set<DataFlavor> flavorSet = new HashSet<>(formats.length);

        // First step: build flavorSet, mappingSet and initial flavorMap

        // flavorSet  - the set of all the DataFlavors into which

        //              data in the specified formats can be translated;

        // mappingSet - the set of all the mappings from the specified formats

        //              into any DataFlavor;

        // flavorMap  - after this step, this map maps each of the DataFlavors

        //              from flavorSet to any of the specified formats.

        for (long format : formats) {

            String nat = getNativeForFormat(format);

            List<DataFlavor> flavors = map.getFlavorsForNative(nat);

            for (DataFlavor flavor : flavors) {

                // Don't explicitly test for String, since it is just a special

                // case of Serializable

                if (flavor.isFlavorTextType() ||

                        flavor.isFlavorJavaFileListType() ||

                        DataFlavor.imageFlavor.equals(flavor) ||

                        flavor.isRepresentationClassSerializable() ||

                        flavor.isRepresentationClassInputStream() ||

                        flavor.isRepresentationClassRemote()) {

                    AbstractMap.SimpleEntry<Long, DataFlavor> mapping =

                            new AbstractMap.SimpleEntry<>(format, flavor);

                    flavorMap.put(flavor, format);

                    mappingSet.add(mapping);

                    flavorSet.add(flavor);

                }

            }

        }

        // Second step: for each DataFlavor try to figure out which of the

        // specified formats is the best to translate to this flavor.

        // Then map each flavor to the best format.

        // For the given flavor, FlavorTable indicates which native will

        // best reflect data in the specified flavor to the underlying native

        // platform. We assume that this native is the best to translate

        // to this flavor.

        // Note: FlavorTable allows one-way mappings, so we can occasionally

        // map a flavor to the format for which the corresponding

        // format-to-flavor mapping doesn't exist. For this reason we have built

        // a mappingSet of all format-to-flavor mappings for the specified formats

        // and check if the format-to-flavor mapping exists for the

        // (flavor,format) pair being added.

        for (DataFlavor flavor : flavorSet) {

            List<String> natives = map.getNativesForFlavor(flavor);

            for (String aNative : natives) {

                Long lFormat = getFormatForNativeAsLong(aNative);

                if (mappingSet.contains(new AbstractMap.SimpleEntry<>(lFormat, flavor))) {

                    flavorMap.put(flavor, lFormat);

                    break;

                }

            }

        }

        return flavorMap;

    }

    /**

     * Returns a Set of all DataFlavors for which

     * 1) a mapping from at least one of the specified formats exists in the

     * specified map and

     * 2) the data translation for this mapping can be performed by the data

     * transfer subsystem.

     *

     * @param formats the data formats

     * @param map the FlavorTable which contains mappings between

     *            DataFlavors and data formats

     * @throws NullPointerException if formats or map is <code>null</code>

     */

    public Set<DataFlavor> getFlavorsForFormatsAsSet(long[] formats, FlavorTable map) {

        Set<DataFlavor> flavorSet = new HashSet<>(formats.length);

        for (long format : formats) {

            List<DataFlavor> flavors = map.getFlavorsForNative(getNativeForFormat(format));

            for (DataFlavor flavor : flavors) {

                // Don't explicitly test for String, since it is just a special

                // case of Serializable

                if (flavor.isFlavorTextType() ||

                        flavor.isFlavorJavaFileListType() ||

                        DataFlavor.imageFlavor.equals(flavor) ||

                        flavor.isRepresentationClassSerializable() ||

                        flavor.isRepresentationClassInputStream() ||

                        flavor.isRepresentationClassRemote()) {

                    flavorSet.add(flavor);

                }

            }

        }

        return flavorSet;

    }

    /**

     * Returns an array of all DataFlavors for which

     * 1) a mapping from at least one of the specified formats exists in the

     * specified map and

     * 2) the data translation for this mapping can be performed by the data

     * transfer subsystem.

     * The array will be sorted according to a

     * <code>DataFlavorComparator</code> created with the specified

     * map as an argument.

     *