export function findR3SymbolsPath(directory: string, filename: string): string|null {
  const r3SymbolsFilePath = resolve(directory, filename);
  if (existsSync(r3SymbolsFilePath)) {
    return r3SymbolsFilePath;
  }

  const subDirectories =
      readdirSync(directory)
          // Not interested in hidden files
          .filter(p => !p.startsWith('.'))
          // Ignore node_modules
          .filter(p => p !== 'node_modules')
          // Only interested in directories (and only those that are not symlinks)
          .filter(p => {
            const stat = lstatSync(resolve(directory, p));
            return stat.isDirectory() && !stat.isSymbolicLink();
          });

  for (const subDirectory of subDirectories) {
    const r3SymbolsFilePath = findR3SymbolsPath(resolve(directory, subDirectory, ), filename);
    if (r3SymbolsFilePath) {
      return r3SymbolsFilePath;
    }
  }

  return null;
}

  /**
   * Merge the input and output source-maps, replacing the source-map comment in the output file
   * with an appropriate source-map comment pointing to the merged source-map.
   */
  protected renderSourceAndMap(
      sourceFile: ts.SourceFile, input: SourceMapInfo, output: MagicString): FileInfo[] {
    const outputPath = resolve(this.targetPath, relative(this.sourcePath, sourceFile.fileName));
    const outputMapPath = `${outputPath}.map`;
    const outputMap = output.generateMap({
      source: sourceFile.fileName,
      includeContent: true,
      // hires: true // TODO: This results in accurate but huge sourcemaps. Instead we should fix
      // the merge algorithm.
    });

    // we must set this after generation as magic string does "manipulation" on the path
    outputMap.file = outputPath;

    const mergedMap =
        mergeSourceMaps(input.map && input.map.toObject(), JSON.parse(outputMap.toString()));

    const result: FileInfo[] = [];
    if (input.isInline) {
      result.push({path: outputPath, contents: `${output.toString()}\n${mergedMap.toComment()}`});
    } else {
      result.push({
        path: outputPath,
        contents: `${output.toString()}\n${generateMapFileComment(outputMapPath)}`
      });
      result.push({path: outputMapPath, contents: mergedMap.toJSON()});
    }
    return result;
  }

  renderFile(
      sourceFile: ts.SourceFile, decorationAnalysis: DecorationAnalysis|undefined,
      switchMarkerAnalysis: SwitchMarkerAnalysis|undefined, targetPath: string): FileInfo[] {
    const renderedFiles =
        super.renderFile(sourceFile, decorationAnalysis, switchMarkerAnalysis, targetPath);

    // Transform the `.d.ts` files.
    // TODO(gkalpak): What about `.d.ts` source maps? (See
    // https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-9.html#new---declarationmap.)
    if (decorationAnalysis) {
      // Create a `DtsFileTransformer` for the source file and record the generated fields, which
      // will allow the corresponding `.d.ts` file to be transformed later.
      const dtsTransformer = new DtsFileTransformer(this.rewriteCoreImportsTo, IMPORT_PREFIX);
      decorationAnalysis.analyzedClasses.forEach(
          analyzedClass =>
              dtsTransformer.recordStaticField(analyzedClass.name, analyzedClass.compilation));

      // Find the corresponding `.d.ts` file.
      const sourceFileName = sourceFile.fileName;
      const originalDtsFileName = this.dtsMapper.getDtsFileNameFor(sourceFileName);
      const originalDtsContents = readFileSync(originalDtsFileName, 'utf8');

      // Transform the `.d.ts` file based on the recorded source file changes.
      const transformedDtsFileName =
          resolve(this.targetPath, relative(this.sourcePath, originalDtsFileName));
      const transformedDtsContents = dtsTransformer.transform(originalDtsContents, sourceFileName);

      // Add the transformed `.d.ts` file to the list of output files.
      renderedFiles.push({path: transformedDtsFileName, contents: transformedDtsContents});
    }

    return renderedFiles;
  }

  entryPoints.forEach(entryPoint => {
    // Are we compiling the Angular core?
    const isCore = entryPoint.name === '@angular/core';

    const compiledFormats = new Set<string>();
    const entryPointPackageJson = entryPoint.packageJson;
    const entryPointPackageJsonPath = AbsoluteFsPath.from(resolve(entryPoint.path, 'package.json'));

    const hasProcessedDts = hasBeenProcessed(entryPointPackageJson, 'typings');

    for (let i = 0; i < propertiesToConsider.length; i++) {
      const property = propertiesToConsider[i] as EntryPointJsonProperty;
      const formatPath = entryPointPackageJson[property];
      const format = getEntryPointFormat(property);

      // No format then this property is not supposed to be compiled.
      if (!formatPath || !format || SUPPORTED_FORMATS.indexOf(format) === -1) continue;

      if (hasBeenProcessed(entryPointPackageJson, property)) {
        compiledFormats.add(formatPath);
        logger.info(`Skipping ${entryPoint.name} : ${property} (already compiled).`);
        continue;
      }

      const isFirstFormat = compiledFormats.size === 0;
      const processDts = !hasProcessedDts && isFirstFormat;

      // We don't break if this if statement fails because we still want to mark
      // the property as processed even if its underlying format has been built already.
      if (!compiledFormats.has(formatPath) && (compileAllFormats || isFirstFormat)) {
        const bundle = makeEntryPointBundle(
            entryPoint.path, formatPath, entryPoint.typings, isCore, property, format, processDts);
        if (bundle) {
          logger.info(`Compiling ${entryPoint.name} : ${property} as ${format}`);
          const transformedFiles = transformer.transform(bundle);
          fileWriter.writeBundle(entryPoint, bundle, transformedFiles);
          compiledFormats.add(formatPath);
        } else {
          logger.warn(
              `Skipping ${entryPoint.name} : ${format} (no valid entry point file for this format).`);
        }
      } else if (!compileAllFormats) {
        logger.info(`Skipping ${entryPoint.name} : ${property} (already compiled).`);
      }

      // Either this format was just compiled or its underlying format was compiled because of a
      // previous property.
      if (compiledFormats.has(formatPath)) {
        markAsProcessed(entryPointPackageJson, entryPointPackageJsonPath, property);
        if (processDts) {
          markAsProcessed(entryPointPackageJson, entryPointPackageJsonPath, 'typings');
        }
      }
    }

    if (compiledFormats.size === 0) {
      throw new Error(
          `Failed to compile any formats for entry-point at (${entryPoint.path}). Tried ${propertiesToConsider}.`);
    }
  });

 it("should parse a TS file", () => {
   const parseInfo = parser.parse(['testSrc.ts'], path.resolve(__dirname, '../../mocks/tsParser'));
   const tsModules = parseInfo.moduleSymbols;
   expect(tsModules.length).toEqual(1);
   expect(tsModules[0].exportArray.length).toEqual(3);
   expect(tsModules[0].exportArray.map(i => i.name)).toEqual(['MyClass', 'myFn', 'x']);
 });

export function loadSitemapUrls() {
  const pathToSiteMap = path.resolve(__dirname, '../../src/generated/sitemap.xml');
  const xml = readFileSync(pathToSiteMap, 'utf8');
  const urls: string[] = [];
  xml.replace(/<loc>([^<]+)<\/loc>/g, (_, loc) => urls.push(loc.replace('%%DEPLOYMENT_HOST%%', '')));
  return urls;
}

export function getEntryPointInfo(pkgPath: string, entryPoint: string): EntryPoint|null {
  const packageJsonPath = path.resolve(entryPoint, 'package.json');
  if (!fs.existsSync(packageJsonPath)) {
    return null;
  }

  // If there is `esm2015` then `es2015` will be FESM2015, otherwise ESM2015.
  // If there is `esm5` then `module` will be FESM5, otherwise it will be ESM5.
  const {
    name,
    module: modulePath,
    types,
    typings = types,  // synonymous
    es2015,
    fesm2015 = es2015,   // synonymous
    fesm5 = modulePath,  // synonymous
    esm2015,
    esm5,
    main
  }: EntryPointPackageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));

  // Minimum requirement is that we have typings and one of esm2015 or fesm2015 formats.
  if (!typings || !(fesm2015 || esm2015)) {
    return null;
  }

  // Also we need to have a metadata.json file
  const metadataPath = path.resolve(entryPoint, typings.replace(/\.d\.ts$/, '') + '.metadata.json');
  if (!fs.existsSync(metadataPath)) {
    return null;
  }

  const entryPointInfo: EntryPoint = {
    name,
    package: pkgPath,
    path: entryPoint,
    typings: path.resolve(entryPoint, typings),
  };

  if (esm2015) {
    entryPointInfo.esm2015 = path.resolve(entryPoint, esm2015);
  }
  if (fesm2015) {
    entryPointInfo.fesm2015 = path.resolve(entryPoint, fesm2015);
  }
  if (fesm5) {
    entryPointInfo.fesm5 = path.resolve(entryPoint, fesm5);
  }
  if (esm5) {
    entryPointInfo.esm5 = path.resolve(entryPoint, esm5);
  }
  if (main) {
    entryPointInfo.umd = path.resolve(entryPoint, main);
  }

  return entryPointInfo;
}

 beforeEach(() => {
   parser = new TsParser(require('dgeni/lib/mocks/log')(false));
   basePath = path.resolve(__dirname, '../../mocks');
   const parseInfo = parser.parse(['tsParser/getDecorators.test.ts'], basePath);
   const moduleExports = parseInfo.moduleSymbols[0].exportArray;
   testClass = moduleExports[0];
   testMethodDeclaration = testClass.members!.get('method' as __String)!.getDeclarations()![0];
   testParameters = (testMethodDeclaration as any).parameters;
 });

  beforeEach(() => {
    dgeni = new Dgeni([mockPackage()]);
    injector = dgeni.configureInjector();

    tsProcessor = injector.get('readTypeScriptModules');
    parseTagsProcessor = injector.get('parseTagsProcessor');
    extractTagsProcessor = injector.get('extractTagsProcessor');
    mergeParameterInfoProcessor = injector.get('mergeParameterInfo');
    tsProcessor.basePath = path.resolve(__dirname, '../mocks/readTypeScriptModules');
    tsProcessor.sourceFiles = ['methodParameters.ts'];
  });

    program.getSourceFiles().map(sourceFile => {
      const decorationAnalysis = decorationAnalyses.get(sourceFile);
      const switchMarkerAnalysis = switchMarkerAnalyses.get(sourceFile);

      // Transform the source files and source maps.
      if (decorationAnalysis || switchMarkerAnalysis) {
        const targetPath = resolve(this.targetPath, relative(this.sourcePath, sourceFile.fileName));
        renderedFiles.push(
            ...this.renderFile(sourceFile, decorationAnalysis, switchMarkerAnalysis, targetPath));
      }
    });