/*

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

import java.awt.Window;

import java.awt.print.PrinterJob;

import java.io.File;

import java.net.URI;

import java.net.URISyntaxException;

import java.util.ArrayList;

import java.util.HashMap;

import javax.print.DocFlavor;

import javax.print.DocPrintJob;

import javax.print.PrintService;

import javax.print.ServiceUIFactory;

import javax.print.attribute.Attribute;

import javax.print.attribute.AttributeSet;

import javax.print.attribute.AttributeSetUtilities;

import javax.print.attribute.EnumSyntax;

import javax.print.attribute.HashAttributeSet;

import javax.print.attribute.PrintRequestAttributeSet;

import javax.print.attribute.PrintServiceAttribute;

import javax.print.attribute.PrintServiceAttributeSet;

import javax.print.attribute.HashPrintServiceAttributeSet;

import javax.print.attribute.standard.PrinterName;

import javax.print.attribute.standard.PrinterIsAcceptingJobs;

import javax.print.attribute.standard.QueuedJobCount;

import javax.print.attribute.standard.JobName;

import javax.print.attribute.standard.RequestingUserName;

import javax.print.attribute.standard.Chromaticity;

import javax.print.attribute.standard.Copies;

import javax.print.attribute.standard.CopiesSupported;

import javax.print.attribute.standard.Destination;

import javax.print.attribute.standard.Fidelity;

import javax.print.attribute.standard.Media;

import javax.print.attribute.standard.MediaSizeName;

import javax.print.attribute.standard.MediaSize;

import javax.print.attribute.standard.MediaTray;

import javax.print.attribute.standard.MediaPrintableArea;

import javax.print.attribute.standard.OrientationRequested;

import javax.print.attribute.standard.PageRanges;

import javax.print.attribute.standard.PrinterState;

import javax.print.attribute.standard.PrinterStateReason;

import javax.print.attribute.standard.PrinterStateReasons;

import javax.print.attribute.standard.Severity;

import javax.print.attribute.standard.Sides;

import javax.print.attribute.standard.ColorSupported;

import javax.print.attribute.standard.PrintQuality;

import javax.print.attribute.standard.PrinterResolution;

import javax.print.attribute.standard.SheetCollate;

import javax.print.event.PrintServiceAttributeListener;

import sun.awt.windows.WPrinterJob;

public class Win32PrintService implements PrintService, AttributeUpdater,

                                          SunPrinterJobService {

    public static MediaSize[] predefMedia = Win32MediaSize.getPredefMedia();

    private static final DocFlavor[] supportedFlavors = {

        DocFlavor.BYTE_ARRAY.GIF,

        DocFlavor.INPUT_STREAM.GIF,

        DocFlavor.URL.GIF,

        DocFlavor.BYTE_ARRAY.JPEG,

        DocFlavor.INPUT_STREAM.JPEG,

        DocFlavor.URL.JPEG,

        DocFlavor.BYTE_ARRAY.PNG,

        DocFlavor.INPUT_STREAM.PNG,

        DocFlavor.URL.PNG,

        DocFlavor.SERVICE_FORMATTED.PAGEABLE,

        DocFlavor.SERVICE_FORMATTED.PRINTABLE,

        DocFlavor.BYTE_ARRAY.AUTOSENSE,

        DocFlavor.URL.AUTOSENSE,

        DocFlavor.INPUT_STREAM.AUTOSENSE

    };

    /* let's try to support a few of these */

    private static final Class<?>[] serviceAttrCats = {

        PrinterName.class,

        PrinterIsAcceptingJobs.class,

        QueuedJobCount.class,

        ColorSupported.class,

    };

    /*  it turns out to be inconvenient to store the other categories

     *  separately because many attributes are in multiple categories.

     */

    private static Class<?>[] otherAttrCats = {

        JobName.class,

        RequestingUserName.class,

        Copies.class,

        Destination.class,

        OrientationRequested.class,

        PageRanges.class,

        Media.class,

        MediaPrintableArea.class,

        Fidelity.class,

        // We support collation on 2D printer jobs, even if the driver can't.

        SheetCollate.class,

        SunAlternateMedia.class,

        Chromaticity.class

    };

    /*

     * This table together with methods findWin32Media and

     * findMatchingMediaSizeNameMM are declared public as these are also

     * used in WPrinterJob.java.

     */

    public static final MediaSizeName[] dmPaperToPrintService = {

      MediaSizeName.NA_LETTER, MediaSizeName.NA_LETTER,

      MediaSizeName.TABLOID, MediaSizeName.LEDGER,

      MediaSizeName.NA_LEGAL, MediaSizeName.INVOICE,

      MediaSizeName.EXECUTIVE, MediaSizeName.ISO_A3,

      MediaSizeName.ISO_A4, MediaSizeName.ISO_A4,

      MediaSizeName.ISO_A5, MediaSizeName.JIS_B4,

      MediaSizeName.JIS_B5, MediaSizeName.FOLIO,

      MediaSizeName.QUARTO, MediaSizeName.NA_10X14_ENVELOPE,

      MediaSizeName.B, MediaSizeName.NA_LETTER,

      MediaSizeName.NA_NUMBER_9_ENVELOPE, MediaSizeName.NA_NUMBER_10_ENVELOPE,

      MediaSizeName.NA_NUMBER_11_ENVELOPE, MediaSizeName.NA_NUMBER_12_ENVELOPE,

      MediaSizeName.NA_NUMBER_14_ENVELOPE, MediaSizeName.C,

      MediaSizeName.D, MediaSizeName.E,

      MediaSizeName.ISO_DESIGNATED_LONG, MediaSizeName.ISO_C5,

      MediaSizeName.ISO_C3, MediaSizeName.ISO_C4,

      MediaSizeName.ISO_C6, MediaSizeName.ITALY_ENVELOPE,

      MediaSizeName.ISO_B4, MediaSizeName.ISO_B5,

      MediaSizeName.ISO_B6, MediaSizeName.ITALY_ENVELOPE,

      MediaSizeName.MONARCH_ENVELOPE, MediaSizeName.PERSONAL_ENVELOPE,

      MediaSizeName.NA_10X15_ENVELOPE, MediaSizeName.NA_9X12_ENVELOPE,

      MediaSizeName.FOLIO, MediaSizeName.ISO_B4,

      MediaSizeName.JAPANESE_POSTCARD, MediaSizeName.NA_9X11_ENVELOPE,

    };

    private static final MediaTray[] dmPaperBinToPrintService = {

      MediaTray.TOP, MediaTray.BOTTOM, MediaTray.MIDDLE,

      MediaTray.MANUAL, MediaTray.ENVELOPE, Win32MediaTray.ENVELOPE_MANUAL,

      Win32MediaTray.AUTO, Win32MediaTray.TRACTOR,

      Win32MediaTray.SMALL_FORMAT, Win32MediaTray.LARGE_FORMAT,

      MediaTray.LARGE_CAPACITY, null, null,

      MediaTray.MAIN, Win32MediaTray.FORMSOURCE,

    };

    // from wingdi.h

    private static int DM_PAPERSIZE = 0x2;

    private static int DM_PRINTQUALITY = 0x400;

    private static int DM_YRESOLUTION = 0x2000;

    private static final int DMRES_MEDIUM = -3;

    private static final int DMRES_HIGH = -4;

    private static final int DMORIENT_LANDSCAPE = 2;

    private static final int DMDUP_VERTICAL = 2;

    private static final int DMDUP_HORIZONTAL = 3;

    private static final int DMCOLLATE_TRUE = 1;

    private static final int DMCOLOR_MONOCHROME = 1;

    private static final int DMCOLOR_COLOR = 2;

    // media sizes with indices above dmPaperToPrintService' length

    private static final int DMPAPER_A2 = 66;

    private static final int DMPAPER_A6 = 70;

    private static final int DMPAPER_B6_JIS = 88;

    // Bit settings for getPrinterCapabilities which matches that

    // of native getCapabilities in WPrinterJob.cpp

    private static final int DEVCAP_COLOR = 0x0001;

    private static final int DEVCAP_DUPLEX = 0x0002;

    private static final int DEVCAP_COLLATE = 0x0004;

    private static final int DEVCAP_QUALITY = 0x0008;

    private static final int DEVCAP_POSTSCRIPT = 0x0010;

    private String printer;

    private PrinterName name;

    private String port;

    private MediaSizeName[] mediaSizeNames;

    private MediaPrintableArea[] mediaPrintables;

    private MediaTray[] mediaTrays;

    private PrinterResolution[] printRes;

    private HashMap<MediaSizeName, MediaPrintableArea> mpaMap;

    private int nCopies;

    private int prnCaps;

    private int[] defaultSettings;

    private boolean gotTrays;

    private boolean gotCopies;

    private boolean mediaInitialized;

    private boolean mpaListInitialized;

    private ArrayList<Integer> idList;

    private MediaSize[] mediaSizes;

    private boolean isInvalid;

    Win32PrintService(String name) {

        if (name == null) {

            throw new IllegalArgumentException("null printer name");

        }

        printer = name;

        // initialize flags

        mediaInitialized = false;

        gotTrays = false;

        gotCopies = false;

        isInvalid = false;

        printRes = null;

        prnCaps = 0;

        defaultSettings = null;

        port = null;

    }

    public void invalidateService() {

        isInvalid = true;

    }

    public String getName() {

        return printer;

    }

    private PrinterName getPrinterName() {

        if (name == null) {

            name = new PrinterName(printer, null);

        }

        return name;

    }

    public int findPaperID(MediaSizeName msn) {

        if (msn instanceof Win32MediaSize) {

            Win32MediaSize winMedia = (Win32MediaSize)msn;

            return winMedia.getDMPaper();

        } else {

            for (int id=0; id<dmPaperToPrintService.length;id++) {

                if (dmPaperToPrintService[id].equals(msn)) {

                    return id+1; // DMPAPER_LETTER == 1

                }

            }

            if (msn.equals(MediaSizeName.ISO_A2)) {

                return DMPAPER_A2;

            }

            else if (msn.equals(MediaSizeName.ISO_A6)) {

                return DMPAPER_A6;

            }

            else if (msn.equals(MediaSizeName.JIS_B6)) {

                return DMPAPER_B6_JIS;

            }

        }

        // If not found in predefined Windows ID, then we search through

        // the returned IDs of the driver because they can define their own

        // unique IDs.

        initMedia();

        if ((idList != null) && (mediaSizes != null) &&

            (idList.size() == mediaSizes.length)) {

            for (int i=0; i< idList.size(); i++) {

                if (mediaSizes[i].getMediaSizeName() == msn) {

                    return idList.get(i).intValue();

                }

            }

        }

        return 0;

    }

    public int findTrayID(MediaTray tray) {

        getMediaTrays(); // make sure they are initialised.

        if (tray instanceof Win32MediaTray) {

            Win32MediaTray winTray = (Win32MediaTray)tray;

            return winTray.getDMBinID();

        }

        for (int id=0; id<dmPaperBinToPrintService.length; id++) {

            if (tray.equals(dmPaperBinToPrintService[id])) {

                return id+1; // DMBIN_FIRST = 1;

            }

        }

        return 0; // didn't find the tray

    }

    public MediaTray findMediaTray(int dmBin) {

        if (dmBin >= 1 && dmBin <= dmPaperBinToPrintService.length) {

            return dmPaperBinToPrintService[dmBin-1];

        }

        MediaTray[] trays = getMediaTrays();

        if (trays != null) {

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

                if(trays[i] instanceof Win32MediaTray) {

                    Win32MediaTray win32Tray = (Win32MediaTray)trays[i];

                    if (win32Tray.winID == dmBin) {

                        return win32Tray;

                    }

                }

            }

        }

        return Win32MediaTray.AUTO;

    }

    public MediaSizeName findWin32Media(int dmIndex) {

        if (dmIndex >= 1 && dmIndex <= dmPaperToPrintService.length) {

            return dmPaperToPrintService[dmIndex - 1];

        }

        switch(dmIndex) {

            /* matching media sizes with indices beyond

               dmPaperToPrintService's length */

            case DMPAPER_A2:

                return MediaSizeName.ISO_A2;

            case DMPAPER_A6:

                return MediaSizeName.ISO_A6;

            case DMPAPER_B6_JIS:

                return MediaSizeName.JIS_B6;

            default:

                return null;

        }

    }

    private boolean addToUniqueList(ArrayList<MediaSizeName> msnList,

                                    MediaSizeName mediaName) {

        MediaSizeName msn;

        for (int i=0; i< msnList.size(); i++) {

            msn = msnList.get(i);

            if (msn == mediaName) {

                return false;

            }

        }

        msnList.add(mediaName);

        return true;

    }

    private synchronized void initMedia() {

        if (mediaInitialized == true) {

            return;

        }

        mediaInitialized = true;

        int[] media = getAllMediaIDs(printer, getPort());

        if (media == null) {

            return;

        }

        ArrayList<MediaSizeName> msnList = new ArrayList<>();

        ArrayList<Win32MediaSize> trailingWmsList = new ArrayList<Win32MediaSize>();

        MediaSizeName mediaName;

        boolean added;

        boolean queryFailure = false;

        float[] prnArea;

        // Get all mediaSizes supported by the printer.

        // We convert media to ArrayList idList and pass this to the

        // function for getting mediaSizes.

        // This is to ensure that mediaSizes and media IDs have 1-1 correspondence.

        // We remove from ID list any invalid mediaSize.  Though this is rare,

        // it happens in HP 4050 German driver.

        idList = new ArrayList<>();

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

            idList.add(Integer.valueOf(media[i]));

        }

        ArrayList<String> dmPaperNameList = new ArrayList<String>();

        mediaSizes = getMediaSizes(idList, media, dmPaperNameList);

        for (int i = 0; i < idList.size(); i++) {

            // match Win ID with our predefined ID using table

            mediaName = findWin32Media(idList.get(i).intValue());

            // Verify that this standard size is the same size as that

            // reported by the driver. This should be the case except when

            // the driver is mis-using a standard windows paper ID.

            if (mediaName != null &&

                idList.size() == mediaSizes.length) {

                MediaSize win32Size = MediaSize.getMediaSizeForName(mediaName);

                MediaSize driverSize = mediaSizes[i];

                int error = 2540; // == 1/10"

                if (Math.abs(win32Size.getX(1)-driverSize.getX(1)) > error ||

                    Math.abs(win32Size.getY(1)-driverSize.getY(1)) > error)

                {

                   mediaName = null;

                }

            }

            boolean dmPaperIDMatched = (mediaName != null);

            // No match found, then we get the MediaSizeName out of the MediaSize

            // This requires 1-1 correspondence, lengths must be checked.

            if ((mediaName == null) && (idList.size() == mediaSizes.length)) {

                mediaName = mediaSizes[i].getMediaSizeName();

            }

            // Add mediaName to the msnList

            added = false;

            if (mediaName != null) {

                added = addToUniqueList(msnList, mediaName);

            }

            if ((!dmPaperIDMatched || !added) && (idList.size() == dmPaperNameList.size())) {

                /* The following block allows to add such media names to the list, whose sizes

                 * matched with media sizes predefined in JDK, while whose paper IDs did not,

                 * or whose sizes and paper IDs both did not match with any predefined in JDK.

                 */

                Win32MediaSize wms = Win32MediaSize.findMediaName(dmPaperNameList.get(i));

                if ((wms == null) && (idList.size() == mediaSizes.length)) {

                    wms = new Win32MediaSize(dmPaperNameList.get(i), idList.get(i));

                    mediaSizes[i] = new MediaSize(mediaSizes[i].getX(MediaSize.MM),

                        mediaSizes[i].getY(MediaSize.MM), MediaSize.MM, wms);

                }

                if ((wms != null) && (wms != mediaName)) {

                    if (!added) {

                        added = addToUniqueList(msnList, mediaName = wms);

                    } else {

                        trailingWmsList.add(wms);

                    }

                }

            }

        }

        for (Win32MediaSize wms : trailingWmsList) {

            added = addToUniqueList(msnList, wms);

        }

        // init mediaSizeNames

        mediaSizeNames = new MediaSizeName[msnList.size()];

        msnList.toArray(mediaSizeNames);

    }

    /*

     * Gets a list of MediaPrintableAreas using a call to native function.

     *  msn is MediaSizeName used to get a specific printable area.  If null,

     *  it will get all the supported MediPrintableAreas.

     */

    private synchronized MediaPrintableArea[] getMediaPrintables(MediaSizeName msn)

    {

        if (msn == null)  {

            if (mpaListInitialized == true) {

                return mediaPrintables;

            }

        } else {

            // get from cached mapping of MPAs

            if (mpaMap != null && (mpaMap.get(msn) != null)) {

                MediaPrintableArea[] mpaArr = new MediaPrintableArea[1];

                mpaArr[0] = mpaMap.get(msn);

                return mpaArr;

            }

        }

        initMedia();

        if ((mediaSizeNames == null) || (mediaSizeNames.length == 0)) {

            return null;

        }

        MediaSizeName[] loopNames;

        if (msn != null) {

            loopNames = new MediaSizeName[1];

            loopNames[0] = msn;

        } else {

            loopNames = mediaSizeNames;

        }

        if (mpaMap == null) {

            mpaMap = new HashMap<>();

        }

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

            MediaSizeName mediaName = loopNames[i];

            if (mpaMap.get(mediaName) != null) {

                continue;

             }

            if (mediaName != null) {

                int defPaper = findPaperID(mediaName);

                float[] prnArea = (defPaper != 0) ? getMediaPrintableArea(printer, defPaper) : null;

                MediaPrintableArea printableArea = null;

                if (prnArea != null) {

                    try {

                        printableArea = new MediaPrintableArea(prnArea[0],

                                                               prnArea[1],

                                                               prnArea[2],

                                                               prnArea[3],

                                                 MediaPrintableArea.INCH);

                        mpaMap.put(mediaName, printableArea);

                    }

                    catch (IllegalArgumentException e) {

                    }

                } else {

                    // if getting  MPA failed, we use MediaSize

                    MediaSize ms = MediaSize.getMediaSizeForName(mediaName);

                    if (ms != null) {

                        try {