package jnpf.fileStorage.dms;

import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.Raster;
import java.awt.image.WritableRaster;

final class DmsJpegExifOrientation {
    private static final int JPEG_MARKER_PREFIX = 0xFF;
    private static final int JPEG_START_OF_IMAGE = 0xD8;
    private static final int JPEG_END_OF_IMAGE = 0xD9;
    private static final int JPEG_START_OF_SCAN = 0xDA;
    private static final int JPEG_APP1 = 0xE1;
    private static final int EXIF_ORIENTATION_TAG = 0x0112;
    private static final int TIFF_SHORT = 3;

    private DmsJpegExifOrientation() {
    }

    static int readOrientation(byte[] jpeg) {
        if (jpeg == null || jpeg.length < 4
                || unsigned(jpeg[0]) != JPEG_MARKER_PREFIX
                || unsigned(jpeg[1]) != JPEG_START_OF_IMAGE) {
            return 1;
        }

        int offset = 2;
        while (offset < jpeg.length) {
            if (unsigned(jpeg[offset]) != JPEG_MARKER_PREFIX) {
                return 1;
            }
            while (offset < jpeg.length && unsigned(jpeg[offset]) == JPEG_MARKER_PREFIX) {
                offset++;
            }
            if (offset >= jpeg.length) {
                return 1;
            }

            int marker = unsigned(jpeg[offset++]);
            if (marker == JPEG_END_OF_IMAGE || marker == JPEG_START_OF_SCAN) {
                return 1;
            }
            if (marker == JPEG_START_OF_IMAGE || marker == 0x01
                    || marker >= 0xD0 && marker <= 0xD7) {
                continue;
            }
            if (!fits(offset, 2, jpeg.length)) {
                return 1;
            }

            int segmentLength = readUnsignedShortBigEndian(jpeg, offset);
            if (segmentLength < 2 || !fits(offset, segmentLength, jpeg.length)) {
                return 1;
            }
            if (marker == JPEG_APP1) {
                int orientation = readExifOrientation(jpeg, offset + 2, segmentLength - 2);
                if (orientation != 0) {
                    return orientation;
                }
            }
            offset += segmentLength;
        }
        return 1;
    }

    static BufferedImage normalize(BufferedImage source, int orientation) {
        if (source == null || orientation < 2 || orientation > 8) {
            return source;
        }

        int sourceWidth = source.getWidth();
        int sourceHeight = source.getHeight();
        boolean swapsAxes = orientation >= 5;
        int targetWidth = swapsAxes ? sourceHeight : sourceWidth;
        int targetHeight = swapsAxes ? sourceWidth : sourceHeight;

        ColorModel colorModel = source.getColorModel();
        WritableRaster targetRaster = colorModel.createCompatibleWritableRaster(targetWidth, targetHeight);
        BufferedImage target = new BufferedImage(colorModel, targetRaster,
                colorModel.isAlphaPremultiplied(), null);
        Raster sourceRaster = source.getRaster();
        Object pixel = null;

        for (int sourceY = 0; sourceY < sourceHeight; sourceY++) {
            for (int sourceX = 0; sourceX < sourceWidth; sourceX++) {
                int targetX;
                int targetY;
                switch (orientation) {
                    case 2:
                        targetX = sourceWidth - 1 - sourceX;
                        targetY = sourceY;
                        break;
                    case 3:
                        targetX = sourceWidth - 1 - sourceX;
                        targetY = sourceHeight - 1 - sourceY;
                        break;
                    case 4:
                        targetX = sourceX;
                        targetY = sourceHeight - 1 - sourceY;
                        break;
                    case 5:
                        targetX = sourceY;
                        targetY = sourceX;
                        break;
                    case 6:
                        targetX = sourceHeight - 1 - sourceY;
                        targetY = sourceX;
                        break;
                    case 7:
                        targetX = sourceHeight - 1 - sourceY;
                        targetY = sourceWidth - 1 - sourceX;
                        break;
                    case 8:
                        targetX = sourceY;
                        targetY = sourceWidth - 1 - sourceX;
                        break;
                    default:
                        return source;
                }
                pixel = sourceRaster.getDataElements(sourceX, sourceY, pixel);
                targetRaster.setDataElements(targetX, targetY, pixel);
            }
        }
        return target;
    }

    private static int readExifOrientation(byte[] data, int payloadOffset, int payloadLength) {
        if (payloadLength < 14 || !fits(payloadOffset, payloadLength, data.length)
                || unsigned(data[payloadOffset]) != 'E'
                || unsigned(data[payloadOffset + 1]) != 'x'
                || unsigned(data[payloadOffset + 2]) != 'i'
                || unsigned(data[payloadOffset + 3]) != 'f'
                || data[payloadOffset + 4] != 0
                || data[payloadOffset + 5] != 0) {
            return 0;
        }

        int tiffOffset = payloadOffset + 6;
        int tiffLength = payloadLength - 6;
        boolean littleEndian;
        if (unsigned(data[tiffOffset]) == 'I' && unsigned(data[tiffOffset + 1]) == 'I') {
            littleEndian = true;
        } else if (unsigned(data[tiffOffset]) == 'M' && unsigned(data[tiffOffset + 1]) == 'M') {
            littleEndian = false;
        } else {
            return 0;
        }
        if (readUnsignedShort(data, tiffOffset + 2, littleEndian) != 42) {
            return 0;
        }

        long firstIfdRelativeOffset = readUnsignedInt(data, tiffOffset + 4, littleEndian);
        if (firstIfdRelativeOffset > Integer.MAX_VALUE) {
            return 0;
        }
        int firstIfdOffset = tiffOffset + (int) firstIfdRelativeOffset;
        int tiffEnd = tiffOffset + tiffLength;
        if (firstIfdOffset < tiffOffset || !fits(firstIfdOffset, 2, tiffEnd)) {
            return 0;
        }

        int entryCount = readUnsignedShort(data, firstIfdOffset, littleEndian);
        for (int index = 0; index < entryCount; index++) {
            long entryOffsetLong = (long) firstIfdOffset + 2L + (long) index * 12L;
            if (entryOffsetLong > Integer.MAX_VALUE) {
                return 0;
            }
            int entryOffset = (int) entryOffsetLong;
            if (!fits(entryOffset, 12, tiffEnd)) {
                return 0;
            }
            if (readUnsignedShort(data, entryOffset, littleEndian) != EXIF_ORIENTATION_TAG) {
                continue;
            }
            if (readUnsignedShort(data, entryOffset + 2, littleEndian) != TIFF_SHORT) {
                return 0;
            }
            long valueCount = readUnsignedInt(data, entryOffset + 4, littleEndian);
            if (valueCount < 1) {
                return 0;
            }

            int valueOffset;
            if (valueCount <= 2) {
                valueOffset = entryOffset + 8;
            } else {
                long relativeValueOffset = readUnsignedInt(data, entryOffset + 8, littleEndian);
                if (relativeValueOffset > Integer.MAX_VALUE) {
                    return 0;
                }
                valueOffset = tiffOffset + (int) relativeValueOffset;
            }
            if (valueOffset < tiffOffset || !fits(valueOffset, 2, tiffEnd)) {
                return 0;
            }
            int orientation = readUnsignedShort(data, valueOffset, littleEndian);
            return orientation >= 1 && orientation <= 8 ? orientation : 0;
        }
        return 0;
    }

    private static int readUnsignedShortBigEndian(byte[] data, int offset) {
        return unsigned(data[offset]) << 8 | unsigned(data[offset + 1]);
    }

    private static int readUnsignedShort(byte[] data, int offset, boolean littleEndian) {
        int first = unsigned(data[offset]);
        int second = unsigned(data[offset + 1]);
        return littleEndian ? first | second << 8 : first << 8 | second;
    }

    private static long readUnsignedInt(byte[] data, int offset, boolean littleEndian) {
        long first = unsigned(data[offset]);
        long second = unsigned(data[offset + 1]);
        long third = unsigned(data[offset + 2]);
        long fourth = unsigned(data[offset + 3]);
        return littleEndian
                ? first | second << 8 | third << 16 | fourth << 24
                : first << 24 | second << 16 | third << 8 | fourth;
    }

    private static boolean fits(int offset, int length, int endExclusive) {
        return offset >= 0 && length >= 0 && (long) offset + length <= endExclusive;
    }

    private static int unsigned(byte value) {
        return value & 0xFF;
    }
}