#!/usr/bin/env python

"""
Show the EXIF information.

Copyright (C) 2017-2020 Cosmin Truta.

Use, modification and distribution are subject to the MIT License.
Please see the accompanying file LICENSE_MIT.txt
"""

from __future__ import absolute_import, division, print_function

import sys

from bytepack import (unpack_uint32be,
                      unpack_uint32le,
                      unpack_uint16be,
                      unpack_uint16le,
                      unpack_uint8)


# Generously allow the TIFF file to occupy up to a quarter-gigabyte.
# TODO: Reduce this limit to 64K and use file seeking for anything larger.
_READ_DATA_SIZE_MAX = 256 * 1024 * 1024

_TIFF_TAG_TYPES = {
    1: "byte",
    2: "ascii",
    3: "short",
    4: "long",
    5: "rational",
    6: "sbyte",
    7: "undefined",
    8: "sshort",
    9: "slong",
    10: "srational",
    11: "float",
    12: "double",
}

# See http://www.digitalpreservation.gov/formats/content/tiff_tags.shtml
_TIFF_TAGS = {
    0x00fe: "Subfile Type",
    0x0100: "Width",
    0x0101: "Height",
    0x0102: "Bits per Sample",
    0x0103: "Compression",
    0x0106: "Photometric",
    0x010d: "Document Name",
    0x010e: "Image Description",
    0x010f: "Make",
    0x0110: "Model",
    0x0111: "Strip Offsets",
    0x0112: "Orientation",
    0x0115: "Samples per Pixel",
    0x0116: "Rows per Strip",
    0x0117: "Strip Byte Counts",
    0x0118: "Min Sample Value",
    0x0119: "Max Sample Value",
    0x011a: "X Resolution",
    0x011b: "Y Resolution",
    0x011c: "Planar Configuration",
    0x011d: "Page Name",
    0x011e: "X Position",
    0x011f: "Y Position",
    0x0128: "Resolution Unit",
    0x0129: "Page Number",
    0x0131: "Software",
    0x0132: "Date Time",
    0x013b: "Artist",
    0x013c: "Host Computer",
    0x013d: "Predictor",
    0x013e: "White Point",
    0x013f: "Primary Chromaticities",
    0x0140: "Color Map",
    0x0141: "Half-Tone Hints",
    0x0142: "Tile Width",
    0x0143: "Tile Length",
    0x0144: "Tile Offsets",
    0x0145: "Tile Byte Counts",
    0x0211: "YCbCr Coefficients",
    0x0212: "YCbCr Subsampling",
    0x0213: "YCbCr Positioning",
    0x0214: "Reference Black White",
    0x022f: "Strip Row Counts",
    0x02bc: "XMP",
    0x8298: "Copyright",
    0x83bb: "IPTC",
    0x8769: "EXIF IFD",
    0x8773: "ICC Profile",
    0x8825: "GPS IFD",
    0xa005: "Interoperability IFD",
    0xc4a5: "Print IM",

    # EXIF IFD tags
    0x829a: "Exposure Time",
    0x829d: "F-Number",
    0x8822: "Exposure Program",
    0x8824: "Spectral Sensitivity",
    0x8827: "ISO Speed Ratings",
    0x8828: "OECF",
    0x9000: "EXIF Version",
    0x9003: "DateTime Original",
    0x9004: "DateTime Digitized",
    0x9101: "Components Configuration",
    0x9102: "Compressed Bits Per Pixel",
    0x9201: "Shutter Speed Value",
    0x9202: "Aperture Value",
    0x9203: "Brightness Value",
    0x9204: "Exposure Bias Value",
    0x9205: "Max Aperture Value",
    0x9206: "Subject Distance",
    0x9207: "Metering Mode",
    0x9208: "Light Source",
    0x9209: "Flash",
    0x920a: "Focal Length",
    0x9214: "Subject Area",
    0x927c: "Maker Note",
    0x9286: "User Comment",
    # ... TODO
    0xa000: "Flashpix Version",
    0xa001: "Color Space",
    0xa002: "Pixel X Dimension",
    0xa003: "Pixel Y Dimension",
    0xa004: "Related Sound File",
    # ... TODO

    # GPS IFD tags
    # ... TODO
}

_TIFF_EXIF_IFD = 0x8769
_GPS_IFD = 0x8825
_INTEROPERABILITY_IFD = 0xa005


class ExifInfo:
    """EXIF reader and information lister."""

    _endian = None
    _buffer = None
    _offset = 0
    _global_ifd_offset = 0
    _exif_ifd_offset = 0
    _gps_ifd_offset = 0
    _interoperability_ifd_offset = 0
    _hex = False

    def __init__(self, buffer, **kwargs):
        """Initialize the EXIF data reader."""
        self._hex = kwargs.get("hex", False)
        self._verbose = kwargs.get("verbose", False)
        if not isinstance(buffer, bytes):
            raise RuntimeError("invalid EXIF data type")
        if buffer.startswith(b"MM\x00\x2a"):
            self._endian = "MM"
        elif buffer.startswith(b"II\x2a\x00"):
            self._endian = "II"
        else:
            raise RuntimeError("invalid EXIF header")
        self._buffer = buffer
        self._offset = 4
        self._global_ifd_offset = self._ui32()

    def endian(self):
        """Return the endianness of the EXIF data."""
        return self._endian

    def _tags_for_ifd(self, ifd_offset):
        """Yield the tags found at the given TIFF IFD offset."""
        if ifd_offset < 8:
            raise RuntimeError("invalid TIFF IFD offset")
        self._offset = ifd_offset
        ifd_size = self._ui16()
        for _ in range(0, ifd_size):
            tag_id = self._ui16()
            tag_type = self._ui16()
            count = self._ui32()
            value_or_offset = self._ui32()
            if self._endian == "MM":
                # FIXME:
                # value_or_offset requires a fixup under big-endian encoding.
                if tag_type == 2:
                    # 2 --> "ascii"
                    value_or_offset >>= 24
                elif tag_type == 3:
                    # 3 --> "short"
                    value_or_offset >>= 16
                else:
                    # ... FIXME
                    pass
            if count == 0:
                raise RuntimeError("unsupported count=0 in tag 0x%x" % tag_id)
            if tag_id == _TIFF_EXIF_IFD:
                if tag_type != 4:
                    raise RuntimeError("incorrect tag type for EXIF IFD")
                self._exif_ifd_offset = value_or_offset
            elif tag_id == _GPS_IFD:
                if tag_type != 4:
                    raise RuntimeError("incorrect tag type for GPS IFD")
                self._gps_ifd_offset = value_or_offset
            elif tag_id == _INTEROPERABILITY_IFD:
                if tag_type != 4:
                    raise RuntimeError("incorrect tag type for Interop IFD")
                self._interoperability_ifd_offset = value_or_offset
            yield (tag_id, tag_type, count, value_or_offset)

    def tags(self):
        """Yield all TIFF/EXIF tags."""
        if self._verbose:
            print("TIFF IFD : 0x%08x" % self._global_ifd_offset)
        for tag in self._tags_for_ifd(self._global_ifd_offset):
            yield tag
        if self._exif_ifd_offset > 0:
            if self._verbose:
                print("EXIF IFD : 0x%08x" % self._exif_ifd_offset)
            for tag in self._tags_for_ifd(self._exif_ifd_offset):
                yield tag
        if self._gps_ifd_offset > 0:
            if self._verbose:
                print("GPS IFD : 0x%08x" % self._gps_ifd_offset)
            for tag in self._tags_for_ifd(self._gps_ifd_offset):
                yield tag
        if self._interoperability_ifd_offset > 0:
            if self._verbose:
                print("Interoperability IFD : 0x%08x" %
                      self._interoperability_ifd_offset)
            for tag in self._tags_for_ifd(self._interoperability_ifd_offset):
                yield tag

    def tagid2str(self, tag_id):
        """Return an informative string representation of a TIFF tag id."""
        idstr = _TIFF_TAGS.get(tag_id, "[Unknown]")
        if self._hex:
            idnum = "0x%04x" % tag_id
        else:
            idnum = "%d" % tag_id
        return "%s (%s)" % (idstr, idnum)

    @staticmethod
    def tagtype2str(tag_type):
        """Return an informative string representation of a TIFF tag type."""
        typestr = _TIFF_TAG_TYPES.get(tag_type, "[unknown]")
        return "%d:%s" % (tag_type, typestr)

    def tag2str(self, tag_id, tag_type, count, value_or_offset):
        """Return an informative string representation of a TIFF tag tuple."""
        return "%s (type=%s) (count=%d) : 0x%08x" \
               % (self.tagid2str(tag_id), self.tagtype2str(tag_type), count,
                  value_or_offset)

    def _ui32(self):
        """Decode a 32-bit unsigned int found at the current offset;
           advance the offset by 4.
        """
        if self._offset + 4 > len(self._buffer):
            raise RuntimeError("out-of-bounds uint32 access in EXIF")
        if self._endian == "MM":
            result = unpack_uint32be(self._buffer, self._offset)
        else:
            result = unpack_uint32le(self._buffer, self._offset)
        self._offset += 4
        return result

    def _ui16(self):
        """Decode a 16-bit unsigned int found at the current offset;
           advance the offset by 2.
        """
        if self._offset + 2 > len(self._buffer):
            raise RuntimeError("out-of-bounds uint16 access in EXIF")
        if self._endian == "MM":
            result = unpack_uint16be(self._buffer, self._offset)
        else:
            result = unpack_uint16le(self._buffer, self._offset)
        self._offset += 2
        return result

    def _ui8(self):
        """Decode an 8-bit unsigned int found at the current offset;
           advance the offset by 1.
        """
        if self._offset + 1 > len(self._buffer):
            raise RuntimeError("out-of-bounds uint8 access in EXIF")
        result = unpack_uint8(self._buffer, self._offset)
        self._offset += 1
        return result


def print_raw_exif_info(buffer, **kwargs):
    """Print the EXIF information found in a raw byte stream."""
    lister = ExifInfo(buffer, **kwargs)
    print("EXIF (endian=%s)" % lister.endian())
    for (tag_id, tag_type, count, value_or_offset) in lister.tags():
        print(lister.tag2str(tag_id=tag_id,
                             tag_type=tag_type,
                             count=count,
                             value_or_offset=value_or_offset))


if __name__ == "__main__":
    # For testing only.
    for arg in sys.argv[1:]:
        with open(arg, "rb") as test_stream:
            test_buffer = test_stream.read(_READ_DATA_SIZE_MAX)
            print_raw_exif_info(test_buffer, hex=True, verbose=True)