/*
 * Copyright (c) 2001, 2024, 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.print;

import java.io.ByteArrayInputStream;
import java.io.CharArrayReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.io.StringReader;

import javax.print.attribute.AttributeSetUtilities;
import javax.print.attribute.DocAttributeSet;

/**
 * This class is an implementation of interface {@code Doc} that can be used in
 * many common printing requests. It can handle all of the presently defined
 * "pre-defined" doc flavors defined as static variables in the
 * {@code DocFlavor} class.
 * <p>
 * In particular this class implements certain required semantics of the
 * {@code Doc} specification as follows:
 * <ul>
 *   <li>constructs a stream for the service if requested and appropriate.
 *   <li>ensures the same object is returned for each call on a method.
 *   <li>ensures multiple threads can access the {@code Doc}
 *   <li>performs some validation of that the data matches the doc flavor.
 * </ul>
 * Clients who want to re-use the doc object in other jobs, or need a
 * {@code MultiDoc} will not want to use this class.
 * <p>
 * If the print data is a stream, or a print job requests data as a stream, then
 * {@code SimpleDoc} does not monitor if the service properly closes the stream
 * after data transfer completion or job termination. Clients may prefer to use
 * provide their own implementation of doc that adds a listener to monitor job
 * completion and to validate that resources such as streams are freed (ie
 * closed).
 */
public final class SimpleDoc implements Doc {

    /**
     * The doc flavor in which this doc will supply its piece of print data.
     */
    private DocFlavor flavor;

    /**
     * The set of printing attributes for this doc.
     */
    private DocAttributeSet attributes;

    /**
     * The print data.
     */
    private Object printData;

    /**
     * The reader for extracting character print data from this doc.
     */
    private Reader reader;

    /**
     * The input stream for extracting byte print data from this doc.
     */
    private InputStream inStream;

    /**
     * Constructs a {@code SimpleDoc} with the specified print data, doc flavor
     * and doc attribute set.
     *
     * @param  printData the print data object
     * @param  flavor the {@code DocFlavor} object
     * @param  attributes a {@code DocAttributeSet}, which can be {@code null}
     * @throws IllegalArgumentException if {@code flavor} or {@code printData}
     *         is {@code null}, or the {@code printData} does not correspond to
     *         the specified doc flavor--for example, the data is not of the
     *         type specified as the representation in the {@code DocFlavor}
     */
    public SimpleDoc(Object printData,
                     DocFlavor flavor, DocAttributeSet attributes) {

       if (flavor == null || printData == null) {
           throw new IllegalArgumentException("null argument(s)");
       }

       Class<?> repClass = null;
       try {
            String className = flavor.getRepresentationClassName();
            repClass = Class.forName(className, false,
                              Thread.currentThread().getContextClassLoader());
       } catch (Throwable e) {
           throw new IllegalArgumentException("unknown representation class");
       }

       if (!repClass.isInstance(printData)) {
           throw new IllegalArgumentException("data is not of declared type");
       }

       this.flavor = flavor;
       if (attributes != null) {
           this.attributes = AttributeSetUtilities.unmodifiableView(attributes);
       }
       this.printData = printData;
    }

    /**
     * Determines the doc flavor in which this doc object will supply its piece
     * of print data.
     *
     * @return doc flavor
     */
    public DocFlavor getDocFlavor() {
        return flavor;
    }

    /**
     * Obtains the set of printing attributes for this doc object. If the
     * returned attribute set includes an instance of a particular attribute
     * <i>X,</i> the printer must use that attribute value for this doc,
     * overriding any value of attribute <i>X</i> in the job's attribute set. If
     * the returned attribute set does not include an instance of a particular
     * attribute <i>X</i> or if {@code null} is returned, the printer must
     * consult the job's attribute set to obtain the value for attribute
     * <i>X,</i> and if not found there, the printer must use an
     * implementation-dependent default value. The returned attribute set is
     * unmodifiable.
     *
     * @return unmodifiable set of printing attributes for this doc, or
     *         {@code null} to obtain all attribute values from the job's
     *         attribute set
     */
    public DocAttributeSet getAttributes() {
        return attributes;
    }

    /**
     * Obtains the print data representation object that contains this doc
     * object's piece of print data in the format corresponding to the supported
     * doc flavor. The {@code getPrintData()} method returns an instance of the
     * representation class whose name is given by {@link #getDocFlavor()
     * getDocFlavor()}.{@link DocFlavor#getRepresentationClassName()
     * getRepresentationClassName()}, and the return value can be cast from
     * class {@code Object} to that representation class.
     *
     * @return print data representation object
     * @throws IOException if the representation class is a stream and there was
     *         an I/O error while constructing the stream
     */
    public Object getPrintData() throws IOException {
        return printData;
    }

    /**
     * Obtains a reader for extracting character print data from this doc. The
     * {@code Doc} implementation is required to support this method if the
     * {@code DocFlavor} has one of the following print data representation
     * classes, and return {@code null} otherwise:
     * <ul>
     *   <li>{@code char[]}
     *   <li>{@code java.lang.String}
     *   <li>{@code java.io.Reader}
     * </ul>
     * The doc's print data representation object is used to construct and
     * return a {@code Reader} for reading the print data as a stream of
     * characters from the print data representation object. However, if the
     * print data representation object is itself a {@code Reader} then the
     * print data representation object is simply returned.
     *
     * @return a {@code Reader} for reading the print data characters from this
     *         doc. If a reader cannot be provided because this doc does not
     *         meet the criteria stated above, {@code null} is returned.
     * @throws IOException if there was an I/O error while creating the reader
     */
    public Reader getReaderForText() throws IOException {

        if (printData instanceof Reader) {
            return (Reader)printData;
        }

        synchronized (this) {
            if (reader != null) {
                return reader;
            }

            if (printData instanceof char[]) {
               reader = new CharArrayReader((char[])printData);
            }
            else if (printData instanceof String) {
                reader = new StringReader((String)printData);
            }
        }
        return reader;
    }

    /**
     * Obtains an input stream for extracting byte print data from this doc. The
     * {@code Doc} implementation is required to support this method if the
     * {@code DocFlavor} has one of the following print data representation
     * classes; otherwise this method returns {@code null}:
     * <ul>
     *   <li>{@code byte[]}
     *   <li>{@code java.io.InputStream}
     * </ul>
     * The doc's print data representation object is obtained. Then, an input
     * stream for reading the print data from the print data representation
     * object as a stream of bytes is created and returned. However, if the
     * print data representation object is itself an input stream then the print
     * data representation object is simply returned.
     *
     * @return an {@code InputStream} for reading the print data bytes from this
     *         doc. If an input stream cannot be provided because this doc does
     *         not meet the criteria stated above, {@code null} is returned.
     * @throws IOException if there was an I/O error while creating the input
     *         stream
     */
    public InputStream getStreamForBytes() throws IOException {

        if (printData instanceof InputStream) {
            return (InputStream)printData;
        }

        synchronized (this) {
            if (inStream != null) {
                return inStream;
            }

            if (printData instanceof byte[]) {
               inStream = new ByteArrayInputStream((byte[])printData);
            }
        }
        return inStream;
    }
}