'use strict';

var index$2 = require('../../../../file-type/index.js');
var index$1 = require('../../../../exif-parser/index.js');
var index = require('../../../utils/es/index.js');
var constants = require('../constants.js');
var mime = require('./mime.js');
var promisify = require('./promisify.js');

async function getMIMEFromBuffer(buffer, path) {
  const fileTypeFromBuffer = await index$2.fromBuffer(buffer);
  if (fileTypeFromBuffer) {
    // If fileType returns something for buffer, then return the mime given
    return fileTypeFromBuffer.mime;
  }
  if (path) {
    // If a path is supplied, and fileType yields no results, then retry with MIME
    // Path can be either a file path or a url
    return mime.getType(path);
  }
  return null;
}

/*
 * Obtains image orientation from EXIF metadata.
 *
 * @param img {Jimp} a Jimp image object
 * @returns {number} a number 1-8 representing EXIF orientation,
 *          in particular 1 if orientation tag is missing
 */
function getExifOrientation(img) {
  return img._exif && img._exif.tags && img._exif.tags.Orientation || 1;
}

/**
 * Returns a function which translates EXIF-rotated coordinates into
 * non-rotated ones.
 *
 * Transformation reference: http://sylvana.net/jpegcrop/exif_orientation.html.
 *
 * @param img {Jimp} a Jimp image object
 * @returns {function} transformation function for transformBitmap().
 */
function getExifOrientationTransformation(img) {
  const w = img.getWidth();
  const h = img.getHeight();
  switch (getExifOrientation(img)) {
    case 1:
      // Horizontal (normal)
      // does not need to be supported here
      return null;
    case 2:
      // Mirror horizontal
      return function (x, y) {
        return [w - x - 1, y];
      };
    case 3:
      // Rotate 180
      return function (x, y) {
        return [w - x - 1, h - y - 1];
      };
    case 4:
      // Mirror vertical
      return function (x, y) {
        return [x, h - y - 1];
      };
    case 5:
      // Mirror horizontal and rotate 270 CW
      return function (x, y) {
        return [y, x];
      };
    case 6:
      // Rotate 90 CW
      return function (x, y) {
        return [y, h - x - 1];
      };
    case 7:
      // Mirror horizontal and rotate 90 CW
      return function (x, y) {
        return [w - y - 1, h - x - 1];
      };
    case 8:
      // Rotate 270 CW
      return function (x, y) {
        return [w - y - 1, x];
      };
    default:
      return null;
  }
}

/*
 * Transforms bitmap in place (moves pixels around) according to given
 * transformation function.
 *
 * @param img {Jimp} a Jimp image object, which bitmap is supposed to
 *        be transformed
 * @param width {number} bitmap width after the transformation
 * @param height {number} bitmap height after the transformation
 * @param transformation {function} transformation function which defines pixel
 *        mapping between new and source bitmap. It takes a pair of coordinates
 *        in the target, and returns a respective pair of coordinates in
 *        the source bitmap, i.e. has following form:
 *        `function(new_x, new_y) { return [src_x, src_y] }`.
 */
function transformBitmap(img, width, height, transformation) {
  // Underscore-prefixed values are related to the source bitmap
  // Their counterparts with no prefix are related to the target bitmap
  const _data = img.bitmap.data;
  const _width = img.bitmap.width;
  const data = Buffer.alloc(_data.length);
  for (let x = 0; x < width; x++) {
    for (let y = 0; y < height; y++) {
      const [_x, _y] = transformation(x, y);
      const idx = width * y + x << 2;
      const _idx = _width * _y + _x << 2;
      const pixel = _data.readUInt32BE(_idx);
      data.writeUInt32BE(pixel, idx);
    }
  }
  img.bitmap.data = data;
  img.bitmap.width = width;
  img.bitmap.height = height;
}

/*
 * Automagically rotates an image based on its EXIF data (if present).
 * @param img {Jimp} a Jimp image object
 */
function exifRotate(img) {
  if (getExifOrientation(img) < 2) return;
  const transformation = getExifOrientationTransformation(img);
  const swapDimensions = getExifOrientation(img) > 4;
  const newWidth = swapDimensions ? img.bitmap.height : img.bitmap.width;
  const newHeight = swapDimensions ? img.bitmap.width : img.bitmap.height;
  transformBitmap(img, newWidth, newHeight, transformation);
}

// parses a bitmap from the constructor to the JIMP bitmap property
async function parseBitmap(data, path, cb) {
  const mime = await getMIMEFromBuffer(data, path);
  if (typeof mime !== "string") {
    return cb(new Error("Could not find MIME for Buffer <" + path + ">"));
  }
  this._originalMime = mime.toLowerCase();
  try {
    const mime = this.getMIME();
    if (this.constructor.decoders[mime]) {
      this.bitmap = this.constructor.decoders[mime](data);
    } else {
      return index.throwError.call(this, "Unsupported MIME type: " + mime, cb);
    }
  } catch (error) {
    return cb.call(this, error, this);
  }
  try {
    this._exif = index$1.create(data).parse();
    exifRotate(this); // EXIF data
  } catch (error) {
    /* meh */
  }
  cb.call(this, null, this);
  return this;
}
function compositeBitmapOverBackground(Jimp, image) {
  return new Jimp(image.bitmap.width, image.bitmap.height, image._background).composite(image, 0, 0).bitmap;
}

/**
 * Converts the image to a buffer
 * @param {(string|number)} mime the mime type of the image buffer to be created
 * @param {function(Error, Jimp)} cb a Node-style function to call with the buffer as the second argument
 * @returns {Jimp} this for chaining of methods
 */
function getBuffer(mime, cb) {
  if (mime === constants.AUTO) {
    // allow auto MIME detection
    mime = this.getMIME();
  }
  if (typeof mime !== "string") {
    return index.throwError.call(this, "mime must be a string", cb);
  }
  if (typeof cb !== "function") {
    return index.throwError.call(this, "cb must be a function", cb);
  }
  mime = mime.toLowerCase();
  if (this._rgba && this.constructor.hasAlpha[mime]) {
    this.bitmap.data = Buffer.from(this.bitmap.data);
  } else {
    // when format doesn't support alpha
    // composite onto a new image so that the background shows through alpha channels
    this.bitmap.data = compositeBitmapOverBackground(this.constructor, this).data;
  }
  if (this.constructor.encoders[mime]) {
    const buffer = this.constructor.encoders[mime](this);
    // Typically, buffers return a string or map.  However, the gif library "gifwrap" seemingly returns promises.
    if (buffer instanceof Promise) {
      // trigger the callback when the promise has been resolved
      buffer.then(buff => {
        cb.call(this, null, buff);
      });
    } else {
      cb.call(this, null, buffer);
    }
  } else {
    return index.throwError.call(this, "Unsupported MIME type: " + mime, cb);
  }
  return this;
}
function getBufferAsync(mime) {
  return promisify(getBuffer, this, mime);
}

exports.getBuffer = getBuffer;
exports.getBufferAsync = getBufferAsync;
exports.parseBitmap = parseBitmap;
