export function dynamicPathParser(project: any, entityName: string, appConfig: any) {
  const projectRoot = project.root;
  const sourceDir = appConfig.root;
  const appRoot = path.join(sourceDir, 'app');
  const cwd = process.env.PWD;

  const rootPath = path.join(projectRoot, appRoot);
  let outputPath = path.join(rootPath, entityName);

  if (entityName.indexOf(path.sep) === 0) {
    outputPath = path.join(rootPath, entityName.substr(1));
  } else if (cwd.indexOf(rootPath) >= 0) {
    outputPath = path.join(cwd, entityName);
  }

  if (!fs.existsSync(outputPath)) {
    // Verify the path exists on disk.
    const parsedOutputPath = path.parse(outputPath);
    const parts = parsedOutputPath.dir.split(path.sep).slice(1);
    const newPath = parts.reduce((tempPath: string, part: string) => {
      // if (tempPath === '') {
      //   return part;
      // }

      const withoutPlus = path.join(tempPath, part);
      const withPlus = path.join(tempPath, '+' + part);
      if (fs.existsSync(withoutPlus)) {
        return withoutPlus;
      } else if (fs.existsSync(withPlus)) {
        return withPlus;
      }

      // Folder not found, create it, and return it
      const dasherizedPart = stringUtils.dasherize(part);
      const dasherizedDirName = path.join(tempPath, dasherizedPart);
      fs.mkdirpSync(dasherizedDirName);
      return dasherizedDirName;

    }, parsedOutputPath.root);
    outputPath = path.join(newPath, parsedOutputPath.name);
  }

  if (outputPath.indexOf(rootPath) < 0) {
    throw `Invalid path: "${entityName}" cannot be ` +
        `above the "${appRoot}" directory`;
  }

  const adjustedPath = outputPath.replace(projectRoot, '');

  const parsedPath = path.parse(adjustedPath);

  if (parsedPath.dir.indexOf(path.sep) === 0) {
    parsedPath.dir = parsedPath.dir.substr(1);
  }

  parsedPath.dir = parsedPath.dir === path.sep ? '' : parsedPath.dir;

  return { ...parsedPath, appRoot, sourceDir };
};

			this.watcher.on('change', (file: string) => {
				switch (path.parse(file).ext) {
					case '.glsl':
						log.info('Recompiling ' + path.parse(file).name);
						this.compileShader(file, options);
						break;
				}
			});

export default function nodeModulesPaths(
  basedir: Config.Path,
  options: NodeModulesPathsOptions,
): Array<Config.Path> {
  const modules =
    options && options.moduleDirectory
      ? Array.from(options.moduleDirectory)
      : ['node_modules'];

  // ensure that `basedir` is an absolute path at this point,
  // resolving against the process' current working directory
  const basedirAbs = path.resolve(basedir);

  let prefix = '/';
  if (/^([A-Za-z]:)/.test(basedirAbs)) {
    prefix = '';
  } else if (/^\\\\/.test(basedirAbs)) {
    prefix = '\\\\';
  }

  // The node resolution algorithm (as implemented by NodeJS and TypeScript)
  // traverses parents of the physical path, not the symlinked path
  let physicalBasedir;
  try {
    physicalBasedir = realpath(basedirAbs);
  } catch (err) {
    // realpath can throw, e.g. on mapped drives
    physicalBasedir = basedirAbs;
  }

  const paths: Array<Config.Path> = [physicalBasedir];
  let parsed = path.parse(physicalBasedir);
  while (parsed.dir !== paths[paths.length - 1]) {
    paths.push(parsed.dir);
    parsed = path.parse(parsed.dir);
  }

  const dirs = paths
    .reduce(
      (dirs, aPath) =>
        dirs.concat(
          modules.map(moduleDir =>
            path.isAbsolute(moduleDir)
              ? aPath === basedirAbs
                ? moduleDir
                : ''
              : path.join(prefix, aPath, moduleDir),
          ),
        ),
      [] as Array<Config.Path>,
    )
    .filter(dir => dir !== '');

  return options.paths ? dirs.concat(options.paths) : dirs;
}

export async function comparePngs(
  sessionPath: string,
  baselinePath: string,
  diffPath: string,
  sessionDirectory: string,
  log: ToolingLog
) {
  log.debug(`comparePngs: ${sessionPath} vs ${baselinePath}`);
  const session = (await Jimp.read(sessionPath)).clone();
  const baseline = (await Jimp.read(baselinePath)).clone();

  if (
    session.bitmap.width !== baseline.bitmap.width ||
    session.bitmap.height !== baseline.bitmap.height
  ) {
    // eslint-disable-next-line no-console
    console.log(
      'expected height ' + baseline.bitmap.height + ' and width ' + baseline.bitmap.width
    );
    // eslint-disable-next-line no-console
    console.log('actual height ' + session.bitmap.height + ' and width ' + session.bitmap.width);

    const width = Math.min(session.bitmap.width, baseline.bitmap.width);
    const height = Math.min(session.bitmap.height, baseline.bitmap.height);
    session.resize(width, height); // , Jimp.HORIZONTAL_ALIGN_LEFT | Jimp.VERTICAL_ALIGN_TOP);
    baseline.resize(width, height); // , Jimp.HORIZONTAL_ALIGN_LEFT | Jimp.VERTICAL_ALIGN_TOP);
  }

  session.quality(60);
  baseline.quality(60);

  log.debug(`calculating diff pixels...`);
  // Note that this threshold value only affects color comparison from pixel to pixel. It won't have
  // any affect when comparing neighboring pixels - so slight shifts, font variations, or "blurry-ness"
  // will still show up as diffs, but upping this will not help that.  Instead we keep the threshold low, and expect
  // some the diffCount to be lower than our own threshold value.
  const THRESHOLD = 0.1;
  const { image, percent } = Jimp.diff(session, baseline, THRESHOLD);
  log.debug(`percent different: ${percent}`);
  if (percent > 0) {
    image.write(diffPath);

    // For debugging purposes it'll help to see the resized images and how they compare.
    session.write(join(sessionDirectory, `${parse(sessionPath).name}-session-resized.png`));
    baseline.write(join(sessionDirectory, `${parse(baselinePath).name}-baseline-resized.png`));
  }
  return percent;
}

				async function compile(shader: any, index: number) {
					let parsed = path.parse(shader);
					log.info('Compiling shader ' + (index + 1) + ' of ' + shaders.length + ' (' + parsed.base + ').');
					let compiledShader: CompiledShader = null;
					try {
						compiledShader = await self.compileShader(shader, options, recompileAll);
					}
					catch (error) {
						log.error('Compiling shader ' + (index + 1) + ' of ' + shaders.length + ' (' + parsed.base + ') failed:');
						log.error(error);
						return Promise.reject(error);
					}
					if (compiledShader === null) {
						compiledShader = new CompiledShader();
						compiledShader.noembed = options.noembed;
						// mark variables as invalid, so they are loaded from previous compilation
						compiledShader.files = null;
						compiledShader.inputs = null;
						compiledShader.outputs = null;
						compiledShader.uniforms = null;
						compiledShader.types = null;
					}
					if (compiledShader.files != null && compiledShader.files.length === 0) {
						// TODO: Remove when krafix has been recompiled everywhere
						compiledShader.files.push(parsed.name + '.' + self.type);
					}
					compiledShader.name = AssetConverter.createExportInfo(parsed, false, options, self.exporter.options.from).name;
					compiledShaders.push(compiledShader);
					++index;
					return Promise.resolve();
				}

			this.watcher.on('ready', async () => {
				ready = true;
				let compiledShaders: CompiledShader[] = [];
				let index = 0;
				for (let shader of shaders) {
					let parsed = path.parse(shader);
					log.info('Compiling shader ' + (index + 1) + ' of ' + shaders.length + ' (' + parsed.base + ').');
					let compiledShader: CompiledShader = null;
					try {
						compiledShader = await this.compileShader(shader, options);
					}
					catch (error) {
						reject(error);
						return;
					}
					if (compiledShader === null) {
						compiledShader = new CompiledShader();
						// mark variables as invalid, so they are loaded from previous compilation
						compiledShader.inputs = null;
						compiledShader.outputs = null;
						compiledShader.uniforms = null;
					}
					if (compiledShader.files.length === 0) {
						// TODO: Remove when krafix has been recompiled everywhere
						compiledShader.files.push(parsed.name + '.' + this.type);
					}
					compiledShader.name = AssetConverter.createExportInfo(parsed, false, options, this.exporter.options.from).name;
					compiledShaders.push(compiledShader);
					++index;
				}
				resolve(compiledShaders);
				return;
			});

export function copyGoldImagesToDatabase(name: string, resourceState: string, fileBucket: any) {
  // The name should always look like "goldens/xxx.png"
  let parsedPath = path.parse(name);
  // Get the file name.
  if (parsedPath.root != '' ||
    parsedPath.dir != 'goldens' ||
    parsedPath.ext.toLowerCase() != '.png') {
    return;
  }

  let filenameKey = path.basename(parsedPath.name, '.screenshot');
  let databaseRef = firebaseAdmin.database().ref(FIREBASE_DATA_GOLDENS).child(filenameKey);

  // When a gold image is deleted, also delete the corresponding record in the firebase database.
  if (resourceState === 'not_exists') {
    return databaseRef.set(null);
  }

  let tempFilePath = `/tmp/${parsedPath.base}`;
  let bucket = gcs.bucket(fileBucket);
  // Download file from bucket.
  return bucket.file(name).download({destination: tempFilePath})
    .then(() => {
      let data = readFileSync(tempFilePath);
      return databaseRef.set(data);
    }).catch((error: any) => console.error(`${filenameKey} ${error}`));
}

    return function (path: string) {
        const nmIndex = path.lastIndexOf('node_modules');

        if (nmIndex !== -1) {
            const subPath = path.substr(nmIndex + 'node_modules'.length).replace(/\\/g, '/');
            const shouldResolve = explicitResolve.length && explicitResolve.some(packageName => subPath.indexOf(packageName) !== -1);
            const pathParts = subPath.split(/[/\-_]/);

            if (!shouldResolve && pathParts.every(p => nsPackageFilters.every(f => f !== p))) {
                return path;
            }
        }

        const { dir, name, ext } = parse(path);

        if (platformSpecificExt.indexOf(ext) === -1) {
            return path;
        }

        for (const platform of platforms) {
            const platformFileName = `${name}.${platform}${ext}`;
            const platformPath = toSystemPath(join(dir, platformFileName));

            try {
                if (statSync(platformPath)) {
                    return platformPath;
                }
            } catch (_e) {
                // continue checking the other platforms
            }
        }

        return path;
    }

export function trueCasePathSync(fsPath: string): string {
	// Normalize the path so as to resolve . and .. components.
	// !! As of Node v4.1.1, a path starting with ../ is NOT resolved relative
	// !! to the current dir, and glob.sync() below then fails.
	// !! When in doubt, resolve with fs.realPathSync() *beforehand*.
	let fsPathNormalized = path.normalize(fsPath);

	// OSX: HFS+ stores filenames in NFD (decomposed normal form) Unicode format,
	// so we must ensure that the input path is in that format first.
	if (process.platform === "darwin")
		fsPathNormalized = fsPathNormalized.normalize("NFD");

	// !! Windows: Curiously, the drive component mustn't be part of a glob,
	// !! otherwise glob.sync() will invariably match nothing.
	// !! Thus, we remove the drive component and instead pass it in as the 'cwd'
	// !! (working dir.) property below.
	const pathRoot = path.parse(fsPathNormalized).root;
	const noDrivePath = fsPathNormalized.slice(Math.max(pathRoot.length - 1, 0));

	// Perform case-insensitive globbing (on Windows, relative to the drive /
	// network share) and return the 1st match, if any.
	// Fortunately, glob() with nocase case-corrects the input even if it is
	// a *literal* path.
	return glob.sync(noDrivePath, { nocase: true, cwd: pathRoot })[0];
}