/*
 * Copyright (c) 2003, 2017, 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.
 *
 * 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.
 */

/*
 * @test
 * @bug 4641872
 * @summary Tests writing compression modes of BMP plugin
 * @modules java.desktop/com.sun.imageio.plugins.bmp
 */

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Transparency;
import java.awt.color.ColorSpace;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.ComponentColorModel;
import java.awt.image.DataBuffer;
import java.awt.image.DirectColorModel;
import java.awt.image.IndexColorModel;
import java.awt.image.PixelInterleavedSampleModel;
import java.awt.image.Raster;
import java.awt.image.SampleModel;
import java.awt.image.SinglePixelPackedSampleModel;
import java.awt.image.WritableRaster;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

import javax.imageio.IIOImage;
import javax.imageio.ImageIO;
import javax.imageio.ImageReader;
import javax.imageio.ImageTypeSpecifier;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;
import javax.imageio.metadata.IIOMetadata;
import javax.imageio.plugins.bmp.BMPImageWriteParam;
import javax.imageio.stream.ImageOutputStream;
import javax.swing.JComponent;
import javax.swing.JFrame;

import com.sun.imageio.plugins.bmp.BMPMetadata;

public class BMPCompressionTest {

    static final String format = "BMP";

    public static void main(String[] args) {

        ImageWriter iw = null;
        Iterator writers = ImageIO.getImageWritersByFormatName(format);
        if (!writers.hasNext()) {
            throw new RuntimeException("No available Image writer for "+format);
        }
        iw = (ImageWriter)writers.next();


        Iterator tests = Test.createTestSet(iw);

        while(tests.hasNext()) {

            Test t = (Test)tests.next();
            System.out.println(t.getDescription());
            t.doTest();
        }

    }


    static class Test {
        static ImageWriter iw;
        private BufferedImage img;
        private String description;
        private BMPImageWriteParam param;
        private IIOMetadata meta;


        public static Iterator createTestSet(ImageWriter w) {
            List l = new LinkedList();

            Test.iw = w;

            // variate compression types
            BMPImageWriteParam param = (BMPImageWriteParam)iw.getDefaultWriteParam();
            param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
            param.setCompressionType("BI_RGB");
            if (param.canWriteCompressed()) {
                String[] cTypes = param.getCompressionTypes();
                String[] cDescr = param.getCompressionQualityDescriptions();
                float[] cValues = param.getCompressionQualityValues();

                if (cDescr == null) {
                    System.out.println("There are no compression quality description!");
                } else {
                    for(int i=0; i<cDescr.length; i++) {
                        System.out.println("Quality[" + i + "]=\""+cDescr[i]+"\"");
                    }
                }
                if (cValues == null) {
                    System.out.println("There are no compression quality values!");
                } else {
                    for(int i=0; i<cValues.length; i++) {
                        System.out.println("Value["+i+"]=\""+cValues[i]+"\"");
                    }
                }

                for(int i=0; i<cTypes.length; i++) {
                    String compressionType = cTypes[i];
                    BufferedImage img = null;

                    int type = BufferedImage.TYPE_INT_BGR;
                    try {
                        img = createTestImage(type);
                        if (compressionType.equals("BI_RLE8")) {
                            img = createTestImage2(8, DataBuffer.TYPE_BYTE);
                        } else if (compressionType.equals("BI_RLE4")) {
                            img = createTestImage3(4, DataBuffer.TYPE_BYTE);
                        } else if (compressionType.equals("BI_BITFIELDS")) {
                            img = createTestImage4(32);
                        }

                    } catch (IOException ex) {
                        throw new RuntimeException("Unable to create test image");
                    }
                    BMPImageWriteParam p = (BMPImageWriteParam)iw.getDefaultWriteParam();
                    System.out.println("Current compression type is \""+cTypes[i]+"\"");
                    p.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
                    p.setCompressionType(compressionType);

                    IIOMetadata md = iw.getDefaultImageMetadata(new ImageTypeSpecifier(img), p);

                    l.add( new Test(p, md, img));
                }
            }
            //     }
            return l.iterator();

        }

        private Test(BMPImageWriteParam p, IIOMetadata md, BufferedImage i) {
            param = p;
            meta = md;
            img = i;


            description = "Compression type is " + p.getCompressionType();
        }

        public String getDescription() {
            return description;
        }

        public void doTest() {
            try {
                System.out.println(this.getDescription());
                if (param.getCompressionMode() != ImageWriteParam.MODE_EXPLICIT) {
                    System.out.println("Warning: compression mode is not MODE_EXPLICIT");
                }
                // change metadata according to ImageWriteParam
                IIOMetadata new_meta = iw.convertImageMetadata(meta, new ImageTypeSpecifier(img), param);

                IIOImage iio_img = new IIOImage(img, null, new_meta);

                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                ImageOutputStream ios = ImageIO.createImageOutputStream(baos);
                iw.setOutput(ios);
                System.out.print("write image...");
                System.out.println("Current compression Type is \""+param.getCompressionType()+"\"");
                iw.write(new_meta, iio_img, param);
                //iw.write(iio_img);
                System.out.println("OK");
                System.out.print("read image ... ");
                ios.flush();

                byte[] ba_image = baos.toByteArray();

                System.out.println("Array length=" + ba_image.length);
                FileOutputStream fos = new FileOutputStream(new File(param.getCompressionType()+".bmp"));
                fos.write(ba_image);
                fos.flush();
                fos = null;
                ByteArrayInputStream bais = new ByteArrayInputStream(ba_image);

                ImageReader ir = ImageIO.getImageReader(iw);
                ir.setInput(ImageIO.createImageInputStream(bais));

                BufferedImage res = ir.read(0);
                System.out.println("OK");

                if (!param.getCompressionType().equals("BI_JPEG")) {
                    System.out.print("compare images ... ");
                    boolean r = compare(img,res);
                    System.out.println(r?"OK":"FAILED");
                    if (!r) {
                        throw new RuntimeException("Compared images are not equals. Test failed.");
                    }
                }


                BMPMetadata mdata = (BMPMetadata)ir.getImageMetadata(0);

                if (!param.getCompressionType().equals(param.getCompressionTypes()[mdata.compression])) {
                    throw new RuntimeException("Different compression value");
                }

            } catch (Exception ex) {
                ex.printStackTrace();
                throw new RuntimeException("Unexpected exception: " + ex);
            }

        }

        private boolean compare(final BufferedImage in, final BufferedImage out) {

            final int width = in.getWidth();
            int height = in.getHeight();
            if (out.getWidth() != width || out.getHeight() != height) {
                throw new RuntimeException("Dimensions changed!");
            }

            Raster oldras = in.getRaster();
            ColorModel oldcm = in.getColorModel();
            Raster newras = out.getRaster();
            ColorModel newcm = out.getColorModel();

            for (int j = 0; j < height; j++) {
                for (int i = 0; i < width; i++) {
                    Object oldpixel = oldras.getDataElements(i, j, null);
                    int oldrgb = oldcm.getRGB(oldpixel);
                    int oldalpha = oldcm.getAlpha(oldpixel);

                    Object newpixel = newras.getDataElements(i, j, null);
                    int newrgb = newcm.getRGB(newpixel);
                    int newalpha = newcm.getAlpha(newpixel);

                    if (newrgb != oldrgb ||
                        newalpha != oldalpha) {
                        // showDiff(in, out);
                        throw new RuntimeException("Pixels differ at " + i +
                                                   ", " + j + " new = " + Integer.toHexString(newrgb) + " old = " + Integer.toHexString(oldrgb));
                    }
                }
            }
            return true;
        }

        private static BufferedImage createTestImage2(int nbits, int transfertype) {
            final int colorShift = 2;
            int SIZE = 256;
            BufferedImage image = null;

            ColorSpace colorSpace =
                ColorSpace.getInstance(ColorSpace.CS_GRAY);
            ColorModel colorModel =
                new ComponentColorModel(colorSpace,
                                        new int[] {nbits},
                                        false,
                                        false,
                                        Transparency.OPAQUE,
                                        transfertype);

            SampleModel sampleModel =
                new PixelInterleavedSampleModel(transfertype,
                                                SIZE,
                                                SIZE,
                                                1,
                                                SIZE,
                                                new int[] {0});

            image =
                new BufferedImage(colorModel,
                                  Raster.createWritableRaster(sampleModel, null),
                                  false, null);
            WritableRaster raster = image.getWritableTile(0, 0);
            int[] samples = raster.getSamples(0, 0, SIZE, SIZE, 0, (int[])null);
            int off = 0;
            int[] row = new int[SIZE];
            for(int i = 0; i < SIZE; i++) {
                Arrays.fill(row, i << colorShift);
                System.arraycopy(row, 0, samples, off, SIZE);
                off += SIZE;
            }
            raster.setSamples(0, 0, SIZE, SIZE, 0, samples);

            return image;
        }


        private static BufferedImage createTestImage3(int nbits, int transfertype) {
            final int colorShift = 2;
            int SIZE = 256;
            BufferedImage image = null;

            ColorSpace colorSpace =
                ColorSpace.getInstance(ColorSpace.CS_sRGB);
            ColorModel colorModel =
                new IndexColorModel(nbits,
                                    4,
                                    new byte[] { (byte)255,   0,   0, (byte)255},
                                    new byte[] {   0, (byte)255,   0, (byte)255},
                                    new byte[] {   0,   0, (byte)255, (byte)255});

            SampleModel sampleModel =
                new PixelInterleavedSampleModel(transfertype,
                                                SIZE,
                                                SIZE,
                                                1,
                                                SIZE,
                                                new int[] {0});

            image =
                new BufferedImage(colorModel,
                                  Raster.createWritableRaster(sampleModel, null),

                                  false, null);

            Graphics2D g = image.createGraphics();
            g.setColor(Color.white);
            g.fillRect(0,0, SIZE, SIZE);
            g.setColor(Color.red);
            g.fillOval(10, 10, SIZE -20, SIZE-20);

            return image;
        }

        private static BufferedImage createTestImage4(int nbits) {
            int SIZE = 10;


            BufferedImage image = null;

            ColorSpace colorSpace =
                ColorSpace.getInstance(ColorSpace.CS_sRGB);
            ColorModel colorModel =
                new DirectColorModel(colorSpace,
                                     nbits, 0xff0000, 0x00ff00, 0x0000ff, 0x000000, false, DataBuffer.TYPE_INT);

            SampleModel sampleModel =
                new SinglePixelPackedSampleModel(DataBuffer.TYPE_INT,
                                                SIZE,
                                                SIZE,
                                      new int[] { 0xff0000, 0x00ff00, 0x0000ff} );


            image =
                new BufferedImage(colorModel,
                                  Raster.createWritableRaster(sampleModel, null),

                                  false, null);

            Graphics2D g = image.createGraphics();
            g.setColor(Color.red);
            g.fillRect(0,0, SIZE, SIZE);
            g.setColor(Color.green);
            //g.fillOval(10, 10, SIZE -20, SIZE-20);
            g.drawLine(7, 0, 7, SIZE);
            g.setColor(Color.blue);
            g.drawLine(1, 0, 1, SIZE);
            g.setColor(Color.white);
            g.drawLine(3, 0, 3, SIZE);
            g.setColor(Color.yellow);
            g.drawLine(5, 0, 5, SIZE);
            return image;
        }

        private static BufferedImage createTestImage(int type)
          throws IOException {

            int w = 200;
            int h = 200;
            BufferedImage b = new BufferedImage(w, h, type);
            Graphics2D g = b.createGraphics();
            g.setColor(Color.white);
            g.fillRect(0,0, w, h);
            g.setColor(Color.black);
            g.fillOval(10, 10, w -20, h-20);

            return b;
        }


    }

    private static void showDiff(final BufferedImage in,
                                 final BufferedImage out) {
        final int width = in.getWidth();
        final int height = in.getHeight();

        JFrame f = new JFrame("");
        f.getContentPane().add( new JComponent() {
                public Dimension getPreferredSize() {
                    return new Dimension(2*width+2, height);
                }
                public void paintComponent(Graphics g) {
                    g.setColor(Color.black);
                    g.drawImage(in, 0,0, null);

                    g.drawImage(out, width+2, 0, null);
                }
            });
        f.pack();
        f.setVisible(true);
    }

}