'use strict';
var __importDefault =
  (this && this.__importDefault) ||
  function (mod) {
    return mod && mod.__esModule ? mod : { default: mod };
  };
Object.defineProperty(exports, '__esModule', { value: true });
const zlib_1 = require('zlib');
const multistream_1 = __importDefault(require('multistream'));
const assert_1 = __importDefault(require('assert'));
const child_process_1 = require('child_process');
const fs_extra_1 = __importDefault(require('fs-extra'));
const into_stream_1 = __importDefault(require('into-stream'));
const path_1 = __importDefault(require('path'));
const stream_meter_1 = __importDefault(require('stream-meter'));
const common_1 = require('./common');
const log_1 = require('./log');
const fabricator_1 = require('./fabricator');
const types_1 = require('./types');
const compress_type_1 = require('./compress_type');
function discoverPlaceholder(binaryBuffer, searchString, padder) {
  const placeholder = Buffer.from(searchString);
  const position = binaryBuffer.indexOf(placeholder);
  if (position === -1) {
    return { notFound: true };
  }
  return { position, size: placeholder.length, padder };
}
function injectPlaceholder(fd, placeholder, value, cb) {
  if ('notFound' in placeholder) {
    (0, assert_1.default)(false, 'Placeholder for not found');
  }
  const { position, size, padder } = placeholder;
  let stringValue = Buffer.from('');
  if (typeof value === 'number') {
    stringValue = Buffer.from(value.toString());
  } else if (typeof value === 'string') {
    stringValue = Buffer.from(value);
  } else {
    stringValue = value;
  }
  const padding = Buffer.from(padder.repeat(size - stringValue.length));
  stringValue = Buffer.concat([stringValue, padding]);
  fs_extra_1.default.write(
    fd,
    stringValue,
    0,
    stringValue.length,
    position,
    cb
  );
}
function discoverPlaceholders(binaryBuffer) {
  return {
    BAKERY: discoverPlaceholder(
      binaryBuffer,
      `\0${'// BAKERY '.repeat(20)}`,
      '\0'
    ),
    PAYLOAD_POSITION: discoverPlaceholder(
      binaryBuffer,
      '// PAYLOAD_POSITION //',
      ' '
    ),
    PAYLOAD_SIZE: discoverPlaceholder(binaryBuffer, '// PAYLOAD_SIZE //', ' '),
    PRELUDE_POSITION: discoverPlaceholder(
      binaryBuffer,
      '// PRELUDE_POSITION //',
      ' '
    ),
    PRELUDE_SIZE: discoverPlaceholder(binaryBuffer, '// PRELUDE_SIZE //', ' '),
  };
}
function injectPlaceholders(fd, placeholders, values, cb) {
  injectPlaceholder(fd, placeholders.BAKERY, values.BAKERY, (error) => {
    if (error) {
      return cb(error);
    }
    injectPlaceholder(
      fd,
      placeholders.PAYLOAD_POSITION,
      values.PAYLOAD_POSITION,
      (error2) => {
        if (error2) {
          return cb(error2);
        }
        injectPlaceholder(
          fd,
          placeholders.PAYLOAD_SIZE,
          values.PAYLOAD_SIZE,
          (error3) => {
            if (error3) {
              return cb(error3);
            }
            injectPlaceholder(
              fd,
              placeholders.PRELUDE_POSITION,
              values.PRELUDE_POSITION,
              (error4) => {
                if (error4) {
                  return cb(error4);
                }
                injectPlaceholder(
                  fd,
                  placeholders.PRELUDE_SIZE,
                  values.PRELUDE_SIZE,
                  cb
                );
              }
            );
          }
        );
      }
    );
  });
}
function makeBakeryValueFromBakes(bakes) {
  const parts = [];
  if (bakes.length) {
    for (let i = 0; i < bakes.length; i += 1) {
      parts.push(Buffer.from(bakes[i]));
      parts.push(Buffer.alloc(1));
    }
    parts.push(Buffer.alloc(1));
  }
  return Buffer.concat(parts);
}
function replaceDollarWise(s, sf, st) {
  return s.replace(sf, () => st);
}
function makePreludeBufferFromPrelude(prelude) {
  return Buffer.from(
    `(function(process, require, console, EXECPATH_FD, PAYLOAD_POSITION, PAYLOAD_SIZE) { ${prelude}\n})` // dont remove \n
  );
}
function findPackageJson(nodeFile) {
  let dir = nodeFile;
  while (dir !== '/') {
    dir = path_1.default.dirname(dir);
    if (
      fs_extra_1.default.existsSync(path_1.default.join(dir, 'package.json'))
    ) {
      break;
    }
  }
  if (dir === '/') {
    throw new Error(`package.json not found for "${nodeFile}"`);
  }
  return dir;
}
function nativePrebuildInstall(target, nodeFile) {
  var _a, _b;
  const prebuildInstall = path_1.default.join(
    __dirname,
    '../node_modules/.bin/prebuild-install'
  );
  const dir = findPackageJson(nodeFile);
  // parse the target node version from the binaryPath
  const nodeVersion = path_1.default.basename(target.binaryPath).split('-')[1];
  if (!/^v[0-9]+\.[0-9]+\.[0-9]+$/.test(nodeVersion)) {
    throw new Error(`Couldn't find node version, instead got: ${nodeVersion}`);
  }
  const nativeFile = `${nodeFile}.${target.platform}.${nodeVersion}`;
  if (fs_extra_1.default.existsSync(nativeFile)) {
    return nativeFile;
  }
  // prebuild-install will overwrite the target .node file, so take a backup
  if (!fs_extra_1.default.existsSync(`${nodeFile}.bak`)) {
    fs_extra_1.default.copyFileSync(nodeFile, `${nodeFile}.bak`);
  }
  const napiVersions =
    (
      (_b =
        (
          (_a = JSON.parse(
            fs_extra_1.default.readFileSync(
              path_1.default.join(dir, 'package.json'),
              { encoding: 'utf-8' }
            )
          )) === null || _a === void 0
        ) ?
          void 0
        : _a.binary) === null || _b === void 0
    ) ?
      void 0
    : _b.napi_versions;
  const options = [
    '--platform',
    types_1.platform[target.platform],
    '--arch',
    target.arch,
  ];
  if (napiVersions == null) {
    // TODO: consider target node version and supported n-api version
    options.push('--target', nodeVersion);
  }
  // run prebuild
  (0, child_process_1.execFileSync)(prebuildInstall, options, { cwd: dir });
  // move the prebuild to a new name with a platform/version extension
  fs_extra_1.default.copyFileSync(nodeFile, nativeFile);
  // put the backed up file back
  fs_extra_1.default.moveSync(`${nodeFile}.bak`, nodeFile, { overwrite: true });
  return nativeFile;
}
/**
 * instead of creating a vfs dicionnary with actual path as key
 * we use a compression mechanism that can reduce significantly
 * the memory footprint of the vfs in the code.
 *
 * without vfs compression:
 *
 * vfs = {
 *   "/folder1/folder2/file1.js": {};
 *   "/folder1/folder2/folder3/file2.js": {};
 *   "/folder1/folder2/folder3/file3.js": {};
 * }
 *
 * with compression :
 *
 * fileDictionary = {
 *    "folder1": "1",
 *    "folder2": "2",
 *    "file1": "3",
 *    "folder3": "4",
 *    "file2": "5",
 *    "file3": "6",
 * }
 * vfs = {
 *   "/1/2/3": {};
 *   "/1/2/4/5": {};
 *   "/1/2/4/6": {};
 * }
 *
 * note: the key is computed in base36 for further compression.
 */
const fileDictionary = {};
let counter = 0;
function getOrCreateHash(fileOrFolderName) {
  let existingKey = fileDictionary[fileOrFolderName];
  if (!existingKey) {
    const newkey = counter;
    counter += 1;
    existingKey = newkey.toString(36);
    fileDictionary[fileOrFolderName] = existingKey;
  }
  return existingKey;
}
const separator = '/';
function makeKey(doCompression, fullpath, slash) {
  if (doCompression === compress_type_1.CompressType.None) return fullpath;
  return fullpath.split(slash).map(getOrCreateHash).join(separator);
}
function producer({
  backpack,
  bakes,
  slash,
  target,
  symLinks,
  doCompress,
  nativeBuild,
}) {
  return new Promise((resolve, reject) => {
    if (!Buffer.alloc) {
      throw (0, log_1.wasReported)(
        'Your node.js does not have Buffer.alloc. Please upgrade!'
      );
    }
    const { prelude } = backpack;
    let { entrypoint, stripes } = backpack;
    entrypoint = (0, common_1.snapshotify)(entrypoint, slash);
    stripes = stripes.slice();
    const vfs = {};
    for (const stripe of stripes) {
      let { snap } = stripe;
      snap = (0, common_1.snapshotify)(snap, slash);
      const vfsKey = makeKey(doCompress, snap, slash);
      if (!vfs[vfsKey]) vfs[vfsKey] = {};
    }
    const snapshotSymLinks = {};
    for (const [key, value] of Object.entries(symLinks)) {
      const k = (0, common_1.snapshotify)(key, slash);
      const v = (0, common_1.snapshotify)(value, slash);
      const vfsKey = makeKey(doCompress, k, slash);
      snapshotSymLinks[vfsKey] = makeKey(doCompress, v, slash);
    }
    let meter;
    let count = 0;
    function pipeToNewMeter(s) {
      meter = (0, stream_meter_1.default)();
      return s.pipe(meter);
    }
    function pipeMayCompressToNewMeter(s) {
      if (doCompress === compress_type_1.CompressType.GZip) {
        return pipeToNewMeter(s.pipe((0, zlib_1.createGzip)()));
      }
      if (doCompress === compress_type_1.CompressType.Brotli) {
        return pipeToNewMeter(s.pipe((0, zlib_1.createBrotliCompress)()));
      }
      return pipeToNewMeter(s);
    }
    function next(s) {
      count += 1;
      return pipeToNewMeter(s);
    }
    const binaryBuffer = fs_extra_1.default.readFileSync(target.binaryPath);
    const placeholders = discoverPlaceholders(binaryBuffer);
    let track = 0;
    let prevStripe;
    let payloadPosition;
    let payloadSize;
    let preludePosition;
    let preludeSize;
    new multistream_1.default((cb) => {
      if (count === 0) {
        return cb(null, next((0, into_stream_1.default)(binaryBuffer)));
      }
      if (count === 1) {
        payloadPosition = meter.bytes;
        return cb(null, next((0, into_stream_1.default)(Buffer.alloc(0))));
      }
      if (count === 2) {
        if (prevStripe && !prevStripe.skip) {
          const { store } = prevStripe;
          let { snap } = prevStripe;
          snap = (0, common_1.snapshotify)(snap, slash);
          const vfsKey = makeKey(doCompress, snap, slash);
          vfs[vfsKey][store] = [track, meter.bytes];
          track += meter.bytes;
        }
        if (stripes.length) {
          // clone to prevent 'skip' propagate
          // to other targets, since same stripe
          // is used for several targets
          const stripe = Object.assign({}, stripes.shift());
          prevStripe = stripe;
          if (stripe.buffer) {
            if (stripe.store === common_1.STORE_BLOB) {
              const snap = (0, common_1.snapshotify)(stripe.snap, slash);
              return (0, fabricator_1.fabricateTwice)(
                bakes,
                target.fabricator,
                snap,
                stripe.buffer,
                (error, buffer) => {
                  if (error) {
                    log_1.log.warn(error.message);
                    stripe.skip = true;
                    return cb(
                      null,
                      (0, into_stream_1.default)(Buffer.alloc(0))
                    );
                  }
                  cb(
                    null,
                    pipeMayCompressToNewMeter(
                      (0, into_stream_1.default)(buffer || Buffer.from(''))
                    )
                  );
                }
              );
            }
            return cb(
              null,
              pipeMayCompressToNewMeter(
                (0, into_stream_1.default)(stripe.buffer)
              )
            );
          }
          if (stripe.file) {
            if (stripe.file === target.output) {
              return cb(
                (0, log_1.wasReported)(
                  'Trying to take executable into executable',
                  stripe.file
                ),
                null
              );
            }
            assert_1.default.strictEqual(stripe.store, common_1.STORE_CONTENT); // others must be buffers from walker
            if ((0, common_1.isDotNODE)(stripe.file) && nativeBuild) {
              try {
                const platformFile = nativePrebuildInstall(target, stripe.file);
                if (fs_extra_1.default.existsSync(platformFile)) {
                  return cb(
                    null,
                    pipeMayCompressToNewMeter(
                      fs_extra_1.default.createReadStream(platformFile)
                    )
                  );
                }
              } catch (err) {
                log_1.log.debug(
                  `prebuild-install failed[${stripe.file}]:`,
                  err.message
                );
              }
            }
            return cb(
              null,
              pipeMayCompressToNewMeter(
                fs_extra_1.default.createReadStream(stripe.file)
              )
            );
          }
          (0, assert_1.default)(false, 'producer: bad stripe');
        } else {
          payloadSize = track;
          preludePosition = payloadPosition + payloadSize;
          return cb(
            null,
            next(
              (0, into_stream_1.default)(
                makePreludeBufferFromPrelude(
                  replaceDollarWise(
                    replaceDollarWise(
                      replaceDollarWise(
                        replaceDollarWise(
                          replaceDollarWise(
                            prelude,
                            '%VIRTUAL_FILESYSTEM%',
                            JSON.stringify(vfs)
                          ),
                          '%DEFAULT_ENTRYPOINT%',
                          JSON.stringify(entrypoint)
                        ),
                        '%SYMLINKS%',
                        JSON.stringify(snapshotSymLinks)
                      ),
                      '%DICT%',
                      JSON.stringify(fileDictionary)
                    ),
                    '%DOCOMPRESS%',
                    JSON.stringify(doCompress)
                  )
                )
              )
            )
          );
        }
      } else {
        return cb(null, null);
      }
    })
      .on('error', (error) => {
        reject(error);
      })
      .pipe(fs_extra_1.default.createWriteStream(target.output))
      .on('error', (error) => {
        reject(error);
      })
      .on('close', () => {
        preludeSize = meter.bytes;
        fs_extra_1.default.open(target.output, 'r+', (error, fd) => {
          if (error) return reject(error);
          injectPlaceholders(
            fd,
            placeholders,
            {
              BAKERY: makeBakeryValueFromBakes(bakes),
              PAYLOAD_POSITION: payloadPosition,
              PAYLOAD_SIZE: payloadSize,
              PRELUDE_POSITION: preludePosition,
              PRELUDE_SIZE: preludeSize,
            },
            (error2) => {
              if (error2) return reject(error2);
              fs_extra_1.default.close(fd, (error3) => {
                if (error3) return reject(error3);
                resolve();
              });
            }
          );
        });
      });
  });
}
exports.default = producer;
//# sourceMappingURL=producer.js.map