/*
 * JavaScript Load Image IPTC Parser
 * https://github.com/blueimp/JavaScript-Load-Image
 *
 * Copyright 2013, Sebastian Tschan
 * Copyright 2018, Dave Bevan
 * https://blueimp.net
 *
 * Licensed under the MIT license:
 * https://opensource.org/licenses/MIT
 */

/* global define, module, require, Buffer */

;(function(factory) {
  'use strict'
  if (typeof define === 'function' && define.amd) {
    // Register as an anonymous AMD module:
    define(['./load-image', './load-image-meta'], factory)
  } else if (typeof module === 'object' && module.exports) {
    factory(require('./load-image'), require('./load-image-meta'))
  } else {
    // Browser globals:
    factory(window.loadImage)
  }
})(function(loadImage) {
  'use strict'

  loadImage.IptcMap = function() {
    return this
  }

  loadImage.IptcMap.prototype.map = {
    ObjectName: 0x5
  }

  loadImage.IptcMap.prototype.get = function(id) {
    return this[id] || this[this.map[id]]
  }

  loadImage.parseIptcTags = function(
    dataView,
    startOffset,
    sectionLength,
    data
  ) {
    /**
     * Retrieves string for the given Buffer and range
     *
     * @param {Buffer} buffer IPTC buffer
     * @param {number} start Range start
     * @param {number} length Range length
     * @returns {string} String value
     */
    function getStringFromDB(buffer, start, length) {
      var outstr = ''
      for (var n = start; n < start + length; n++) {
        outstr += String.fromCharCode(buffer.getUint8(n))
      }
      return outstr
    }
    var fieldValue, dataSize, segmentType
    var segmentStartPos = startOffset
    while (segmentStartPos < startOffset + sectionLength) {
      // we currently handle the 2: class of iptc tag
      if (
        dataView.getUint8(segmentStartPos) === 0x1c &&
        dataView.getUint8(segmentStartPos + 1) === 0x02
      ) {
        segmentType = dataView.getUint8(segmentStartPos + 2)
        // only store data for known tags
        if (segmentType in data.iptc.tags) {
          dataSize = dataView.getInt16(segmentStartPos + 3)
          fieldValue = getStringFromDB(dataView, segmentStartPos + 5, dataSize)
          // Check if we already stored a value with this name
          if (Object.prototype.hasOwnProperty.call(data.iptc, segmentType)) {
            // Value already stored with this name, create multivalue field
            if (data.iptc[segmentType] instanceof Array) {
              data.iptc[segmentType].push(fieldValue)
            } else {
              data.iptc[segmentType] = [data.iptc[segmentType], fieldValue]
            }
          } else {
            data.iptc[segmentType] = fieldValue
          }
        }
      }
      segmentStartPos++
    }
  }

  loadImage.parseIptcData = function(dataView, offset, length, data, options) {
    if (options.disableIptc) {
      return
    }
    var markerLength = offset + length
    // Found '8BIM<EOT><EOT>' ?
    var isFieldSegmentStart = function(dataView, offset) {
      return (
        dataView.getUint32(offset) === 0x3842494d &&
        dataView.getUint16(offset + 4) === 0x0404
      )
    }
    // Hunt forward, looking for the correct IPTC block signature:
    // Reference: https://metacpan.org/pod/distribution/Image-MetaData-JPEG/lib/Image/MetaData/JPEG/Structures.pod#Structure-of-a-Photoshop-style-APP13-segment
    // From https://github.com/exif-js/exif-js/blob/master/exif.js ~ line 474 on
    while (offset + 8 < markerLength) {
      if (isFieldSegmentStart(dataView, offset)) {
        var nameHeaderLength = dataView.getUint8(offset + 7)
        if (nameHeaderLength % 2 !== 0) nameHeaderLength += 1
        // Check for pre photoshop 6 format
        if (nameHeaderLength === 0) {
          // Always 4
          nameHeaderLength = 4
        }
        var startOffset = offset + 8 + nameHeaderLength
        if (startOffset > markerLength) {
          // eslint-disable-next-line no-console
          console.log('Invalid IPTC data: Invalid segment offset.')
          break
        }
        var sectionLength = dataView.getUint16(offset + 6 + nameHeaderLength)
        if (offset + sectionLength > markerLength) {
          // eslint-disable-next-line no-console
          console.log('Invalid IPTC data: Invalid segment size.')
          break
        }
        // Create the iptc object to store the tags:
        data.iptc = new loadImage.IptcMap()
        // Parse the tags
        return loadImage.parseIptcTags(
          dataView,
          startOffset,
          sectionLength,
          data
        )
      }
      // eslint-disable-next-line no-param-reassign
      offset++
    }
    // eslint-disable-next-line no-console
    console.log('No IPTC data at this offset - could be XMP')
  }

  // Registers this IPTC parser for the APP13 JPEG meta data segment:
  loadImage.metaDataParsers.jpeg[0xffed].push(loadImage.parseIptcData)

  // Adds the following properties to the parseMetaData callback data:
  // * iptc: The iptc tags, parsed by the parseIptcData method

  // Adds the following options to the parseMetaData method:
  // * disableIptc: Disables IPTC parsing.
})