/*

 * Copyright (c) 2005, 2016, 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 com.sun.imageio.plugins.tiff;

import java.io.IOException;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.StringTokenizer;

import javax.imageio.metadata.IIOMetadata;

import javax.imageio.metadata.IIOInvalidTreeException;

import javax.imageio.metadata.IIOMetadataFormatImpl;

import javax.imageio.metadata.IIOMetadataNode;

import javax.imageio.stream.ImageInputStream;

import org.w3c.dom.NamedNodeMap;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

import javax.imageio.plugins.tiff.BaselineTIFFTagSet;

import javax.imageio.plugins.tiff.ExifParentTIFFTagSet;

import javax.imageio.plugins.tiff.TIFFField;

import javax.imageio.plugins.tiff.TIFFTag;

import javax.imageio.plugins.tiff.TIFFTagSet;

public class TIFFImageMetadata extends IIOMetadata {

    // package scope

    public static final String NATIVE_METADATA_FORMAT_NAME =

        "javax_imageio_tiff_image_1.0";

    public static final String NATIVE_METADATA_FORMAT_CLASS_NAME =

        "javax.imageio.plugins.tiff.TIFFImageMetadataFormat";

    private List<TIFFTagSet> tagSets;

    TIFFIFD rootIFD;

    public TIFFImageMetadata(List<TIFFTagSet> tagSets) {

        super(true,

              NATIVE_METADATA_FORMAT_NAME,

              NATIVE_METADATA_FORMAT_CLASS_NAME,

              null, null);

        this.tagSets = tagSets;

        this.rootIFD = new TIFFIFD(tagSets);

    }

    public TIFFImageMetadata(TIFFIFD ifd) {

        super(true,

              NATIVE_METADATA_FORMAT_NAME,

              NATIVE_METADATA_FORMAT_CLASS_NAME,

              null, null);

        this.tagSets = ifd.getTagSetList();

        this.rootIFD = ifd;

    }

    public void initializeFromStream(ImageInputStream stream,

                                     boolean ignoreUnknownFields)

        throws IOException {

        rootIFD.initialize(stream, true, ignoreUnknownFields);

    }

    public void addShortOrLongField(int tagNumber, int value) {

        TIFFField field = new TIFFField(rootIFD.getTag(tagNumber), value);

        rootIFD.addTIFFField(field);

    }

    public boolean isReadOnly() {

        return false;

    }

    private Node getIFDAsTree(TIFFIFD ifd,

                              String parentTagName, int parentTagNumber) {

        IIOMetadataNode IFDRoot = new IIOMetadataNode("TIFFIFD");

        if (parentTagNumber != 0) {

            IFDRoot.setAttribute("parentTagNumber",

                                 Integer.toString(parentTagNumber));

        }

        if (parentTagName != null) {

            IFDRoot.setAttribute("parentTagName", parentTagName);

        }

        List<TIFFTagSet> tagSets = ifd.getTagSetList();

        if (tagSets.size() > 0) {

            Iterator<TIFFTagSet> iter = tagSets.iterator();

            StringBuilder tagSetNames = new StringBuilder();

            while (iter.hasNext()) {

                TIFFTagSet tagSet = iter.next();

                tagSetNames.append(tagSet.getClass().getName());

                if (iter.hasNext()) {

                    tagSetNames.append(",");

                }

            }

            IFDRoot.setAttribute("tagSets", tagSetNames.toString());

        }

        Iterator<TIFFField> iter = ifd.iterator();

        while (iter.hasNext()) {

            TIFFField f = iter.next();

            int tagNumber = f.getTagNumber();

            TIFFTag tag = TIFFIFD.getTag(tagNumber, tagSets);

            Node node = null;

            if (tag == null) {

                node = f.getAsNativeNode();

            } else if (tag.isIFDPointer() && f.hasDirectory()) {

                // Recurse

                node = getIFDAsTree(subIFD, tag.getName(), tag.getNumber());

            } else {

                node = f.getAsNativeNode();

            }

            if (node != null) {

                IFDRoot.appendChild(node);

            }

        }

        return IFDRoot;

    }

    public Node getAsTree(String formatName) {

        if (formatName.equals(nativeMetadataFormatName)) {

            return getNativeTree();

        } else if (formatName.equals

                   (IIOMetadataFormatImpl.standardMetadataFormatName)) {

            return getStandardTree();

        } else {

            throw new IllegalArgumentException("Not a recognized format!");

        }

    }

    private Node getNativeTree() {

        IIOMetadataNode root = new IIOMetadataNode(nativeMetadataFormatName);

        Node IFDNode = getIFDAsTree(rootIFD, null, 0);

        root.appendChild(IFDNode);

        return root;

    }

    private static final String[] colorSpaceNames = {

        "GRAY", // WhiteIsZero

        "GRAY", // BlackIsZero

        "RGB", // RGB

        "RGB", // PaletteColor

        "GRAY", // TransparencyMask

        "CMYK", // CMYK

        "YCbCr", // YCbCr

        "Lab", // CIELab

        "Lab", // ICCLab

    };

    public IIOMetadataNode getStandardChromaNode() {

        IIOMetadataNode chroma_node = new IIOMetadataNode("Chroma");

        IIOMetadataNode node = null; // scratch node

        TIFFField f;

        // Set the PhotometricInterpretation and the palette color flag.

        int photometricInterpretation = -1;

        boolean isPaletteColor = false;

        f = getTIFFField(BaselineTIFFTagSet.TAG_PHOTOMETRIC_INTERPRETATION);

        if (f != null) {

            photometricInterpretation = f.getAsInt(0);

            isPaletteColor =

                photometricInterpretation ==

                BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_PALETTE_COLOR;

        }

        // Determine the number of channels.

        int numChannels = -1;

        if(isPaletteColor) {

            numChannels = 3;

        } else {

            f = getTIFFField(BaselineTIFFTagSet.TAG_SAMPLES_PER_PIXEL);

            if (f != null) {

                numChannels = f.getAsInt(0);

            } else { // f == null

                f = getTIFFField(BaselineTIFFTagSet.TAG_BITS_PER_SAMPLE);

                if(f != null) {

                    numChannels = f.getCount();

                }

            }

        }

        if(photometricInterpretation != -1) {

            if (photometricInterpretation >= 0 &&

                photometricInterpretation < colorSpaceNames.length) {

                node = new IIOMetadataNode("ColorSpaceType");

                String csName;

                if(photometricInterpretation ==

                   BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_CMYK &&

                   numChannels == 3) {

                    csName = "CMY";

                } else {

                    csName = colorSpaceNames[photometricInterpretation];

                }

                node.setAttribute("name", csName);

                chroma_node.appendChild(node);

            }

            node = new IIOMetadataNode("BlackIsZero");

            node.setAttribute("value",

                              (photometricInterpretation ==

                   BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_WHITE_IS_ZERO)

                              ? "FALSE" : "TRUE");

            chroma_node.appendChild(node);

        }

        if(numChannels != -1) {

            node = new IIOMetadataNode("NumChannels");

            node.setAttribute("value", Integer.toString(numChannels));

            chroma_node.appendChild(node);

        }

        f = getTIFFField(BaselineTIFFTagSet.TAG_COLOR_MAP);

        if (f != null) {

            // NOTE: The presence of hasAlpha is vestigial: there is

            // no way in TIFF to represent an alpha component in a palette

            // color image. See bug 5086341.

            boolean hasAlpha = false;

            node = new IIOMetadataNode("Palette");

            int len = f.getCount()/(hasAlpha ? 4 : 3);

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

                IIOMetadataNode entry =

                    new IIOMetadataNode("PaletteEntry");

                entry.setAttribute("index", Integer.toString(i));

                int r = (f.getAsInt(i)*255)/65535;

                int g = (f.getAsInt(len + i)*255)/65535;

                int b = (f.getAsInt(2*len + i)*255)/65535;

                entry.setAttribute("red", Integer.toString(r));

                entry.setAttribute("green", Integer.toString(g));

                entry.setAttribute("blue", Integer.toString(b));

                if (hasAlpha) {

                    int alpha = 0;

                    entry.setAttribute("alpha", Integer.toString(alpha));

                }

                node.appendChild(entry);

            }

            chroma_node.appendChild(node);

        }

        return chroma_node;

    }

    public IIOMetadataNode getStandardCompressionNode() {

        IIOMetadataNode compression_node = new IIOMetadataNode("Compression");

        IIOMetadataNode node = null; // scratch node

        TIFFField f;

        f = getTIFFField(BaselineTIFFTagSet.TAG_COMPRESSION);

        if (f != null) {

            String compressionTypeName = null;

            int compression = f.getAsInt(0);

            boolean isLossless = true; // obligate initialization.

            if(compression == BaselineTIFFTagSet.COMPRESSION_NONE) {

                compressionTypeName = "None";

                isLossless = true;

            } else {

                int[] compressionNumbers = TIFFImageWriter.compressionNumbers;

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

                    if(compression == compressionNumbers[i]) {

                        compressionTypeName =

                            TIFFImageWriter.compressionTypes[i];

                        isLossless =

                            TIFFImageWriter.isCompressionLossless[i];

                        break;

                    }

                }

            }

            if (compressionTypeName != null) {

                node = new IIOMetadataNode("CompressionTypeName");

                node.setAttribute("value", compressionTypeName);

                compression_node.appendChild(node);

                node = new IIOMetadataNode("Lossless");

                node.setAttribute("value", isLossless ? "TRUE" : "FALSE");

                compression_node.appendChild(node);

            }

        }

        node = new IIOMetadataNode("NumProgressiveScans");

        node.setAttribute("value", "1");

        compression_node.appendChild(node);

        return compression_node;

    }

    private String repeat(String s, int times) {

        if (times == 1) {

            return s;

        }

        StringBuffer sb = new StringBuffer((s.length() + 1)*times - 1);

        sb.append(s);

        for (int i = 1; i < times; i++) {

            sb.append(" ");

            sb.append(s);

        }

        return sb.toString();

    }

    public IIOMetadataNode getStandardDataNode() {

        IIOMetadataNode data_node = new IIOMetadataNode("Data");

        IIOMetadataNode node = null; // scratch node

        TIFFField f;

        boolean isPaletteColor = false;

        f = getTIFFField(BaselineTIFFTagSet.TAG_PHOTOMETRIC_INTERPRETATION);

        if (f != null) {

            isPaletteColor =

                f.getAsInt(0) ==

                BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_PALETTE_COLOR;

        }

        f = getTIFFField(BaselineTIFFTagSet.TAG_PLANAR_CONFIGURATION);

        String planarConfiguration = "PixelInterleaved";

        if (f != null &&

            f.getAsInt(0) == BaselineTIFFTagSet.PLANAR_CONFIGURATION_PLANAR) {

            planarConfiguration = "PlaneInterleaved";

        }

        node = new IIOMetadataNode("PlanarConfiguration");

        node.setAttribute("value", planarConfiguration);

        data_node.appendChild(node);

        f = getTIFFField(BaselineTIFFTagSet.TAG_PHOTOMETRIC_INTERPRETATION);

        if (f != null) {

            int photometricInterpretation = f.getAsInt(0);

            String sampleFormat = "UnsignedIntegral";

            if (photometricInterpretation ==

                BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_PALETTE_COLOR) {

                sampleFormat = "Index";

            } else {

                f = getTIFFField(BaselineTIFFTagSet.TAG_SAMPLE_FORMAT);

                if (f != null) {

                    int format = f.getAsInt(0);

                    if (format ==

                        BaselineTIFFTagSet.SAMPLE_FORMAT_SIGNED_INTEGER) {

                        sampleFormat = "SignedIntegral";

                    } else if (format ==

                        BaselineTIFFTagSet.SAMPLE_FORMAT_UNSIGNED_INTEGER) {

                        sampleFormat = "UnsignedIntegral";

                    } else if (format ==

                               BaselineTIFFTagSet.SAMPLE_FORMAT_FLOATING_POINT) {

                        sampleFormat = "Real";

                    } else {

                        sampleFormat = null; // don't know

                    }

                }

            }

            if (sampleFormat != null) {

                node = new IIOMetadataNode("SampleFormat");

                node.setAttribute("value", sampleFormat);

                data_node.appendChild(node);

            }

        }

        f = getTIFFField(BaselineTIFFTagSet.TAG_BITS_PER_SAMPLE);

        int[] bitsPerSample = null;

        if(f != null) {

            bitsPerSample = f.getAsInts();

        } else {

            f = getTIFFField(BaselineTIFFTagSet.TAG_COMPRESSION);

            int compression = f != null ?

                f.getAsInt(0) : BaselineTIFFTagSet.COMPRESSION_NONE;

            if(getTIFFField(ExifParentTIFFTagSet.TAG_EXIF_IFD_POINTER) !=

               null ||

               compression == BaselineTIFFTagSet.COMPRESSION_JPEG ||

               compression == BaselineTIFFTagSet.COMPRESSION_OLD_JPEG ||

               getTIFFField(BaselineTIFFTagSet.TAG_JPEG_INTERCHANGE_FORMAT) !=

               null) {

                f = getTIFFField(BaselineTIFFTagSet.TAG_PHOTOMETRIC_INTERPRETATION);

                if(f != null &&

                   (f.getAsInt(0) ==

                    BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_WHITE_IS_ZERO ||

                    f.getAsInt(0) ==

                    BaselineTIFFTagSet.PHOTOMETRIC_INTERPRETATION_BLACK_IS_ZERO)) {

                    bitsPerSample = new int[] {8};

                } else {

                    bitsPerSample = new int[] {8, 8, 8};

                }

            } else {

                bitsPerSample = new int[] {1};

            }

        }

        StringBuffer sb = new StringBuffer();

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

            if (i > 0) {

                sb.append(" ");

            }

            sb.append(Integer.toString(bitsPerSample[i]));

        }

        node = new IIOMetadataNode("BitsPerSample");

        if(isPaletteColor) {

            node.setAttribute("value", repeat(sb.toString(), 3));

        } else {

            node.setAttribute("value", sb.toString());

        }

        data_node.appendChild(node);

            // SampleMSB

        f = getTIFFField(BaselineTIFFTagSet.TAG_FILL_ORDER);

        int fillOrder = f != null ?

            f.getAsInt(0) : BaselineTIFFTagSet.FILL_ORDER_LEFT_TO_RIGHT;

        sb = new StringBuffer();

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

            if (i > 0) {

                sb.append(" ");

            }

            int maxBitIndex = bitsPerSample[i] == 1 ?

                7 : bitsPerSample[i] - 1;

            int msb =

                fillOrder == BaselineTIFFTagSet.FILL_ORDER_LEFT_TO_RIGHT ?

                maxBitIndex : 0;

            sb.append(Integer.toString(msb));

        }

        node = new IIOMetadataNode("SampleMSB");

        if(isPaletteColor) {

            node.setAttribute("value", repeat(sb.toString(), 3));

        } else {

            node.setAttribute("value", sb.toString());

        }

        data_node.appendChild(node);

        return data_node;

    }

    private static final String[] orientationNames = {

        null,

        "Normal",

        "FlipH",

        "Rotate180",

        "FlipV",

        "FlipHRotate90",

        "Rotate270",

        "FlipVRotate90",

        "Rotate90",

    };

    public IIOMetadataNode getStandardDimensionNode() {

        IIOMetadataNode dimension_node = new IIOMetadataNode("Dimension");

        IIOMetadataNode node = null; // scratch node

        TIFFField f;

        long[] xres = null;

        long[] yres = null;

        f = getTIFFField(BaselineTIFFTagSet.TAG_X_RESOLUTION);

        if (f != null) {

            xres = f.getAsRational(0).clone();

        }

        f = getTIFFField(BaselineTIFFTagSet.TAG_Y_RESOLUTION);

        if (f != null) {

            yres = f.getAsRational(0).clone();

        }

        if (xres != null && yres != null) {

            node = new IIOMetadataNode("PixelAspectRatio");

            // Compute (1/xres)/(1/yres)

            // (xres_denom/xres_num)/(yres_denom/yres_num) =

            // (xres_denom/xres_num)*(yres_num/yres_denom) =

            // (xres_denom*yres_num)/(xres_num*yres_denom)

            float ratio = (float)((double)xres[1]*yres[0])/(xres[0]*yres[1]);

            node.setAttribute("value", Float.toString(ratio));

            dimension_node.appendChild(node);

        }

        if (xres != null || yres != null) {

            // Get unit field.

            f = getTIFFField(BaselineTIFFTagSet.TAG_RESOLUTION_UNIT);

            // Set resolution unit.

            int resolutionUnit = f != null ?

                f.getAsInt(0) : BaselineTIFFTagSet.RESOLUTION_UNIT_INCH;

            // Have size if either centimeters or inches.

            boolean gotPixelSize =

                resolutionUnit != BaselineTIFFTagSet.RESOLUTION_UNIT_NONE;

            // Convert pixels/inch to pixels/centimeter.

            if (resolutionUnit == BaselineTIFFTagSet.RESOLUTION_UNIT_INCH) {

                // Divide xres by 2.54

                if (xres != null) {

                    xres[0] *= 100;

                    xres[1] *= 254;

                }