/*

 * Copyright (c) 2005, 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 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</code> 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</code>

 * </td>

 * <td>

 * <code>"Byte"</code>

 * </td>

 * </tr>

 *

 * <tr>

 * <td>

 * <tt>ASCII</tt>

 * </td>

 * <td>

 * {@link TIFFTag#TIFF_ASCII}

 * </td>

 * <td>

 * <code>String</code>

 * </td>

 * <td>

 * <code>"Ascii"</code>

 * </td>

 * </tr>

 *

 * <tr>

 * <td>

 * <tt>SHORT</tt>

 * </td>

 * <td>

 * {@link TIFFTag#TIFF_SHORT}

 * </td>

 * <td>

 * <code>char</code>

 * </td>

 * <td>

 * <code>"Short"</code>

 * </td>

 * </tr>

 *

 * <tr>

 * <td>

 * <tt>LONG</tt>

 * </td>

 * <td>

 * {@link TIFFTag#TIFF_LONG}

 * </td>

 * <td>

 * <code>long</code>

 * </td>

 * <td>

 * <code>"Long"</code>

 * </td>

 * </tr>

 *

 * <tr>

 * <td>

 * <tt>RATIONAL</tt>

 * </td>

 * <td>

 * {@link TIFFTag#TIFF_RATIONAL}

 * </td>

 * <td>

 * <code>long[2]</code> {numerator, denominator}

 * </td>

 * <td>

 * <code>"Rational"</code>

 * </td>

 * </tr>

 *

 * <tr>

 * <td>

 * <tt>SBYTE</tt>

 * </td>

 * <td>

 * {@link TIFFTag#TIFF_SBYTE}

 * </td>

 * <td>

 * <code>byte</code>

 * </td>

 * <td>

 * <code>"SByte"</code>

 * </td>

 * </tr>

 *

 * <tr>

 * <td>

 * <tt>UNDEFINED</tt>

 * </td>

 * <td>

 * {@link TIFFTag#TIFF_UNDEFINED}

 * </td>

 * <td>

 * <code>byte</code>

 * </td>

 * <td>

 * <code>"Undefined"</code>

 * </td>

 * </tr>

 *

 * <tr>

 * <td>

 * <tt>SSHORT</tt>

 * </td>

 * <td>

 * {@link TIFFTag#TIFF_SSHORT}

 * </td>

 * <td>

 * <code>short</code>

 * </td>

 * <td>

 * <code>"SShort"</code>

 * </td>

 * </tr>

 *

 * <tr>

 * <td>

 * <tt>SLONG</tt>

 * </td>

 * <td>

 * {@link TIFFTag#TIFF_SLONG}

 * </td>

 * <td>

 * <code>int</code>

 * </td>

 * <td>

 * <code>"SLong"</code>

 * </td>

 * </tr>

 *

 * <tr>

 * <td>

 * <tt>SRATIONAL</tt>

 * </td>

 * <td>

 * {@link TIFFTag#TIFF_SRATIONAL}

 * </td>

 * <td>

 * <code>int[2]</code> {numerator, denominator}

 * </td>

 * <td>

 * <code>"SRational"</code>

 * </td>

 * </tr>

 *

 * <tr>

 * <td>

 * <tt>FLOAT</tt>

 * </td>

 * <td>

 * {@link TIFFTag#TIFF_FLOAT}

 * </td>

 * <td>

 * <code>float</code>

 * </td>

 * <td>

 * <code>"Float"</code>

 * </td>

 * </tr>

 *

 * <tr>

 * <td>

 * <tt>DOUBLE</tt>

 * </td>

 * <td>

 * {@link TIFFTag#TIFF_DOUBLE}

 * </td>

 * <td>

 * <code>double</code>

 * </td>

 * <td>

 * <code>"Double"</code>

 * </td>

 * </tr>

 *

 * <tr>

 * <td>

 * <tt>IFD</tt>

 * </td>

 * <td>

 * {@link TIFFTag#TIFF_IFD_POINTER}

 * </td>

 * <td>

 * <code>long</code>

 * </td>

 * <td>

 * <code>"IFDPointer"</code>

 * </td>

 * </tr>

 *

 * </table>

 *

 * @since 1.9

 * @see   TIFFDirectory

 * @see   TIFFTag

 */

public 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</code> from a TIFF native image

     * metadata node. If the value of the <tt>"tagNumber"</tt> attribute

     * of the node is not found in <code>tagSet</code> then a new

     * <code>TIFFTag</code> with name <code>TIFFTag.UNKNOWN_TAG_NAME</code>

     * will be created and assigned to the field.

     *

     * @param tagSet The <code>TIFFTagSet</code> to which the

     * <code>TIFFTag</code> of the field belongs.

     * @param node A native TIFF image metadata <code>TIFFField</code> node.

     * @throws NullPointerException if <code>node</code> is

     * <code>null</code>.

     * @throws IllegalArgumentException if the name of the node is not

     * <code>"TIFFField"</code>.

     * @return A new {@code TIFFField}.

     */

    public static TIFFField createFromMetadataNode(TIFFTagSet tagSet,

                                                   Node node) {

        if (node == null) {

            throw 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);

        }

        return new TIFFField(tag, type, count, data);

    }

    /**

     * Constructs a <code>TIFFField</code> with arbitrary data. The

     * <code>type</code> parameter must be a value for which

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

     * returns <code>true</code>. The <code>data</code> 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</code>

     * 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

     * field will already have been read from the TIFF stream. (An exception

     * to this case may occur when the field represents the contents of a

     * non-baseline IFD. In that case the data will be a <code>long[]</code>

     * containing the offset to the IFD and the <code>TIFFDirectory</code>

     * returned by {@link #getDirectory()} will be its contents.)

     *

     * @param tag The tag to associated with this field.

     * @param type One of the <code>TIFFTag.TIFF_*</code> constants

     * indicating the data type of the field as written to the TIFF stream.

     * @param count The number of data values.

     * @param data The actual data content of the field.

     *

     * @throws NullPointerException if <code>tag&nbsp;==&nbsp;null</code>.

     * @throws IllegalArgumentException if <code>type</code> is not

     * one of the <code>TIFFTag.TIFF_*</code> data type constants.

     * @throws IllegalArgumentException if <code>type</code> is an unacceptable

     * data type for the supplied <code>TIFFTag</code>.

     * @throws IllegalArgumentException if <code>count&nbsp;&lt;&nbsp;0</code>.

     * @throws NullPointerException if <code>data&nbsp;==&nbsp;null</code>.

     * @throws IllegalArgumentException if <code>data</code> is an instance of

     * a class incompatible with the specified type.

     * @throws IllegalArgumentException if the size of the data array is wrong.

     */

    public TIFFField(TIFFTag tag, int type, int count, Object data) {

        if(tag == null) {

            throw new NullPointerException("tag == null!");