import { promises as fs } from 'fs';
import originalFs from 'original-fs';
import fse from 'fs-extra';
import { extractFull } from 'node-7z';
import jimp from 'jimp/es';
import makeDir from 'make-dir';
import { promisify } from 'util';
import { ipcRenderer } from 'electron';
import path from 'path';
import crypto from 'crypto';
import { exec, spawn } from 'child_process';
import {
  MC_LIBRARIES_URL,
  FABRIC,
  FORGE,
  LATEST_JAVA_VERSION
} from '../../../common/utils/constants';

import {
  addQuotes,
  removeDuplicates,
  sortByForgeVersionDesc
} from '../../../common/utils';
import { getAddon, getAddonFile, mcGetPlayerSkin } from '../../../common/api';
import { downloadFile } from './downloader';
import browserDownload from '../../../common/utils/browserDownload';
import { REQUIRED_JAVA_ARGS } from './constants';

export const isDirectory = source =>
  fs.lstat(source).then(r => r.isDirectory());

export const getDirectories = async source => {
  const dirs = await fs.readdir(source);
  return Promise.all(
    dirs
      .map(name => path.join(source, name))
      .filter(isDirectory)
      .map(dir => path.basename(dir))
  );
};

export const mavenToArray = (s, nativeString, forceExt) => {
  const pathSplit = s.split(':');
  const fileName = pathSplit[3]
    ? `${pathSplit[2]}-${pathSplit[3]}`
    : pathSplit[2];
  const finalFileName = fileName.includes('@')
    ? fileName.replace('@', '.')
    : `${fileName}${nativeString || ''}${forceExt || '.jar'}`;
  const initPath = pathSplit[0]
    .split('.')
    .concat(pathSplit[1])
    .concat(pathSplit[2].split('@')[0])
    .concat(`${pathSplit[1]}-${finalFileName}`);
  return initPath;
};

export const convertOSToMCFormat = ElectronFormat => {
  switch (ElectronFormat) {
    case 'win32':
      return 'windows';
    case 'darwin':
      return 'osx';
    case 'linux':
      return 'linux';
    default:
      return false;
  }
};

export const convertOSToJavaFormat = ElectronFormat => {
  switch (ElectronFormat) {
    case 'win32':
      return 'windows';
    case 'darwin':
      return 'mac';
    case 'linux':
      return 'linux';
    default:
      return false;
  }
};

export const convertArchToJavaFormat = ElectronFormat => {
  switch (ElectronFormat) {
    case 'x64':
      return 'x64';
    case 'ia32':
      return 'x32';
    case 'arm':
      return 'arm';
    case 'arm64':
      return 'aarch64';
    default:
      return false;
  }
};

export const skipLibrary = lib => {
  let skip = false;
  if (lib.rules) {
    skip = true;
    lib.rules.forEach(({ action, os, features }) => {
      if (features) return true;
      if (
        action === 'allow' &&
        ((os && os.name === convertOSToMCFormat(process.platform)) || !os)
      ) {
        skip = false;
      }
      if (
        action === 'disallow' &&
        ((os && os.name === convertOSToMCFormat(process.platform)) || !os)
      ) {
        skip = true;
      }
    });
  }
  return skip;
};

export const librariesMapper = (libraries, librariesPath) => {
  return removeDuplicates(
    libraries
      .filter(v => !skipLibrary(v))
      .reduce((acc, lib) => {
        const tempArr = [];
        // Forge libs
        if (lib.downloads && lib.downloads.artifact) {
          let { url } = lib.downloads.artifact;
          // Handle special case for forge universal where the url is "".
          if (lib.downloads.artifact.url === '') {
            url = `https://files.minecraftforge.net/${mavenToArray(
              lib.name
            ).join('/')}`;
          }
          tempArr.push({
            url,
            path: path.join(librariesPath, lib.downloads.artifact.path),
            sha1: lib.downloads.artifact.sha1,
            name: lib.name
          });
        }

        const native = (
          (lib?.natives &&
            lib?.natives[convertOSToMCFormat(process.platform)]) ||
          ''
        ).replace(
          '${arch}', // eslint-disable-line no-template-curly-in-string
          '64'
        );

        // Vanilla native libs
        if (native && lib?.downloads?.classifiers[native]) {
          tempArr.push({
            url: lib.downloads.classifiers[native].url,
            path: path.join(
              librariesPath,
              lib.downloads.classifiers[native].path
            ),
            sha1: lib.downloads.classifiers[native].sha1,
            natives: true,
            name: lib.name
          });
        }
        if (tempArr.length === 0) {
          tempArr.push({
            url: `${lib.url || `${MC_LIBRARIES_URL}/`}${mavenToArray(
              lib.name,
              native && `-${native}`
            ).join('/')}`,
            path: path.join(librariesPath, ...mavenToArray(lib.name, native)),
            ...(native && { natives: true }),
            name: lib.name
          });
        }
        // Patch log4j versions https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-44228
        for (const k in tempArr) {
          if (tempArr[k]?.url?.includes('log4j')) {
            // Get rid of all log4j aside from official
            if (!tempArr[k].url.includes('libraries.minecraft.net')) {
              tempArr[k] = null;
              continue;
            }

            if (tempArr[k].url.includes('2.0-beta9')) {
              tempArr[k] = {
                url: tempArr[k].url
                  .replace(
                    'libraries.minecraft.net',
                    'cdn.gdlauncher.com/maven'
                  )
                  .replace(/2.0-beta9/g, '2.0-beta9-fixed'),
                path: tempArr[k].path.replace(/2.0-beta9/g, '2.0-beta9-fixed'),
                sha1: tempArr[k].url.includes('log4j-api')
                  ? 'b61eaf2e64d8b0277e188262a8b771bbfa1502b3'
                  : '677991ea2d7426f76309a73739cecf609679492c',
                name: tempArr[k].name
              };
            } else {
              const splitName = tempArr[k].name.split(':');
              splitName[splitName.length - 1] = '2.15.0';
              const patchedName = splitName.join(':');

              // Assuming we can use 2.15
              tempArr[k] = {
                url: `https://cdn.gdlauncher.com/maven/${mavenToArray(
                  patchedName,
                  native
                ).join(path.sep)}`,
                path: path.join(
                  librariesPath,
                  ...mavenToArray(patchedName, native)
                ),
                sha1: tempArr[k].url.includes('log4j-api')
                  ? '42319af9991a86b4475ab3316633a3d03e2d29e1'
                  : '9bd89149d5083a2a3ab64dcc88b0227da14152ec'
              };
            }
          }
        }

        return acc.concat(tempArr.filter(_ => _));
      }, []),
    'url'
  );
};

export const getFilteredVersions = (
  vanillaManifest,
  forgeManifest,
  fabricManifest
) => {
  const versions = [
    {
      value: 'vanilla',
      label: 'Vanilla',
      children: [
        {
          value: 'release',
          label: 'Releases',
          children: vanillaManifest.versions
            .filter(v => v.type === 'release')
            .map(v => ({
              value: v.id,
              label: v.id
            }))
        },
        {
          value: 'snapshot',
          label: 'Snapshots',
          children: vanillaManifest.versions
            .filter(v => v.type === 'snapshot')
            .map(v => ({
              value: v.id,
              label: v.id
            }))
        },
        {
          value: 'old_beta',
          label: 'Old Beta',
          children: vanillaManifest.versions
            .filter(v => v.type === 'old_beta')
            .map(v => ({
              value: v.id,
              label: v.id
            }))
        },
        {
          value: 'old_alpha',
          label: 'Old Alpha',
          children: vanillaManifest.versions
            .filter(v => v.type === 'old_alpha')
            .map(v => ({
              value: v.id,
              label: v.id
            }))
        }
      ]
    },
    {
      value: 'forge',
      label: 'Forge',
      children: Object.entries(forgeManifest).map(([k, v]) => ({
        value: k,
        label: k,
        children: v.sort(sortByForgeVersionDesc).map(child => ({
          value: child,
          label: child.split('-')[1]
        }))
      }))
    },
    {
      value: 'fabric',
      label: 'Fabric',
      children: [
        {
          value: 'release',
          label: 'Releases',
          children: fabricManifest.game
            .filter(v => v.stable)
            .map(v => ({
              value: v.version,
              label: v.version,
              children: fabricManifest.loader.map(c => ({
                value: c.version,
                label: c.version
              }))
            }))
        },
        {
          value: 'snapshot',
          label: 'Snapshots',
          children: fabricManifest.game
            .filter(v => !v.stable)
            .map(v => ({
              value: v.version,
              label: v.version,
              children: fabricManifest.loader.map(c => ({
                value: c.version,
                label: c.version
              }))
            }))
        }
      ]
    }
  ];
  return versions;
};

export const isLatestJavaDownloaded = async (
  meta,
  userData,
  retry,
  version = 8
) => {
  const javaOs = convertOSToJavaFormat(process.platform);
  const javaArch = convertArchToJavaFormat(process.arch);
  let log = null;

  const isJavaLatest = version === LATEST_JAVA_VERSION;

  const manifest = isJavaLatest ? meta.javaLatest : meta.java;

  const javaMeta = manifest.find(
    v =>
      v.os === javaOs &&
      v.architecture === javaArch &&
      (v.binary_type === 'jre' || v.binary_type === 'jdk')
  );
  const javaFolder = path.join(
    userData,
    'java',
    javaMeta.version_data.openjdk_version
  );
  // Check if it's downloaded, if it's latest version and if it's a valid download
  let isValid = true;

  const javaExecutable = path.join(
    javaFolder,
    'bin',
    `java${javaOs === 'windows' ? '.exe' : ''}`
  );
  try {
    await fs.access(javaFolder);
    log = await promisify(exec)(`"${javaExecutable}" -version`);
  } catch (err) {
    if (retry) {
      if (process.platform !== 'win32') {
        try {
          await promisify(exec)(`chmod +x "${javaExecutable}"`);
          await promisify(exec)(`chmod 755 "${javaExecutable}"`);
        } catch {
          // swallow error
        }
      }

      return isLatestJavaDownloaded(meta, userData, null, version);
    }

    isValid = false;
  }
  // Return stderr because that garbage of a language which is java
  // outputs the result of the version command to the error stream
  // https://stackoverflow.com/questions/13483443/why-does-java-version-go-to-stderr
  return { isValid, log: log?.stderr };
};

export const get7zPath = async () => {
  // Get userData from ipc because we can't always get this from redux
  let baseDir = await ipcRenderer.invoke('getExecutablePath');
  const isDev = process.env.NODE_ENV === 'development';
  if (isDev) {
    baseDir = path.resolve(baseDir, '../../');
    if (process.platform === 'win32') {
      baseDir = path.join(baseDir, '7zip-bin/win/x64');
    } else if (process.platform === 'linux') {
      baseDir = path.join(baseDir, '7zip-bin/linux/x64');
    } else if (process.platform === 'darwin') {
      baseDir = path.resolve(baseDir, '../../../', '7zip-bin/mac/x64');
    }
  }
  if (process.platform === 'linux') {
    return path.join(baseDir, '7za');
  }
  if (process.platform === 'darwin') {
    return path.resolve(baseDir, isDev ? '' : '../', '7za');
  }
  return path.join(baseDir, '7za.exe');
};

get7zPath();

export const extractAll = async (
  source,
  destination,
  args = {},
  funcs = {}
) => {
  const sevenZipPath = await get7zPath();
  const extraction = extractFull(source, destination, {
    ...args,
    yes: true,
    $bin: sevenZipPath,
    $spawnOptions: { shell: true }
  });
  let extractedParentDir = null;
  await new Promise((resolve, reject) => {
    if (funcs.progress) {
      extraction.on('progress', ({ percent }) => {
        funcs.progress(percent);
      });
    }
    extraction.on('data', data => {
      if (!extractedParentDir) {
        [extractedParentDir] = data.file.split('/');
      }
    });
    extraction.on('end', () => {
      funcs.end?.();
      resolve(extractedParentDir);
    });
    extraction.on('error', err => {
      funcs.error?.();
      reject(err);
    });
  });
  return { extraction, extractedParentDir };
};

export const extractNatives = async (libraries, instancePath) => {
  const extractLocation = path.join(instancePath, 'natives');
  await Promise.all(
    libraries
      .filter(l => l.natives)
      .map(async l => {
        await extractAll(l.path, extractLocation, {
          $raw: ['-xr!META-INF']
        });
      })
  );
};

export const copyAssetsToResources = async assets => {
  await Promise.all(
    assets.map(async asset => {
      try {
        await fs.access(asset.resourcesPath);
      } catch {
        await makeDir(path.dirname(asset.resourcesPath));
        await fs.copyFile(asset.path, asset.resourcesPath);
      }
    })
  );
};

export const copyAssetsToLegacy = async assets => {
  await Promise.all(
    assets.map(async asset => {
      try {
        await fs.access(asset.legacyPath);
      } catch {
        await makeDir(path.dirname(asset.legacyPath));
        await fs.copyFile(asset.path, asset.legacyPath);
      }
    })
  );
};

const hiddenToken = '__HIDDEN_TOKEN__';
export const getJVMArguments112 = (
  libraries,
  mcjar,
  instancePath,
  assetsPath,
  mcJson,
  account,
  memory,
  resolution,
  hideAccessToken,
  jvmOptions = []
) => {
  const needsQuote = process.platform !== 'win32';
  const args = [];
  args.push('-cp');

  args.push(
    [...libraries, mcjar]
      .filter(l => !l.natives)
      .map(l => `${addQuotes(needsQuote, l.path)}`)
      .join(process.platform === 'win32' ? ';' : ':')
  );

  const javaArgs = jvmOptions.filter(Boolean);

  // if (process.platform === "darwin") {
  //   args.push("-Xdock:name=instancename");
  //   args.push("-Xdock:icon=instanceicon");
  // }

  args.push(`-Xmx${memory}m`);
  args.push(`-Xms${memory}m`);
  args.push(...REQUIRED_JAVA_ARGS.split(' '));
  if (javaArgs.length > 0) args.push(...javaArgs);
  args.push(
    `-Djava.library.path=${addQuotes(
      needsQuote,
      path.join(instancePath, 'natives')
    )}`
  );
  args.push(
    `-Dminecraft.applet.TargetDirectory=${addQuotes(needsQuote, instancePath)}`
  );
  if (mcJson.logging) {
    args.push(mcJson?.logging?.client?.argument || '');
  }

  args.push(mcJson.mainClass);

  const mcArgs = mcJson.minecraftArguments.split(' ');
  const argDiscovery = /\${*(.*)}/;

  for (let i = 0; i < mcArgs.length; i += 1) {
    if (argDiscovery.test(mcArgs[i])) {
      const identifier = mcArgs[i].match(argDiscovery)[1];
      let val = null;
      switch (identifier) {
        case 'auth_player_name':
          val = account.selectedProfile.name.trim();
          break;
        case 'version_name':
          val = mcJson.id;
          break;
        case 'game_directory':
          val = `${addQuotes(needsQuote, instancePath)}`;
          break;
        case 'assets_root':
          val = `${addQuotes(needsQuote, assetsPath)}`;
          break;
        case 'game_assets':
          val = `${path.join(assetsPath, 'virtual', 'legacy')}`;
          break;
        case 'assets_index_name':
          val = mcJson.assets;
          break;
        case 'auth_uuid':
          val = account.selectedProfile.id.trim();
          break;
        case 'auth_access_token':
          val = hideAccessToken ? hiddenToken : account.accessToken;
          break;
        case 'auth_session':
          val = hideAccessToken ? hiddenToken : account.accessToken;
          break;
        case 'user_type':
          val = 'mojang';
          break;
        case 'version_type':
          val = mcJson.type;
          break;
        case 'user_properties':
          val = '{}';
          break;
        default:
          break;
      }
      if (val != null) {
        mcArgs[i] = val;
      }
      if (typeof args[i] === 'string' && !needsQuote) {
        args[i] = args[i].replaceAll('"', '');
      }
    }
  }

  args.push(...mcArgs);

  if (resolution) {
    args.push(`--width=${resolution.width}`);
    args.push(`--height=${resolution.height}`);
  }

  return args;
};

export const getJVMArguments113 = (
  libraries,
  mcjar,
  instancePath,
  assetsPath,
  mcJson,
  account,
  memory,
  resolution,
  hideAccessToken,
  jvmOptions = []
) => {
  const argDiscovery = /\${*(.*)}/;
  let args = mcJson.arguments.jvm.filter(v => !skipLibrary(v));
  const needsQuote = process.platform !== 'win32';

  const javaArgs = jvmOptions.filter(Boolean);
  // if (process.platform === "darwin") {
  //   args.push("-Xdock:name=instancename");
  //   args.push("-Xdock:icon=instanceicon");
  // }
  args.push(`-Xmx${memory}m`);
  args.push(`-Xms${memory}m`);
  args.push(
    `-Dminecraft.applet.TargetDirectory=${addQuotes(needsQuote, instancePath)}`
  );
  if (mcJson.logging) {
    args.push(mcJson?.logging?.client?.argument || '');
  }

  args.push(...REQUIRED_JAVA_ARGS.split(' '));
  if (javaArgs.length > 0) args.push(...javaArgs);

  // Eventually inject additional arguments (from 1.17 (?))
  if (mcJson?.forge?.arguments?.jvm) {
    args.push(...mcJson.forge.arguments.jvm);
  }

  args.push(mcJson.mainClass);

  args.push(...mcJson.arguments.game.filter(v => !skipLibrary(v)));

  for (let i = 0; i < args.length; i += 1) {
    if (typeof args[i] === 'object' && args[i].rules) {
      if (typeof args[i].value === 'string') {
        args[i] = `${addQuotes(needsQuote, args[i].value)}`;
      } else if (typeof args[i].value === 'object') {
        args.splice(i, 1, ...args[i].value.map(v => `${v}`));
      }
      i -= 1;
    } else if (typeof args[i] === 'string') {
      if (argDiscovery.test(args[i])) {
        const identifier = args[i].match(argDiscovery)[1];
        let val = null;
        switch (identifier) {
          case 'auth_player_name':
            val = account.selectedProfile.name.trim();
            break;
          case 'version_name':
            val = mcJson.id;
            break;
          case 'game_directory':
            val = `${addQuotes(needsQuote, instancePath)}`;
            break;
          case 'assets_root':
            val = `${addQuotes(needsQuote, assetsPath)}`;
            break;
          case 'assets_index_name':
            val = mcJson.assets;
            break;
          case 'auth_uuid':
            val = account.selectedProfile.id.trim();
            break;
          case 'auth_access_token':
            val = hideAccessToken ? hiddenToken : account.accessToken;
            break;
          case 'user_type':
            val = 'mojang';
            break;
          case 'version_type':
            val = mcJson.type;
            break;
          case 'resolution_width':
            val = 800;
            break;
          case 'resolution_height':
            val = 600;
            break;
          case 'natives_directory':
            val = args[i].replace(
              argDiscovery,
              `${addQuotes(needsQuote, path.join(instancePath, 'natives'))}`
            );
            break;
          case 'launcher_name':
            val = args[i].replace(argDiscovery, 'GDLauncher');
            break;
          case 'launcher_version':
            val = args[i].replace(argDiscovery, '1.0');
            break;
          case 'classpath':
            val = [...libraries, mcjar]
              .filter(l => !l.natives)
              .map(l => `${addQuotes(needsQuote, l.path)}`)
              .join(process.platform === 'win32' ? ';' : ':');
            break;
          default:
            break;
        }
        if (val !== null) {
          args[i] = val;
        }
      }
      if (!needsQuote) args[i] = args[i].replaceAll('"', '');
    }
  }

  if (resolution) {
    args.push(`--width=${resolution.width}`);
    args.push(`--height=${resolution.height}`);
  }

  args = args.filter(arg => {
    return arg != null;
  });

  return args;
};

export const readJarManifest = async (jarPath, property) => {
  const { extraction: list } = await extractAll(jarPath, '.', {
    toStdout: true,
    $cherryPick: 'META-INF/MANIFEST.MF'
  });

  if (list.info.has(property)) return list.info.get(property);
  return null;
};

export const patchForge113 = async (
  forgeJson,
  mainJar,
  librariesPath,
  installerPath,
  mcJsonPath,
  universalPath,
  javaPath,
  updatePercentage
) => {
  const { processors } = forgeJson;
  const replaceIfPossible = arg => {
    const finalArg = arg.replace('{', '').replace('}', '');
    if (forgeJson.data[finalArg]) {
      // Handle special case
      if (finalArg === 'BINPATCH') {
        return `"${path
          .join(librariesPath, ...mavenToArray(forgeJson.path || universalPath))
          .replace('.jar', '-clientdata.lzma')}"`;
      }
      // Return replaced string
      return forgeJson.data[finalArg].client;
    }
    // Fix forge madness
    return arg
      .replace('{SIDE}', `client`)
      .replace('{ROOT}', `"${path.dirname(installerPath)}"`)
      .replace('{MINECRAFT_JAR}', `"${mainJar}"`)
      .replace('{MINECRAFT_VERSION}', `"${mcJsonPath}"`)
      .replace('{INSTALLER}', `"${installerPath}"`)
      .replace('{LIBRARY_DIR}', `"${librariesPath}"`);
  };
  const computePathIfPossible = arg => {
    if (arg[0] === '[') {
      return `"${path.join(
        librariesPath,
        ...mavenToArray(arg.replace('[', '').replace(']', ''))
      )}"`;
    }
    return arg;
  };

  let counter = 1;
  /* eslint-disable no-await-in-loop, no-restricted-syntax */
  for (const key in processors) {
    if (Object.prototype.hasOwnProperty.call(processors, key)) {
      const p = processors[key];
      if (p?.sides && !(p?.sides || []).includes('client')) {
        continue;
      }
      const filePath = path.join(librariesPath, ...mavenToArray(p.jar));
      const args = p.args
        .map(arg => replaceIfPossible(arg))
        .map(arg => computePathIfPossible(arg));

      const classPaths = p.classpath.map(
        cp => `"${path.join(librariesPath, ...mavenToArray(cp))}"`
      );

      const mainClass = await readJarManifest(filePath, 'Main-Class');

      await new Promise(resolve => {
        const ps = spawn(
          `"${javaPath}"`,
          [
            '-classpath',
            [`"${filePath}"`, ...classPaths].join(path.delimiter),
            mainClass,
            ...args
          ],
          { shell: true }
        );

        ps.stdout.on('data', data => {
          console.log(data.toString());
        });

        ps.stderr.on('data', data => {
          console.error(`ps stderr: ${data}`);
        });

        ps.on('close', code => {
          if (code !== 0) {
            console.log(`process exited with code ${code}`);
            resolve();
          }
          resolve();
        });
      });
      updatePercentage(counter, processors.length);
      counter += 1;
    }
  }
  /* eslint-enable no-await-in-loop, no-restricted-syntax */
};

export const importAddonZip = async (
  zipPath,
  instancePath,
  instanceTempPath,
  tempPath
) => {
  const tempZipFile = path.join(instanceTempPath, 'addon.zip');
  await makeDir(instanceTempPath);
  if (zipPath.includes(tempPath)) {
    await fse.move(zipPath, tempZipFile);
  } else {
    await fse.copyFile(zipPath, tempZipFile);
  }
  const instanceManifest = path.join(instancePath, 'manifest.json');
  // Wait 500ms to avoid `The process cannot access the file because it is being used by another process.`
  await new Promise(resolve => {
    setTimeout(() => resolve(), 500);
  });

  await extractAll(tempZipFile, instancePath, {
    yes: true,
    $cherryPick: 'manifest.json'
  });
  const manifest = await fse.readJson(instanceManifest);
  return manifest;
};

export const downloadAddonZip = async (id, fileID, instancePath, tempPath) => {
  const data = await getAddonFile(id, fileID);
  const instanceManifest = path.join(instancePath, 'manifest.json');
  const zipFile = path.join(tempPath, 'addon.zip');
  if (data.downloadUrl) {
    await downloadFile(zipFile, data.downloadUrl);
  } else {
    const addon = await getAddon(id);

    const addonZipUrl = `https://www.curseforge.com/minecraft/modpacks/${addon.slug}/download/${fileID}`;
    await browserDownload(addonZipUrl, zipFile);
  }
  // Wait 500ms to avoid `The process cannot access the file because it is being used by another process.`
  await new Promise(resolve => {
    setTimeout(() => resolve(), 500);
  });

  await extractAll(zipFile, instancePath, {
    yes: true,
    $cherryPick: 'manifest.json'
  });
  const manifest = await fse.readJson(instanceManifest);
  return manifest;
};

export const getPlayerSkin = async uuid => {
  const playerSkin = await mcGetPlayerSkin(uuid);
  const { data } = playerSkin;
  const base64 = data.properties[0].value;
  const decoded = JSON.parse(Buffer.from(base64, 'base64').toString());
  return decoded?.textures?.SKIN?.url;
};

export const extractFace = async buffer => {
  const face = await jimp.read(buffer);
  const hat = await jimp.read(buffer);
  face.crop(8, 8, 8, 8);
  hat.crop(40, 8, 8, 8);
  face.scale(10, jimp.RESIZE_NEAREST_NEIGHBOR);
  hat.scale(10, jimp.RESIZE_NEAREST_NEIGHBOR);
  face.composite(hat, 0, 0);
  const ImageBuffer = await face.getBufferAsync(jimp.MIME_PNG);
  return ImageBuffer.toString('base64');
};

export const normalizeModData = (data, projectID, modName) => {
  const temp = data;
  temp.name = modName;
  if (data.fileFingerprint) {
    temp.packageFingerprint = data.fileFingerprint;
  }
  if (data.projectID && data.fileID) return temp;
  if (data.id) {
    temp.projectID = projectID;
    temp.fileID = data?.file?.id || data.id;
  }
  return temp;
};

export const reflect = p =>
  p.then(
    v => ({ v, status: true }),
    e => ({ e, status: false })
  );

export const convertCompletePathToInstance = (f, instancesPath) => {
  const escapeRegExp = stringToGoIntoTheRegex => {
    return stringToGoIntoTheRegex.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
  };

  return f.replace(new RegExp(escapeRegExp(instancesPath), 'gi'), '');
};

export const isMod = (fileName, instancesPath) =>
  /^(\\|\/)([\w\d\-.{}()[\]@#$%^&!\s])+((\\|\/)mods((\\|\/)(([^\\/])*))(\.jar|\.disabled))$/.test(
    convertCompletePathToInstance(fileName, instancesPath)
  );

export const isInstanceFolderPath = (f, instancesPath) =>
  /^(\\|\/)([\w\d-.{}()[\]@#$%^&!\s])+$/.test(
    convertCompletePathToInstance(f, instancesPath)
  );

export const isFileModFabric = file => {
  return (
    (file.gameVersions.includes('Fabric') ||
      file.modules.find(v => v.foldername === 'fabric.mod.json')) &&
    !file.gameVersions.includes('Forge')
  );
};

export const filterFabricFilesByVersion = (files, version) => {
  return files.filter(v => {
    if (Array.isArray(v.gameVersions)) {
      return v.gameVersions.includes(version) && isFileModFabric(v);
    }
    return v.gameVersions === version;
  });
};

export const filterForgeFilesByVersion = (files, version) => {
  return files.filter(v => {
    if (Array.isArray(v.gameVersions)) {
      return v.gameVersions.includes(version) && !isFileModFabric(v);
    }
    return v.gameVersions === version;
  });
};

export const getFirstPreferredCandidate = (files, release) => {
  let counter = release || 1;

  let latestFile = null;
  while (counter <= 3 && !latestFile) {
    const c = counter;
    const latest = files.find(v => v.releaseType <= c);
    if (latest) {
      latestFile = latest;
    }
    counter += 1;
  }
  return latestFile;
};

export const getFileHash = async (filePath, algorithm = 'sha1') => {
  // Calculate sha1 on original file
  const shasum = crypto.createHash(algorithm);

  const s = originalFs.ReadStream(filePath);
  s.on('data', data => {
    shasum.update(data);
  });

  const hash = await new Promise(resolve => {
    s.on('end', () => {
      resolve(shasum.digest('hex'));
    });
  });
  return hash;
};

export const getFilesRecursive = async dir => {
  const subdirs = await originalFs.promises.readdir(dir);
  const files = await Promise.all(
    subdirs.map(async subdir => {
      const res = path.resolve(dir, subdir);
      return (await originalFs.promises.stat(res)).isDirectory()
        ? getFilesRecursive(res)
        : res;
    })
  );
  return files.reduce((a, f) => a.concat(f), []);
};

export const extractFabricVersionFromManifest = manifest => {
  // Backwards compatability for manifest entries that use the `yarn`
  // property to set the fabric loader version. Newer manifests use the
  // format `fabric-<version>` in the id.
  let loaderVersion = manifest?.minecraft?.modLoaders[0]?.yarn;
  if (!loaderVersion) {
    loaderVersion = manifest?.minecraft?.modLoaders[0]?.id?.split('-', 2)[1];
  }
  return loaderVersion;
};

export const convertcurseForgeToCanonical = (
  curseForge,
  mcVersion,
  forgeManifest
) => {
  const patchedCurseForge = curseForge.replace('forge-', '');
  const forgeEquivalent = forgeManifest[mcVersion].find(v => {
    return v.split('-')[1] === patchedCurseForge;
  });
  return forgeEquivalent;
};

export const getPatchedInstanceType = instance => {
  const isForge = instance.loader?.loaderType === FORGE;
  const hasJumpLoader = (instance.mods || []).find(v => v.projectID === 361988);
  if (isForge && !hasJumpLoader) {
    return FORGE;
  }
  return FABRIC;
};