/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.commons.imaging.roundtrip;

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import org.apache.commons.imaging.ImageFormat;
import org.apache.commons.imaging.ImageReadException;
import org.apache.commons.imaging.ImageWriteException;
import org.apache.commons.imaging.Sanselan;
import org.apache.commons.imaging.SanselanConstants;
import org.apache.commons.imaging.SanselanTest;
import org.apache.commons.imaging.common.RgbBufferedImageFactory;
import org.apache.commons.imaging.util.Debug;
import org.apache.commons.imaging.util.IoUtils;

public class RoundtripTest extends SanselanTest
{
    private static final int COLOR_FULL_RGB = 0;
    private static final int COLOR_LIMITED_INDEX = 1;
    private static final int COLOR_GRAYSCALE = 2;
    private static final int COLOR_BITMAP = 3;

    private static class FormatInfo
    {

        public final ImageFormat format;
        public final boolean canRead;
        public final boolean canWrite;
        public final int colorSupport;
        public final boolean identicalSecondWrite;

        public FormatInfo(ImageFormat format, boolean canRead,
                boolean canWrite, int colorSupport,
                final boolean identicalSecondWrite)
        {
            this.canRead = canRead;
            this.canWrite = canWrite;
            this.colorSupport = colorSupport;
            this.format = format;
            this.identicalSecondWrite = identicalSecondWrite;
        }
    }

    private static final FormatInfo FORMAT_INFOS[] = { //
            new FormatInfo(ImageFormat.IMAGE_FORMAT_PNG, true, true,
                    COLOR_FULL_RGB, true), //
            new FormatInfo(ImageFormat.IMAGE_FORMAT_GIF, true, true,
                    COLOR_LIMITED_INDEX, true), //
            new FormatInfo(ImageFormat.IMAGE_FORMAT_ICO, true, true,
                    COLOR_FULL_RGB, true), //
            new FormatInfo(ImageFormat.IMAGE_FORMAT_TIFF, true, true,
                    COLOR_FULL_RGB, true), //
            new FormatInfo(ImageFormat.IMAGE_FORMAT_JPEG, true, false,
                    COLOR_FULL_RGB, true), //
            new FormatInfo(ImageFormat.IMAGE_FORMAT_BMP, true, true,
                    COLOR_FULL_RGB, true), //
            new FormatInfo(ImageFormat.IMAGE_FORMAT_PSD, true, false,
                    COLOR_FULL_RGB, true), //
            new FormatInfo(ImageFormat.IMAGE_FORMAT_PBM, true, true,
                    COLOR_BITMAP, true), //
            new FormatInfo(ImageFormat.IMAGE_FORMAT_PGM, true, true,
                    COLOR_GRAYSCALE, true), //
            new FormatInfo(ImageFormat.IMAGE_FORMAT_PPM, true, true,
                    COLOR_FULL_RGB, true), //
            // new FormatInfo(ImageFormat.IMAGE_FORMAT_PNM, true, true,
            // COLOR_FULL_RGB, true), //
            new FormatInfo(ImageFormat.IMAGE_FORMAT_TGA, false, false,
                    COLOR_FULL_RGB, true), //
            new FormatInfo(ImageFormat.IMAGE_FORMAT_WBMP, true, true,
                    COLOR_BITMAP, true), //
            new FormatInfo(ImageFormat.IMAGE_FORMAT_PCX, true, true,
                    COLOR_FULL_RGB, true), //
            new FormatInfo(ImageFormat.IMAGE_FORMAT_DCX, true, true,
                    COLOR_FULL_RGB, true), //
            new FormatInfo(ImageFormat.IMAGE_FORMAT_XBM, true, true,
                    COLOR_BITMAP, false), //
            new FormatInfo(ImageFormat.IMAGE_FORMAT_XPM, true, true,
                    COLOR_FULL_RGB, false), //
    };

    private BufferedImage createArgbBitmapImage(int width, int height)
    {
        BufferedImage result = new BufferedImage(width, height,
                BufferedImage.TYPE_INT_ARGB);
        for (int x = 0; x < width; x++)
            for (int y = 0; y < height; y++)
            {
                // alternating black and white.
                int modulator = y + 2; // make sure lines vary.
                int argb = (x + y) % modulator == 0 ? 0xff000000 : 0xffffffff;
                result.setRGB(x, y, argb);
            }
        return result;
    }

    private BufferedImage createBitmapBitmapImage(int width, int height)
    {
        BufferedImage result = new BufferedImage(width, height,
                BufferedImage.TYPE_BYTE_BINARY);
        for (int x = 0; x < width; x++)
            for (int y = 0; y < height; y++)
            {
                // alternating black and white.
                int modulator = y + 2; // make sure lines vary.
                int argb = (x + y) % modulator == 0 ? 0xff000000 : 0xffffffff;
                result.setRGB(x, y, argb);
            }
        return result;
    }

    private BufferedImage createArgbGrayscaleImage(int width, int height)
    {
        BufferedImage result = new BufferedImage(width, height,
                BufferedImage.TYPE_INT_ARGB);
        for (int x = 0; x < width; x++)
            for (int y = 0; y < height; y++)
            {
                int value = (256 * (x + y)) / (width + height);
                int argb = (0xff << 24) | (value << 16) | (value << 8)
                        | (value << 0);

                result.setRGB(x, y, argb);
            }
        return result;
    }

    private BufferedImage createGrayscaleGrayscaleImage(int width, int height)
    {
        BufferedImage result = new BufferedImage(width, height,
                BufferedImage.TYPE_BYTE_GRAY);
        for (int x = 0; x < width; x++)
            for (int y = 0; y < height; y++)
            {
                int value = (256 * (x + y)) / (width + height);
                int argb = (0xff << 24) | (value << 16) | (value << 8)
                        | (value << 0);

                result.setRGB(x, y, argb);
            }
        return result;
    }

    private BufferedImage createLimitedColorImage(int width, int height)
    {
        int colors[] = { 0xffffffff, 0xff000000, 0xfff00000, 0xff0000ff,
                0xff123456, 0xfffefeff, 0xff7f817f, };

        BufferedImage result = new BufferedImage(width, height,
                BufferedImage.TYPE_INT_ARGB);
        for (int x = 0; x < width; x++)
            for (int y = 0; y < height; y++)
            {
                int argb = colors[(x + y) % colors.length];
                result.setRGB(x, y, argb);
            }
        return result;
    }

    private BufferedImage createFullColorImage(int width, int height)
    {
        BufferedImage result = new BufferedImage(width, height,
                BufferedImage.TYPE_INT_ARGB);
        for (int x = 0; x < width; x++)
            for (int y = 0; y < height; y++)
            {
                int red = (x * 255) / width;
                int green = (y * 255) / height;
                int blue = ((x + y) * 255) / (width + height);
                int argb = (0xff << 24) | (red << 16) | (green << 8)
                        | (blue << 0);
                result.setRGB(x, y, argb);
            }
        return result;
    }

    private void compareImagesExact(BufferedImage a, BufferedImage b)
    {
        compareImages(a, b, 0);
    }

    // private void compareImagesOffByOne(BufferedImage a, BufferedImage b)
    // {
    // compareImages(a, b, 3); // one bit of rounding error for each channel
    // }

    private void compareImages(BufferedImage a, BufferedImage b, int tolerance)
    {
        assertEquals(a.getWidth(), b.getWidth());
        assertEquals(a.getHeight(), b.getHeight());

        for (int x = 0; x < a.getWidth(); x++)
            for (int y = 0; y < a.getHeight(); y++)
            {
                int a_argb = a.getRGB(x, y);
                int b_argb = b.getRGB(x, y);
                if (a_argb != b_argb)
                {
                    if (calculateARGBDistance(a_argb, b_argb) <= tolerance)
                        continue; // ignore.
                }
                if (a_argb != b_argb)
                {
                    Debug.debug("width", a.getWidth());
                    Debug.debug("height", a.getHeight());
                    Debug.debug("distance", calculateARGBDistance(a_argb,
                            b_argb));
                    Debug.debug("x", x);
                    Debug.debug("y", y);
                    Debug.debug("a_argb", a_argb + " (0x"
                            + Integer.toHexString(a_argb) + ")");
                    Debug.debug("b_argb", b_argb + " (0x"
                            + Integer.toHexString(b_argb) + ")");
                }
                assertEquals(a_argb, b_argb);
            }
    }

    private int calculateARGBDistance(int a, int b)
    {
        int aAlpha = 0xff & (a >> 24);
        int aRed = 0xff & (a >> 16);
        int aGreen = 0xff & (a >> 8);
        int aBlue = 0xff & (a >> 0);
        int bAlpha = 0xff & (b >> 24);
        int bRed = 0xff & (b >> 16);
        int bGreen = 0xff & (b >> 8);
        int bBlue = 0xff & (b >> 0);
        int diff = Math.abs(aAlpha - bAlpha) + Math.abs(aRed - bRed)
                + Math.abs(aGreen - bGreen) + Math.abs(aBlue - bBlue);
        return diff;

    }

    private void compareFilesExact(File a, File b) throws IOException
    {
        assertTrue(a.exists() && a.isFile());
        assertTrue(b.exists() && b.isFile());
        assertEquals(a.length(), b.length());

        byte aData[] = IoUtils.getFileBytes(a);
        byte bData[] = IoUtils.getFileBytes(b);

        for (int i = 0; i < a.length(); i++)
        {
            int aByte = 0xff & aData[i];
            int bByte = 0xff & bData[i];

            if (aByte != bByte)
            {
                Debug.debug("a", a);
                Debug.debug("b", b);
                Debug.debug("i", i);
                Debug.debug("aByte", aByte + " (0x"
                        + Integer.toHexString(aByte) + ")");
                Debug.debug("bByte", bByte + " (0x"
                        + Integer.toHexString(bByte) + ")");
            }
            assertEquals(aByte, bByte);
        }
    }

    public void testBitmapRoundtrip() throws Exception
    {
        BufferedImage testImages[] = { //

        createArgbBitmapImage(1, 1), // minimal
                createArgbBitmapImage(2, 2), //
                createArgbBitmapImage(10, 10), // larger than 8
                createArgbBitmapImage(300, 300), // larger than 256

                createBitmapBitmapImage(1, 1), // minimal
                createBitmapBitmapImage(2, 2), //
                createBitmapBitmapImage(10, 10), // larger than 8
                createBitmapBitmapImage(300, 300), // larger than 256
        };

        for (int j = 0; j < testImages.length; j++)
        {
            BufferedImage testImage = testImages[j];

            for (int i = 0; i < FORMAT_INFOS.length; i++)
            {
                FormatInfo formatInfo = FORMAT_INFOS[i];
                if ((!formatInfo.canRead) || (!formatInfo.canWrite))
                    continue;

                Debug.debug("bitmap test: " + formatInfo.format.name);

                roundtrip(formatInfo, testImage, "bitmap", true);
            }
        }
    }

    public void testGrayscaleRoundtrip() throws Exception
    {
        BufferedImage testImages[] = { //

        createArgbBitmapImage(1, 1), // minimal
                createArgbGrayscaleImage(2, 2), //
                createArgbGrayscaleImage(10, 10), // larger than 8
                createArgbGrayscaleImage(300, 300), // larger than 256

                createGrayscaleGrayscaleImage(1, 1), // minimal
                createGrayscaleGrayscaleImage(2, 2), //
                createGrayscaleGrayscaleImage(10, 10), // larger than 8
                createGrayscaleGrayscaleImage(300, 300), // larger than 256
        };

        for (int j = 0; j < testImages.length; j++)
        {
            BufferedImage testImage = testImages[j];

            for (int i = 0; i < FORMAT_INFOS.length; i++)
            {
                FormatInfo formatInfo = FORMAT_INFOS[i];
                if ((!formatInfo.canRead) || (!formatInfo.canWrite))
                    continue;

                Debug.debug("grayscale test: " + formatInfo.format.name);

                boolean imageExact = true;
                if (formatInfo.colorSupport == COLOR_BITMAP)
                    imageExact = false;

                roundtrip(formatInfo, testImage, "gray", imageExact);
            }
        }
    }

    public void testLimitedColorRoundtrip() throws Exception
    {
        BufferedImage testImages[] = { //

        createLimitedColorImage(1, 1), // minimal
                createLimitedColorImage(2, 2), //
                createLimitedColorImage(10, 10), // larger than 8
                createLimitedColorImage(300, 300), // larger than 256
        };

        for (int j = 0; j < testImages.length; j++)
        {
            BufferedImage testImage = testImages[j];

            for (int i = 0; i < FORMAT_INFOS.length; i++)
            {
                FormatInfo formatInfo = FORMAT_INFOS[i];
                if ((!formatInfo.canRead) || (!formatInfo.canWrite))
                    continue;

                Debug.debug("indexable test: " + formatInfo.format.name);

                boolean imageExact = true;
                if (formatInfo.colorSupport == COLOR_BITMAP)
                    imageExact = false;
                if (formatInfo.colorSupport == COLOR_GRAYSCALE)
                    imageExact = false;

                roundtrip(formatInfo, testImage, "indexable", imageExact);
            }
        }
    }

    public void testFullColorRoundtrip() throws Exception
    {
        BufferedImage testImages[] = { //

        createFullColorImage(1, 1), // minimal
                createFullColorImage(2, 2), //
                createFullColorImage(10, 10), // larger than 8
                createFullColorImage(300, 300), // larger than 256
        };

        for (int j = 0; j < testImages.length; j++)
        {
            BufferedImage testImage = testImages[j];

            for (int i = 0; i < FORMAT_INFOS.length; i++)
            {
                FormatInfo formatInfo = FORMAT_INFOS[i];
                if ((!formatInfo.canRead) || (!formatInfo.canWrite))
                    continue;

                Debug.debug("fullColor test: " + formatInfo.format.name);

                boolean imageExact = true;
                if (formatInfo.colorSupport == COLOR_BITMAP)
                    imageExact = false;
                if (formatInfo.colorSupport == COLOR_GRAYSCALE)
                    imageExact = false;
                if (formatInfo.colorSupport == COLOR_LIMITED_INDEX)
                    imageExact = false;

                roundtrip(formatInfo, testImage, "fullColor", imageExact);
            }
        }
    }

    private void roundtrip(FormatInfo formatInfo, BufferedImage testImage,
            String tempPrefix, boolean imageExact) throws IOException,
            ImageReadException, ImageWriteException
    {
        File temp1 = createTempFile(tempPrefix + ".", "."
                + formatInfo.format.extension);
        // Debug.debug("tempFile: " + tempFile.getName());

        Map params = new HashMap();
        Sanselan.writeImage(testImage, temp1, formatInfo.format, params);

        Map readParams = new HashMap();
        readParams.put(SanselanConstants.BUFFERED_IMAGE_FACTORY,
                new RgbBufferedImageFactory());
        BufferedImage image2 = Sanselan.getBufferedImage(temp1, readParams);
        assertNotNull(image2);

        if (imageExact)
        {
            // note tolerance when comparing grayscale images
            // BufferedImages of
            compareImagesExact(testImage, image2);
        }

        if (formatInfo.identicalSecondWrite)
        {
            File temp2 = createTempFile(tempPrefix + ".", "."
                    + formatInfo.format.extension);
            // Debug.debug("tempFile: " + tempFile.getName());
            Sanselan.writeImage(image2, temp2, formatInfo.format, params);

            compareFilesExact(temp1, temp2);
        }
    }

}