/*

 * 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 javax.imageio.plugins.tiff;

import java.util.StringTokenizer;

import org.w3c.dom.NamedNodeMap;

import org.w3c.dom.Node;

import com.sun.imageio.plugins.tiff.TIFFFieldNode;

import com.sun.imageio.plugins.tiff.TIFFIFD;

/**

 * A class representing a field in a TIFF 6.0 Image File Directory.

 *

 * <p> A field in a TIFF Image File Directory (IFD) is defined as a

 * tag number accompanied by a sequence of values of identical data type.

 * TIFF 6.0 defines 12 data types; a 13th type {@code IFD} is

 * defined in TIFF Tech Note 1 of TIFF Specification Supplement 1. These

 * TIFF data types are referred to by Java constants and mapped internally

 * onto Java language data types and type names as follows:

 *

 * <br>

 * <br>

 * <table border="1">

 * <caption>TIFF Data Type to Java Data Type Mapping</caption>

 *

 * <tr>

 * <th>

 * <b>TIFF Data Type</b>

 * </th>

 * <th>

 * <b>Java Constant</b>

 * </th>

 * <th>

 * <b>Java Data Type</b>

 * </th>

 * <th>

 * <b>Java Type Name</b>

 * </th>

 * </tr>

 *

 * <tr>

 * <td>

 * <tt>BYTE</tt>

 * </td>

 * <td>

 * {@link TIFFTag#TIFF_BYTE}

 * </td>

 * <td>

 * {@code byte}

 * </td>

 * <td>

 * {@code "Byte"}

 * </td>

 * </tr>

 *

 * <tr>

 * <td>

 * <tt>ASCII</tt>

 * </td>

 * <td>

 * {@link TIFFTag#TIFF_ASCII}

 * </td>

 * <td>

 * {@code String}

 * </td>

 * <td>

 * {@code "Ascii"}

 * </td>

 * </tr>

 *

 * <tr>

 * <td>

 * <tt>SHORT</tt>

 * </td>

 * <td>

 * {@link TIFFTag#TIFF_SHORT}

 * </td>

 * <td>

 * {@code char}

 * </td>

 * <td>

 * {@code "Short"}

 * </td>

 * </tr>

 *

 * <tr>

 * <td>

 * <tt>LONG</tt>

 * </td>

 * <td>

 * {@link TIFFTag#TIFF_LONG}

 * </td>

 * <td>

 * {@code long}

 * </td>

 * <td>

 * {@code "Long"}

 * </td>

 * </tr>

 *

 * <tr>

 * <td>

 * <tt>RATIONAL</tt>

 * </td>

 * <td>

 * {@link TIFFTag#TIFF_RATIONAL}

 * </td>

 * <td>

 * {@code long[2]} {numerator, denominator}

 * </td>

 * <td>

 * {@code "Rational"}

 * </td>

 * </tr>

 *

 * <tr>

 * <td>

 * <tt>SBYTE</tt>

 * </td>

 * <td>

 * {@link TIFFTag#TIFF_SBYTE}

 * </td>

 * <td>

 * {@code byte}

 * </td>

 * <td>

 * {@code "SByte"}

 * </td>

 * </tr>

 *

 * <tr>

 * <td>

 * <tt>UNDEFINED</tt>

 * </td>

 * <td>

 * {@link TIFFTag#TIFF_UNDEFINED}

 * </td>

 * <td>

 * {@code byte}

 * </td>

 * <td>

 * {@code "Undefined"}

 * </td>

 * </tr>

 *

 * <tr>

 * <td>

 * <tt>SSHORT</tt>

 * </td>

 * <td>

 * {@link TIFFTag#TIFF_SSHORT}

 * </td>

 * <td>

 * {@code short}

 * </td>

 * <td>

 * {@code "SShort"}

 * </td>

 * </tr>

 *

 * <tr>

 * <td>

 * <tt>SLONG</tt>

 * </td>

 * <td>

 * {@link TIFFTag#TIFF_SLONG}

 * </td>

 * <td>

 * {@code int}

 * </td>

 * <td>

 * {@code "SLong"}

 * </td>

 * </tr>

 *

 * <tr>

 * <td>

 * <tt>SRATIONAL</tt>

 * </td>

 * <td>

 * {@link TIFFTag#TIFF_SRATIONAL}

 * </td>

 * <td>

 * {@code int[2]} {numerator, denominator}

 * </td>

 * <td>

 * {@code "SRational"}

 * </td>

 * </tr>

 *

 * <tr>

 * <td>

 * <tt>FLOAT</tt>

 * </td>

 * <td>

 * {@link TIFFTag#TIFF_FLOAT}

 * </td>

 * <td>

 * {@code float}

 * </td>

 * <td>

 * {@code "Float"}

 * </td>

 * </tr>

 *

 * <tr>

 * <td>

 * <tt>DOUBLE</tt>

 * </td>

 * <td>

 * {@link TIFFTag#TIFF_DOUBLE}

 * </td>

 * <td>

 * {@code double}

 * </td>

 * <td>

 * {@code "Double"}

 * </td>

 * </tr>

 *

 * <tr>

 * <td>

 * <tt>IFD</tt>

 * </td>

 * <td>

 * {@link TIFFTag#TIFF_IFD_POINTER}

 * </td>

 * <td>

 * {@code long}

 * </td>

 * <td>

 * {@code "IFDPointer"}

 * </td>

 * </tr>

 *

 * </table>

 *

 * @since 9

 * @see   TIFFDirectory

 * @see   TIFFTag

 */

public final class TIFFField implements Cloneable {

    private static final String[] typeNames = {

        null,

        "Byte", "Ascii", "Short", "Long", "Rational",

        "SByte", "Undefined", "SShort", "SLong", "SRational",

        "Float", "Double", "IFDPointer"

    };

    private static final boolean[] isIntegral = {

        false,

        true, false, true, true, false,

        true, true, true, true, false,

        false, false, false

    };

    /** The tag. */

    private TIFFTag tag;

    /** The tag number. */

    private int tagNumber;

    /** The tag type. */

    private int type;

    /** The number of data items present in the field. */

    private int count;

    /** The field data. */

    private Object data;

    /** The IFD contents if available. This will usually be a TIFFIFD. */

    private TIFFDirectory dir;

    /** The default constructor. */

    private TIFFField() {}

    private static String getAttribute(Node node, String attrName) {

        NamedNodeMap attrs = node.getAttributes();

        return attrs.getNamedItem(attrName).getNodeValue();

    }

    private static void initData(Node node,

                                 int[] otype, int[] ocount, Object[] odata) {

        int type;

        int count;

        Object data = null;

        String typeName = node.getNodeName();

        typeName = typeName.substring(4);

        typeName = typeName.substring(0, typeName.length() - 1);

        type = TIFFField.getTypeByName(typeName);

        if (type == -1) {

            throw new IllegalArgumentException("typeName = " + typeName);

        }

        Node child = node.getFirstChild();

        count = 0;

        while (child != null) {

            String childTypeName = child.getNodeName().substring(4);

            if (!typeName.equals(childTypeName)) {

                // warning

            }

            ++count;

            child = child.getNextSibling();

        }

        if (count > 0) {

            data = createArrayForType(type, count);

            child = node.getFirstChild();

            int idx = 0;

            while (child != null) {

                String value = getAttribute(child, "value");

                String numerator, denominator;

                int slashPos;

                switch (type) {

                case TIFFTag.TIFF_ASCII:

                    ((String[])data)[idx] = value;

                    break;

                case TIFFTag.TIFF_BYTE:

                case TIFFTag.TIFF_SBYTE:

                    ((byte[])data)[idx] =

                        (byte)Integer.parseInt(value);

                    break;

                case TIFFTag.TIFF_SHORT:

                    ((char[])data)[idx] =

                        (char)Integer.parseInt(value);

                    break;

                case TIFFTag.TIFF_SSHORT:

                    ((short[])data)[idx] =

                        (short)Integer.parseInt(value);

                    break;

                case TIFFTag.TIFF_SLONG:

                    ((int[])data)[idx] =

                        Integer.parseInt(value);

                    break;

                case TIFFTag.TIFF_LONG:

                case TIFFTag.TIFF_IFD_POINTER:

                    ((long[])data)[idx] =

                        Long.parseLong(value);

                    break;

                case TIFFTag.TIFF_FLOAT:

                    ((float[])data)[idx] =

                        Float.parseFloat(value);

                    break;

                case TIFFTag.TIFF_DOUBLE:

                    ((double[])data)[idx] =

                        Double.parseDouble(value);

                    break;

                case TIFFTag.TIFF_SRATIONAL:

                    slashPos = value.indexOf("/");

                    numerator = value.substring(0, slashPos);

                    denominator = value.substring(slashPos + 1);

                    ((int[][])data)[idx] = new int[2];

                    ((int[][])data)[idx][0] =

                        Integer.parseInt(numerator);

                    ((int[][])data)[idx][1] =

                        Integer.parseInt(denominator);

                    break;

                case TIFFTag.TIFF_RATIONAL:

                    slashPos = value.indexOf("/");

                    numerator = value.substring(0, slashPos);

                    denominator = value.substring(slashPos + 1);

                    ((long[][])data)[idx] = new long[2];

                    ((long[][])data)[idx][0] =

                        Long.parseLong(numerator);

                    ((long[][])data)[idx][1] =

                        Long.parseLong(denominator);

                    break;

                default:

                    // error

                }

                idx++;

                child = child.getNextSibling();

            }

        }

        otype[0] = type;

        ocount[0] = count;

        odata[0] = data;

    }

    /**

     * Creates a {@code TIFFField} from a TIFF native image

     * metadata node. If the value of the {@code "number"} attribute

     * of the node is not found in {@code tagSet} then a new

     * {@code TIFFTag} with name {@code TIFFTag.UNKNOWN_TAG_NAME}

     * will be created and assigned to the field.

     *

     * @param tagSet The {@code TIFFTagSet} to which the

     * {@code TIFFTag} of the field belongs.

     * @param node A native TIFF image metadata {@code TIFFField} node.

     * @throws IllegalArgumentException If the {@code Node} parameter content

     * does not adhere to the {@code TIFFField} element structure defined by

     * the <a href="../../metadata/doc-files/tiff_metadata.html#ImageMetadata">

     * TIFF native image metadata format specification</a>, or if the

     * combination of node attributes and data is not legal per the

     * {@link #TIFFField(TIFFTag,int,int,Object)} constructor specification.

     * Note that a cause might be set on such an exception.

     * @return A new {@code TIFFField}.

     */

    public static TIFFField createFromMetadataNode(TIFFTagSet tagSet,

                                                   Node node) {

        if (node == null) {

            // This method is specified to throw only IllegalArgumentExceptions

            // so we create an IAE with a NullPointerException as its cause.

            throw new IllegalArgumentException(new NullPointerException

                ("node == null!"));

        }

        String name = node.getNodeName();

        if (!name.equals("TIFFField")) {

            throw new IllegalArgumentException("!name.equals(\"TIFFField\")");

        }

        int tagNumber = Integer.parseInt(getAttribute(node, "number"));

        TIFFTag tag = null;

        if (tagSet != null) {

            tag = tagSet.getTag(tagNumber);

        }

        int type = TIFFTag.TIFF_UNDEFINED;

        int count = 0;

        Object data = null;

        Node child = node.getFirstChild();

        if (child != null) {

            String typeName = child.getNodeName();

            if (typeName.equals("TIFFUndefined")) {

                String values = getAttribute(child, "value");

                StringTokenizer st = new StringTokenizer(values, ",");

                count = st.countTokens();

                byte[] bdata = new byte[count];

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

                    bdata[i] = (byte)Integer.parseInt(st.nextToken());

                }

                type = TIFFTag.TIFF_UNDEFINED;

                data = bdata;

            } else {

                int[] otype = new int[1];

                int[] ocount = new int[1];

                Object[] odata = new Object[1];

                initData(node.getFirstChild(), otype, ocount, odata);

                type = otype[0];

                count = ocount[0];

                data = odata[0];

            }

        } else if (tag != null) {

            int t = TIFFTag.MAX_DATATYPE;

            while(t >= TIFFTag.MIN_DATATYPE && !tag.isDataTypeOK(t)) {

                t--;

            }

            type = t;

        }

        if (tag == null) {

            tag = new TIFFTag(TIFFTag.UNKNOWN_TAG_NAME, tagNumber, 1 << type);

        }

        TIFFField field;

        try {

            field = new TIFFField(tag, type, count, data);

        } catch (NullPointerException npe) {

            // This method is specified to throw only IllegalArgumentExceptions

            // so we catch the NullPointerException and set it as the cause of

            // the IAE which is thrown.

            throw new IllegalArgumentException(npe);

        }

        return field;

    }

    /**

     * Constructs a {@code TIFFField} with arbitrary data. The

     * {@code type} parameter must be a value for which

     * {@link TIFFTag#isDataTypeOK tag.isDataTypeOK()}

     * returns {@code true}. The {@code data} parameter must

     * be an array of a Java type appropriate for the type of the TIFF

     * field.

     *

     * <p>Note that the value (data) of the {@code TIFFField}

     * will always be the actual field value regardless of the number of

     * bytes required for that value. This is the case despite the fact

     * that the TIFF <i>IFD Entry</i> corresponding to the field may

     * actually contain the offset to the value of the field rather than

     * the value itself (the latter occurring if and only if the

     * value fits into 4 bytes). In other words, the value of the