/*

 * Copyright 2000-2006 Sun Microsystems, Inc.  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.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package sun.print;

import java.io.File;

import java.net.URI;

import java.net.URISyntaxException;

import java.net.URL;

import java.util.Vector;

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.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.ResolutionSyntax;

import javax.print.attribute.standard.PrinterResolution;

import javax.print.attribute.standard.SheetCollate;

import javax.print.event.PrintServiceAttributeListener;

import java.util.ArrayList;

import sun.print.SunPrinterJobService;

public class Win32PrintService implements PrintService, AttributeUpdater,

                                          SunPrinterJobService {

    public static MediaSize[] predefMedia;

    static {

        Class c = Win32MediaSize.class;

    }

    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;

    // 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;

    transient private PrintServiceAttributeSet lastSet;

    transient private ServiceNotifier notifier = null;

    private MediaSizeName[] mediaSizeNames;

    private MediaPrintableArea[] mediaPrintables;

    private MediaTray[] mediaTrays;

    private PrinterResolution[] printRes;

    private int nCopies;

    private int prnCaps;

    private int[] defaultSettings;

    private boolean gotTrays;

    private boolean gotCopies;

    private boolean mediaInitialized;

    private ArrayList 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;

            }

        }

        return 0;

    }

    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) {

           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 dmPaperToPrintService[dmIndex - 1];

            }

        }

        return null;

    }

    private boolean addToUniqueList(ArrayList msnList, MediaSizeName mediaName) {

        MediaSizeName msn;

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

            msn = (MediaSizeName)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 msnList = new ArrayList();

        ArrayList printableList = new ArrayList();

        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++) {

        }

        mediaSizes = getMediaSizes(idList, media);

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

            // match Win ID with our predefined ID using table

            mediaName = findWin32Media(((Integer)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;

                }

            }

            // 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

            if (mediaName != null) {

                added = addToUniqueList(msnList, mediaName);

                // get MediaPrintableArea only for supported MediaSizeName ?

                if (added && !queryFailure) {

                    prnArea=getMediaPrintableArea(printer,

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

                    if (prnArea != null) {

                        try {

                            MediaPrintableArea mpa =

                                new MediaPrintableArea(prnArea[0],

                                                       prnArea[1],

                                                       prnArea[2],

                                                       prnArea[3],

                                                       MediaPrintableArea.INCH);

                            printableList.add(mpa);

                        } catch (IllegalArgumentException iae) {

                        }

                    } else {

                        // Calling getMediaPrintableArea causes

                        // much overhead so if first attempt failed, we should

                        // just bail out.

                        if (i==0) {

                            queryFailure = true;

                        }

                    }

                }

            }

        }

        // init mediaSizeNames

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

        msnList.toArray(mediaSizeNames);

        // init mediaPrintables

        mediaPrintables = new MediaPrintableArea[printableList.size()];

        printableList.toArray(mediaPrintables);

    }

    private synchronized MediaTray[] getMediaTrays() {

        if (gotTrays == true && mediaTrays != null) {

            return mediaTrays;

        }

        String prnPort = getPort();

        int[] mediaTr = getAllMediaTrays(printer, prnPort);

        String[] winMediaTrayNames = getAllMediaTrayNames(printer, prnPort);

        if ((mediaTr == null) || (winMediaTrayNames == null)){

            return null;

        }

        /* first count how many valid bins there are so we can allocate

         * an array of the correct size

         */

        int nTray = 0;

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

            if (mediaTr[i] > 0) nTray++;

        }

        MediaTray[] arr = new MediaTray[nTray];

        int dmBin;

        for (int i = 0, j=0; i < mediaTr.length; i++) {

            dmBin = mediaTr[i];

            if (dmBin > 0) {

                // check for unsupported DMBINs and create new Win32MediaTray

                if ((dmBin > dmPaperBinToPrintService.length)

                    || (dmPaperBinToPrintService[dmBin-1] == null)) {

                    arr[j++] = new Win32MediaTray(dmBin, winMediaTrayNames[i]);

                } else {

                    arr[j++] = dmPaperBinToPrintService[dmBin-1];

                }

            }

            // no else - For invalid ids, just ignore it because assigning a "default"

            // value may result in duplicate trays.

        }

        mediaTrays = arr;

        gotTrays = true;

        return mediaTrays;

    }

    private boolean isSameSize(float w1, float h1, float w2, float h2) {

        float diffX = w1 - w2;

        float diffY = h1 - h2;

        // Get diff of reverse dimensions

        // EPSON Stylus COLOR 860 reverses envelope's width & height

        float diffXrev = w1 - h2;

        float diffYrev = h1 - w2;

        if (((Math.abs(diffX)<=1) && (Math.abs(diffY)<=1)) ||

            ((Math.abs(diffXrev)<=1) && (Math.abs(diffYrev)<=1))){

          return true;

        } else {

          return false;

        }

    }

    public MediaSizeName findMatchingMediaSizeNameMM (float w, float h){

        if (predefMedia != null) {

            for (int k=0; k<predefMedia.length;k++) {

                if (predefMedia[k] == null) {

                    continue;

                }

                if (isSameSize(predefMedia[k].getX(MediaSize.MM),

                               predefMedia[k].getY(MediaSize.MM),

                               w, h)) {

                  return predefMedia[k].getMediaSizeName();

                }

            }

        }

        return null;

    }

    private MediaSize[] getMediaSizes(ArrayList idList, int[] media) {

        String prnPort = getPort();

        int[] mediaSz = getAllMediaSizes(printer, prnPort);

        String[] winMediaNames = getAllMediaNames(printer, prnPort);

        MediaSizeName msn = null;

        MediaSize ms = null;

        float wid, ht;

        if ((mediaSz == null) || (winMediaNames == null)) {

            return null;

        }

        int nMedia = mediaSz.length/2;

        ArrayList msList = new ArrayList();

        for (int i = 0; i < nMedia; i++, ms=null) {

            wid = mediaSz[i*2]/10f;

            ht = mediaSz[i*2+1]/10f;

          // Make sure to validate wid & ht.

          // HP LJ 4050 (german) causes IAE in Sonderformat paper, wid & ht

          // returned is not constant.

          if ((wid <= 0) || (ht <= 0)) {

            //Remove corresponding ID from list

            if (nMedia == media.length) {

              idList.remove(idList.indexOf(remObj));

            }

            continue;

          }

          // Find matching media using dimensions.

          // This call matches only with our own predefined sizes.

          msn = findMatchingMediaSizeNameMM(wid, ht);

          if (msn != null) {