package jnpf.fileStorage.dms;

import org.junit.Test;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.util.Arrays;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;

public class DmsJpegExifOrientationTest {

    @Test
    public void readsAndNormalizesAllEightExifOrientations() throws Exception {
        String[][] expected = {
                null,
                {"ABC", "DEF"},
                {"CBA", "FED"},
                {"FED", "CBA"},
                {"DEF", "ABC"},
                {"AD", "BE", "CF"},
                {"DA", "EB", "FC"},
                {"FC", "EB", "DA"},
                {"CF", "BE", "AD"}
        };
        BufferedImage source = pattern();
        byte[] jpeg = jpeg();

        for (int orientation = 1; orientation <= 8; orientation++) {
            byte[] tagged = withExifOrientation(jpeg, orientation, orientation % 2 == 0);
            assertNotNull(ImageIO.read(new ByteArrayInputStream(tagged)));
            int parsed = DmsJpegExifOrientation.readOrientation(tagged);

            assertEquals(orientation, parsed);
            assertGrid(expected[orientation], DmsJpegExifOrientation.normalize(source, parsed));
        }
    }

    @Test
    public void defaultsToOneForMissingOrMalformedExif() throws Exception {
        byte[] jpeg = jpeg();
        byte[] invalidOrientation = withExifOrientation(jpeg, 9, true);
        byte[] truncated = Arrays.copyOf(withExifOrientation(jpeg, 6, false), 14);

        assertEquals(1, DmsJpegExifOrientation.readOrientation(null));
        assertEquals(1, DmsJpegExifOrientation.readOrientation(new byte[]{1, 2, 3}));
        assertEquals(1, DmsJpegExifOrientation.readOrientation(jpeg));
        assertEquals(1, DmsJpegExifOrientation.readOrientation(invalidOrientation));
        assertEquals(1, DmsJpegExifOrientation.readOrientation(truncated));
    }

    @Test
    public void returnsOriginalImageForIdentityInvalidAndNullInputs() {
        BufferedImage source = pattern();

        assertSame(source, DmsJpegExifOrientation.normalize(source, 1));
        assertSame(source, DmsJpegExifOrientation.normalize(source, 0));
        assertSame(source, DmsJpegExifOrientation.normalize(source, 9));
        assertNull(DmsJpegExifOrientation.normalize(null, 6));
    }

    private BufferedImage pattern() {
        BufferedImage image = new BufferedImage(3, 2, BufferedImage.TYPE_INT_ARGB);
        String[] rows = {"ABC", "DEF"};
        for (int y = 0; y < rows.length; y++) {
            for (int x = 0; x < rows[y].length(); x++) {
                image.setRGB(x, y, color(rows[y].charAt(x)));
            }
        }
        return image;
    }

    private void assertGrid(String[] expected, BufferedImage image) {
        assertEquals(expected[0].length(), image.getWidth());
        assertEquals(expected.length, image.getHeight());
        for (int y = 0; y < expected.length; y++) {
            for (int x = 0; x < expected[y].length(); x++) {
                assertEquals("pixel at " + x + "," + y,
                        color(expected[y].charAt(x)), image.getRGB(x, y));
            }
        }
    }

    private int color(char label) {
        return 0xFF000000 | label * 0x00010101;
    }

    private byte[] jpeg() throws Exception {
        BufferedImage image = new BufferedImage(4, 3, BufferedImage.TYPE_INT_RGB);
        ByteArrayOutputStream output = new ByteArrayOutputStream();
        ImageIO.write(image, "jpeg", output);
        return output.toByteArray();
    }

    private byte[] withExifOrientation(byte[] jpeg, int orientation, boolean littleEndian) {
        byte[] payload = new byte[32];
        payload[0] = 'E';
        payload[1] = 'x';
        payload[2] = 'i';
        payload[3] = 'f';
        int tiff = 6;
        payload[tiff] = littleEndian ? (byte) 'I' : (byte) 'M';
        payload[tiff + 1] = payload[tiff];
        putShort(payload, tiff + 2, 42, littleEndian);
        putInt(payload, tiff + 4, 8, littleEndian);
        putShort(payload, tiff + 8, 1, littleEndian);
        int entry = tiff + 10;
        putShort(payload, entry, 0x0112, littleEndian);
        putShort(payload, entry + 2, 3, littleEndian);
        putInt(payload, entry + 4, 1, littleEndian);
        putShort(payload, entry + 8, orientation, littleEndian);

        int segmentLength = payload.length + 2;
        byte[] result = new byte[jpeg.length + payload.length + 4];
        result[0] = jpeg[0];
        result[1] = jpeg[1];
        result[2] = (byte) 0xFF;
        result[3] = (byte) 0xE1;
        result[4] = (byte) (segmentLength >>> 8);
        result[5] = (byte) segmentLength;
        System.arraycopy(payload, 0, result, 6, payload.length);
        System.arraycopy(jpeg, 2, result, 6 + payload.length, jpeg.length - 2);
        return result;
    }

    private void putShort(byte[] data, int offset, int value, boolean littleEndian) {
        if (littleEndian) {
            data[offset] = (byte) value;
            data[offset + 1] = (byte) (value >>> 8);
        } else {
            data[offset] = (byte) (value >>> 8);
            data[offset + 1] = (byte) value;
        }
    }

    private void putInt(byte[] data, int offset, int value, boolean littleEndian) {
        if (littleEndian) {
            data[offset] = (byte) value;
            data[offset + 1] = (byte) (value >>> 8);
            data[offset + 2] = (byte) (value >>> 16);
            data[offset + 3] = (byte) (value >>> 24);
        } else {
            data[offset] = (byte) (value >>> 24);
            data[offset + 1] = (byte) (value >>> 16);
            data[offset + 2] = (byte) (value >>> 8);
            data[offset + 3] = (byte) value;
        }
    }
}