/*

 * Copyright 2007 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.

 *

 * 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.

 */

/*

 * @test

 * @bug     6570475

 * @summary Test verifies that palette comparison procedure of

 *          ImageRepresentation class does not produce extra transparent

 *          pixels.

 *

 * @run     main LUTCompareTest

 */

import java.awt.Color;

import java.awt.Dimension;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.MediaTracker;

import java.awt.Toolkit;

import java.awt.image.BufferedImage;

import java.awt.image.DataBuffer;

import java.awt.image.ImageObserver;

import java.awt.image.IndexColorModel;

import java.awt.image.WritableRaster;

import java.io.File;

import java.io.IOException;

import java.util.Arrays;

import javax.imageio.IIOImage;

import javax.imageio.ImageIO;

import javax.imageio.ImageWriteParam;

import javax.imageio.ImageWriter;

import javax.imageio.stream.ImageOutputStream;

import javax.swing.JComponent;

import javax.swing.JFrame;

public class LUTCompareTest implements ImageObserver {

    public static void main(String[] args) throws IOException {

        Image img = createTestImage();

        Toolkit tk = Toolkit.getDefaultToolkit();

        LUTCompareTest o = new LUTCompareTest(img);

        tk.prepareImage(img, -1, -1, o);

        while(!o.isImageReady()) {

            synchronized(lock) {

                try {

                    lock.wait(200);

                } catch (InterruptedException e) {

                }

            }

        }

        checkResults(img);

    }

    private static Object lock = new Object();

    Image image;

    boolean isReady = false;

    public LUTCompareTest(Image img) {

        this.image = img;

    }

    public boolean imageUpdate(Image image, int info,

                               int x, int y, int w, int h) {

        if (image == this.image) {

            System.out.println("Image status: " + dump(info));

            synchronized(this) {

                isReady = (info & ImageObserver.ALLBITS) != 0;

                    if (isReady) {

                        synchronized(lock) {

                            lock.notifyAll();

                        }

                    }

            }

            return !isReady;

        } else {

            return true;

        }

    }

    public synchronized boolean isImageReady() {

        return isReady;

    }

    private static void checkResults(Image image) {

        BufferedImage buf = new BufferedImage(w, h,

                                              BufferedImage.TYPE_INT_RGB);

        Graphics2D g = buf.createGraphics();

        g.setColor(Color.pink);

        g.fillRect(0, 0, w, h);

        g.drawImage(image, 0, 0, null);

        g.dispose();

        int rgb = buf.getRGB(w/2, h/2);

        System.out.printf("Result color: %x\n", rgb);

        /* Buffered image should be the same as the last frame

         * of animated sequence (which is filled with blue).

         * Any other color indicates the problem.

         */

        if (rgb != 0xff0000ff) {

            throw new RuntimeException("Test FAILED!");

        }

        System.out.println("Test PASSED.");

    }

    private static int w = 100;

    private static int h = 100;

    /* Create test image with two frames:

     *  1) with {red, red} palette

     *  2) with {blue, red } palette

     */

    private static Image createTestImage() throws IOException  {

        BufferedImage frame1 = createFrame(new int[] { 0xffff0000, 0xffff0000 });

        BufferedImage frame2 = createFrame(new int[] { 0xff0000ff, 0xffff0000 });

        ImageWriter writer = ImageIO.getImageWritersByFormatName("GIF").next();

        ImageOutputStream ios = ImageIO.createImageOutputStream(new File("lut_test.gif"));

        ImageWriteParam param = writer.getDefaultWriteParam();

        writer.setOutput(ios);

        writer.prepareWriteSequence(null);

        writer.writeToSequence(new IIOImage(frame1, null, null), param);

        writer.writeToSequence(new IIOImage(frame2, null, null), param);

        writer.endWriteSequence();

        writer.reset();

        writer.dispose();

        ios.flush();

        ios.close();

        return Toolkit.getDefaultToolkit().createImage("lut_test.gif");

    }

    private static BufferedImage createFrame(int[] palette) {

        IndexColorModel icm = new IndexColorModel(getNumBits(palette.length),

            palette.length, palette, 0, false, -1, DataBuffer.TYPE_BYTE);

        WritableRaster wr = icm.createCompatibleWritableRaster(w, h);

        int[] samples = new int[w * h];

        Arrays.fill(samples, 0);

        wr.setSamples(0, 0, w, h, 0, samples);

        BufferedImage img = new BufferedImage(icm, wr, false, null);

        return img;

    }

    private static int getNumBits(int size) {

        if (size < 0) {

            throw new RuntimeException("Invalid palette size: " + size);

        } else if (size < 3) {

            return 1;

        } else if (size < 5) {

            return 2;

        } else {

            throw new RuntimeException("Palette size is not supported: " + size);

        }

    }

     private static String[] name = new String[] {

        "WIDTH", "HEIGHT", "PROPERTIES", "SOMEBITS",

        "FRAMEBITS", "ALLBITS", "ERROR", "ABORT"

    };

    private static String dump(int info) {

        String res = "";

        int count = 0;

        while (info != 0) {

            //System.out.println("info = " + info);

            if ((info & 0x1) == 1) {

                res += name[count];

                if ((info >> 1) != 0) {

                    res += " ";

                }

            }

            count ++;

            info = (info >> 1);

        }

        return res;

    }

}