// Module ID: 4714
// Function ID: 41008
// Name: _shouldConvertToWebP
// Dependencies: [5, 3, 4715, 1193, 2]
// Exports: maybeConvertToWebP

// Module 4714 (_shouldConvertToWebP)
import asyncGeneratorStep from "asyncGeneratorStep";
import importDefaultResult from "createBuffer";

const require = arg1;
function _shouldConvertToWebP() {
  return _shouldConvertToWebP2(...arguments);
}
async function _shouldConvertToWebP2(arg0, arg1) {
  let obj = arg0;
  let closure_0 = arg0;
  if ("image/webp" === arg0.type) {
    outer2_4.verbose("[WebP] File already WebP format");
    return outer2_5.ALREADY_WEBP;
  } else {
    const items = ["image/png"];
    if (items.includes(obj.type)) {
      if ("function" === typeof obj.arrayBuffer) {
        const tmp15 = yield obj.arrayBuffer();
        const DiscordImageFactory = outer2_0(outer2_2[2]).DiscordImageFactory;
        obj = DiscordImageFactory.create(tmp15);
        if (null == obj) {
          const _Error = Error;
          let error = new Error("DiscordImage.create returned null");
          throw error;
        } else if (obj2.hasTransparency()) {
          outer2_4.verbose("[webp] png uses actual transparency - skipping conversion");
          return outer2_5.HAS_TRANSPARENCY;
        } else if (obj2.isAnimated()) {
          outer2_4.verbose("[webp] png is animated (apng) - skipping conversion");
          return outer2_5.ANIMATED_IMAGE;
        } else if (obj2.isPng8()) {
          outer2_4.verbose("[webp] png is PNG8 format (indexed color) - skipping conversion");
          return outer2_5.PNG8_FORMAT;
        } else if (yield obj2.hasSrgbIccProfile()) {
          return null;
        } else {
          return outer2_5.ICC_NON_SRGB_PROFILE;
        }
        const tmp16 = tmp15;
      } else {
        const promise = new Promise((closure_0) => {
          let closure_1 = arg1;
          const fileReader = new FileReader();
          fileReader.onload = () => callback(fileReader.result);
          fileReader.onerror = () => {
            const error = new Error("Failed to read file as ArrayBuffer");
            return callback2(error);
          };
          const asArrayBuffer = fileReader.readAsArrayBuffer(closure_0);
        });
        const tmp11 = yield promise;
        return tmp11;
      }
    } else {
      const _HermesInternal = HermesInternal;
      outer2_4.verbose("[WebP] Unsupported format: " + obj.type);
      return outer2_5.UNSUPPORTED_FORMAT;
    }
  }
}
function hashImageData(data) {
  const uint8Array = new Uint8Array(data.data.buffer);
  return importDefault(1193)(uint8Array).toString(16);
}
async function _performWebPConversion(arg0, arg1) {
  let height;
  let width;
  let size;
  let image;
  let objectURL;
  let image1;
  objectURL = undefined;
  size = <canvas />;
  const size2 = size;
  const context = size.getContext("2d");
  let obj = context;
  if (null == context) {
    const _Error2 = Error;
    let error = new Error("could not get canvas context");
    throw error;
  } else {
    const prototype6 = globalThis.Image.prototype;
    image = new globalThis.Image();
    const _URL4 = URL;
    objectURL = URL.createObjectURL(arg0);
    yield new Promise((arg0, arg1) => {
      let closure_0 = arg0;
      let closure_1 = arg1;
      closure_1.onload = () => callback();
      closure_1.onerror = () => {
        const error = new Error("failed to load image");
        return callback2(error);
      };
      closure_1.src = objectURL;
    });
    ({ width: size2.width, height: size2.height } = image);
    obj.drawImage(image, 0, 0);
    const _URL = URL;
    URL.revokeObjectURL(objectURL);
    const tmp10 = yield new Promise((arg0) => {
      size.toBlob(arg0, "image/webp", 1);
    });
    if (null == tmp10) {
      const _Error = Error;
      const error1 = new Error("failed to convert to webp");
      throw error1;
    } else {
      const _performance2 = performance;
      const tmp75 = yield obj.getImageData(0, 0, size2.width, size2.height);
      obj.clearRect(0, 0, size2.width, size2.height);
      const prototype2 = globalThis.Image.prototype;
      image1 = new globalThis.Image();
      const _URL2 = URL;
      objectURL = URL.createObjectURL(tmp11);
      yield new Promise((arg0, arg1) => {
        let closure_0 = arg0;
        let closure_1 = arg1;
        image1.onload = () => callback();
        image1.onerror = () => {
          const error = new Error("failed to load image");
          return callback2(error);
        };
        image1.src = objectURL;
      });
      obj.drawImage(image1, 0, 0);
      const _URL3 = URL;
      URL.revokeObjectURL(objectURL);
      const nowResult = performance.now();
      const tmp21 = image1;
      const tmp24 = objectURL;
      const tmp37 = outer2_8(tmp75);
      const tmp38 = outer2_8(yield obj.getImageData(0, 0, size.width, size.height));
      const _performance = performance;
      const diff = performance.now() - nowResult;
      const name = arg0.name;
      const _Math = Math;
      ({ width, height } = image1);
      const _HermesInternal = HermesInternal;
      outer2_4.verbose("[WebP] Pixel hash results: fileName=" + name + " fileLength={" + arg0.size + "} width=" + width + " height=" + height + " pixelHash=" + tmp37 + " mezzanineFileLength={" + tmp11.size + "} mezzaninePixelHash=" + tmp38 + " match=" + tmp37 === tmp38 + " elapsed_ms=" + Math.round(diff));
      obj = {};
      if (tmp37 === tmp38) {
        obj.success = true;
        obj.webpBlob = tmp10;
        obj.pixelHashTimeMs = diff;
        let tmp51 = obj;
      } else {
        obj.success = false;
        obj.reason = outer2_5.PIXEL_HASH_MISMATCH;
        obj.pixelHashTimeMs = diff;
        tmp51 = obj;
      }
      return tmp51;
    }
    const tmp63 = image;
    const tmp67 = objectURL;
  }
}
async function _maybeConvertToWebP(arg0, arg1) {
  let closure_0 = arg0;
  let c1;
  function createFailedResult(INSUFFICIENT_SAVINGS, size) {
    if (size === undefined) {
      size = closure_0.size;
    }
    const obj = { success: false, originalFile: closure_0, sizeBefore: closure_0.size, sizeAfter: size };
    let num = 1;
    if (closure_0.size > 0) {
      num = size / closure_0.size;
    }
    obj.compressionRatio = num;
    obj.reason = INSUFFICIENT_SAVINGS;
    obj.compressTimeMs = Math.round(performance.now() - c1);
    return obj;
  }
  if (null == arg0) {
    const _Error = Error;
    const error = new Error("file is null or undefined");
    throw error;
  } else {
    const _HermesInternal3 = HermesInternal;
    outer2_4.verbose("[WebP] Starting conversion for: " + tmp.name);
    const _performance = performance;
    const nowResult = performance.now();
    c1 = nowResult;
    const tmp36 = yield outer2_6(tmp);
    if (null != tmp36) {
      const _HermesInternal2 = HermesInternal;
      outer2_4.verbose("[WebP] Conversion rejected: " + tmp2);
      return createFailedResult(tmp2);
    } else {
      const tmp38 = yield (function performWebPConversion(arg0) {
        return outer3_9(...arguments);
      })(tmp);
      if (tmp38.success) {
        if (null != tmp3.webpBlob) {
          const webpBlob = tmp3.webpBlob;
          let num = 1;
          if (tmp.size > 0) {
            num = webpBlob.size / tmp.size;
          }
          const diff = 1 - num;
          if (diff < 0) {
            const _Math = Math;
            const _HermesInternal = HermesInternal;
            outer2_4.verbose("[WebP] Insufficient savings: " + Math.round(100 * tmp9) + "% < 0% (" + tmp.size + " -> " + webpBlob.size + " bytes)");
            let failedResult = createFailedResult(outer2_5.INSUFFICIENT_SAVINGS, webpBlob.size);
          } else {
            const _performance2 = performance;
            const diff1 = performance.now() - nowResult;
            const name = tmp.name;
            const _Math2 = Math;
            const _HermesInternal4 = HermesInternal;
            outer2_4.verbose("[WebP] Conversion successful: " + name + " to WebP in " + Math.round(diff1) + "ms");
            failedResult = { success: true, originalFile: tmp, convertedBlob: webpBlob, sizeBefore: tmp.size, sizeAfter: webpBlob.size, compressionRatio: num, hashTimeMs: tmp3.pixelHashTimeMs };
            const _Math3 = Math;
            failedResult.compressTimeMs = Math.round(diff1);
          }
          return failedResult;
        }
      }
      const reason = tmp38.reason;
      if (null != reason) {
        let UNKNOWN_ERROR = reason;
      } else {
        UNKNOWN_ERROR = outer2_5.UNKNOWN_ERROR;
      }
      return createFailedResult(UNKNOWN_ERROR);
    }
  }
}
importDefaultResult = new importDefaultResult("WebP");
let obj = { ALREADY_WEBP: "already_webp", UNSUPPORTED_FORMAT: "unsupported_format", ANIMATED_IMAGE: "animated_image", HAS_TRANSPARENCY: "has_transparency", PNG8_FORMAT: "png8_format", INSUFFICIENT_SAVINGS: "insufficient_savings", CONVERSION_FAILED: "conversion_failed", CORRUPTED_FILE: "corrupted_file", PIXEL_HASH_MISMATCH: "pixel_hash_mismatch", ICC_NON_SRGB_PROFILE: "icc_non_srgb_profile", ICC_DETECTION_FAILED: "icc_detection_failed", UNKNOWN_ERROR: "unknown_error" };
const result = require("DiscordImageFactory").fileFinishedImporting("lib/uploader/webpConversion.tsx");

export const ConversionFailureReason = obj;
export { _shouldConvertToWebP };
export const maybeConvertToWebP = function maybeConvertToWebP(size) {
  return _maybeConvertToWebP(...arguments);
};