/*
 * 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.formats.tiff;

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

import org.apache.commons.imaging.ImageFormats;
import org.apache.commons.imaging.ImageReadException;
import org.apache.commons.imaging.ImageWriteException;
import org.apache.commons.imaging.Imaging;
import org.apache.commons.imaging.ImagingConstants;
import org.apache.commons.imaging.common.itu_t4.T4AndT6Compression;
import org.apache.commons.imaging.formats.tiff.constants.TiffConstants;
import org.apache.commons.imaging.util.Debug;

public class TiffCcittTest extends TiffBaseTest {
    public void testAll5x2Compressions() {
        final byte[] uncompressed = new byte[2];
        final int[] combinations = new int[10];
        do {
            for (int x = 0; x < 5; x++) {
                if (combinations[x] != 0) {
                    uncompressed[0] |= (0x80 >>> x);
                }
            }
            for (int x = 0; x < 5; x++) {
                if (combinations[5 + x] != 0) {
                    uncompressed[1] |= (0x80 >>> x);
                }
            }

            try {
                final byte[] compressed = T4AndT6Compression.compressModifiedHuffman(
                        uncompressed, 5, 2);
                final byte[] result = T4AndT6Compression.decompressModifiedHuffman(
                        compressed, 5, 2);
                assertEquals(uncompressed.length, result.length);
                for (int i = 0; i < uncompressed.length; i++) {
                    assertEquals(uncompressed[i], result[i]);
                }
            } catch (final ImageWriteException ex) {
                Debug.debug(ex);
                assertFalse(true);
            } catch (final ImageReadException ex) {
                Debug.debug(ex);
                assertFalse(true);
            }

            try {
                final byte[] compressed = T4AndT6Compression.compressT4_1D(
                        uncompressed, 5, 2, true);
                final byte[] result = T4AndT6Compression.decompressT4_1D(compressed,
                        5, 2, true);
                assertEquals(uncompressed.length, result.length);
                for (int i = 0; i < uncompressed.length; i++) {
                    assertEquals(uncompressed[i], result[i]);
                }
            } catch (final ImageWriteException ex) {
                Debug.debug(ex);
                assertFalse(true);
            } catch (final ImageReadException ex) {
                Debug.debug(ex);
                assertFalse(true);
            }

            try {
                final byte[] compressed = T4AndT6Compression.compressT4_1D(
                        uncompressed, 5, 2, false);
                final byte[] result = T4AndT6Compression.decompressT4_1D(compressed,
                        5, 2, false);
                assertEquals(uncompressed.length, result.length);
                for (int i = 0; i < uncompressed.length; i++) {
                    assertEquals(uncompressed[i], result[i]);
                }
            } catch (final ImageWriteException ex) {
                Debug.debug(ex);
                assertFalse(true);
            } catch (final ImageReadException ex) {
                Debug.debug(ex);
                assertFalse(true);
            }

            try {
                final byte[] compressed = T4AndT6Compression.compressT4_2D(
                        uncompressed, 5, 2, true, 2);
                final byte[] result = T4AndT6Compression.decompressT4_2D(compressed,
                        5, 2, true);
                assertEquals(uncompressed.length, result.length);
                for (int i = 0; i < uncompressed.length; i++) {
                    assertEquals(uncompressed[i], result[i]);
                }
            } catch (final ImageWriteException ex) {
                Debug.debug(ex);
                assertFalse(true);
            } catch (final ImageReadException ex) {
                Debug.debug(ex);
                assertFalse(true);
            }

            try {
                final byte[] compressed = T4AndT6Compression.compressT4_2D(
                        uncompressed, 5, 2, false, 2);
                final byte[] result = T4AndT6Compression.decompressT4_2D(compressed,
                        5, 2, false);
                assertEquals(uncompressed.length, result.length);
                for (int i = 0; i < uncompressed.length; i++) {
                    assertEquals(uncompressed[i], result[i]);
                }
            } catch (final ImageWriteException ex) {
                Debug.debug(ex);
                assertFalse(true);
            } catch (final ImageReadException ex) {
                Debug.debug(ex);
                assertFalse(true);
            }

            try {
                final byte[] compressed = T4AndT6Compression.compressT6(uncompressed,
                        5, 2);
                final byte[] result = T4AndT6Compression.decompressT6(compressed, 5,
                        2);
                assertEquals(uncompressed.length, result.length);
                for (int i = 0; i < uncompressed.length; i++) {
                    assertEquals(uncompressed[i], result[i]);
                }
            } catch (final ImageWriteException ex) {
                Debug.debug(ex);
                assertFalse(true);
            } catch (final ImageReadException ex) {
                Debug.debug(ex);
                assertFalse(true);
            }
        } while (nextCombination(combinations, 1));
    }

    public void testAll5x2Images() {
        final int[] combinations = new int[10];
        final BufferedImage image = new BufferedImage(5, 2,
                BufferedImage.TYPE_INT_RGB);
        do {
            for (int x = 0; x < 5; x++) {
                if (combinations[x] == 0) {
                    image.setRGB(x, 0, 0xFFFFFF);
                } else {
                    image.setRGB(x, 0, 0);
                }
            }
            for (int x = 0; x < 5; x++) {
                if (combinations[5 + x] == 0) {
                    image.setRGB(x, 1, 0xFFFFFF);
                } else {
                    image.setRGB(x, 1, 0);
                }
            }

            try {
                final HashMap<String,Object> params = new HashMap<String,Object>();
                params.put(ImagingConstants.PARAM_KEY_COMPRESSION,
                        TiffConstants.TIFF_COMPRESSION_CCITT_1D);
                final byte[] compressed = Imaging.writeImageToBytes(image,
                        ImageFormats.TIFF, params);
                final BufferedImage result = Imaging.getBufferedImage(compressed);
                compareImages(image, result);
            } catch (final ImageWriteException ex) {
                Debug.debug(ex);
                assertFalse(true);
            } catch (final ImageReadException ex) {
                Debug.debug(ex);
                assertFalse(true);
            } catch (final IOException ex) {
                Debug.debug(ex);
                assertFalse(true);
            }

            try {
                final HashMap<String,Object> params = new HashMap<String,Object>();
                params.put(ImagingConstants.PARAM_KEY_COMPRESSION,
                        TiffConstants.TIFF_COMPRESSION_CCITT_GROUP_3);
                params.put(TiffConstants.PARAM_KEY_T4_OPTIONS, 0);
                final byte[] compressed = Imaging.writeImageToBytes(image,
                        ImageFormats.TIFF, params);
                final BufferedImage result = Imaging.getBufferedImage(compressed);
                compareImages(image, result);
            } catch (final ImageWriteException ex) {
                Debug.debug(ex);
                assertFalse(true);
            } catch (final ImageReadException ex) {
                Debug.debug(ex);
                assertFalse(true);
            } catch (final IOException ex) {
                Debug.debug(ex);
                assertFalse(true);
            }

            try {
                final HashMap<String,Object> params = new HashMap<String,Object>();
                params.put(ImagingConstants.PARAM_KEY_COMPRESSION,
                        TiffConstants.TIFF_COMPRESSION_CCITT_GROUP_3);
                params.put(TiffConstants.PARAM_KEY_T4_OPTIONS, 4);
                final byte[] compressed = Imaging.writeImageToBytes(image,
                        ImageFormats.TIFF, params);
                final BufferedImage result = Imaging.getBufferedImage(compressed);
                compareImages(image, result);
            } catch (final ImageWriteException ex) {
                Debug.debug(ex);
                assertFalse(true);
            } catch (final ImageReadException ex) {
                Debug.debug(ex);
                assertFalse(true);
            } catch (final IOException ex) {
                Debug.debug(ex);
                assertFalse(true);
            }

            try {
                final HashMap<String,Object> params = new HashMap<String,Object>();
                params.put(ImagingConstants.PARAM_KEY_COMPRESSION,
                        TiffConstants.TIFF_COMPRESSION_CCITT_GROUP_3);
                params.put(TiffConstants.PARAM_KEY_T4_OPTIONS, 1);
                final byte[] compressed = Imaging.writeImageToBytes(image,
                        ImageFormats.TIFF, params);
                final BufferedImage result = Imaging.getBufferedImage(compressed);
                compareImages(image, result);
            } catch (final ImageWriteException ex) {
                Debug.debug(ex);
                assertFalse(true);
            } catch (final ImageReadException ex) {
                Debug.debug(ex);
                assertFalse(true);
            } catch (final IOException ex) {
                Debug.debug(ex);
                assertFalse(true);
            }

            try {
                final HashMap<String,Object> params = new HashMap<String,Object>();
                params.put(ImagingConstants.PARAM_KEY_COMPRESSION,
                        TiffConstants.TIFF_COMPRESSION_CCITT_GROUP_3);
                params.put(TiffConstants.PARAM_KEY_T4_OPTIONS, 5);
                final byte[] compressed = Imaging.writeImageToBytes(image,
                        ImageFormats.TIFF, params);
                final BufferedImage result = Imaging.getBufferedImage(compressed);
                compareImages(image, result);
            } catch (final ImageWriteException ex) {
                Debug.debug(ex);
                assertFalse(true);
            } catch (final ImageReadException ex) {
                Debug.debug(ex);
                assertFalse(true);
            } catch (final IOException ex) {
                Debug.debug(ex);
                assertFalse(true);
            }

            try {
                final HashMap<String,Object> params = new HashMap<String,Object>();
                params.put(ImagingConstants.PARAM_KEY_COMPRESSION,
                        TiffConstants.TIFF_COMPRESSION_CCITT_GROUP_4);
                final byte[] compressed = Imaging.writeImageToBytes(image,
                        ImageFormats.TIFF, params);
                final BufferedImage result = Imaging.getBufferedImage(compressed);
                compareImages(image, result);
            } catch (final ImageWriteException ex) {
                Debug.debug(ex);
                assertFalse(true);
            } catch (final ImageReadException ex) {
                Debug.debug(ex);
                assertFalse(true);
            } catch (final IOException ex) {
                Debug.debug(ex);
                assertFalse(true);
            }
        } while (nextCombination(combinations, 1));
    }

    /**
     * Generates the next combination of elements in the sequence array, with
     * each element having a maximum value of max. Initially, the sequence
     * should be set to minimum values of each element.
     * 
     * @param sequence
     *            the array of elements to update
     * @param max
     *            the maximum value of each element in the sequence
     * @return false if there is no more combinations (ie. nothing was done),
     *         true otherwise
     */
    private static boolean nextCombination(final int[] sequence, final int max) {
        int i;
        for (i = 0; i < sequence.length; i++) {
            if (sequence[i] == max) {
                sequence[i] = 0;
            } else {
                sequence[i]++;
                break;
            }
        }
        return i < sequence.length;
    }

    private void compareImages(final BufferedImage a, final BufferedImage b) {
        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++) {
                final int a_argb = a.getRGB(x, y);
                final int b_argb = b.getRGB(x, y);
                if (a_argb != b_argb) {
                    Debug.debug("width", a.getWidth());
                    Debug.debug("height", a.getHeight());
                    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);
            }
        }
    }
}