// tslint:disable-next-line:no-default-export
export default async () => {
  // Warn about creating new JS files
  const jsFiles = danger.git.created_files.filter(
    f => f.includes("src") && f.endsWith(".js")
  )
  if (jsFiles.length) {
    const files = danger.github.utils.fileLinks(jsFiles)
    warn(
      `Please don't include .js files, we want to be using TypeScript found: ${files}.`
    )
  }

  const isReleasePR = danger.github.pr.base.ref === "release"
  const versionToCheck = isReleasePR ? "production" : "staging"
  const changes: string[] = await getBreakingChanges(versionToCheck)

  // There are breaking changes with the schema
  if (changes.length) {
    if (isReleasePR) {
      const deployURL = "https://github.com/artsy/metaphysics#deployment"
      fail(
        `You need to promote Metaphysics from staging to production. The schema used in Reaction, is further ahead than the version in Metaphyisc production. This could cause your queries to fail. You can see how to [deploy here](${deployURL}).`
      )
    } else {
      warn(
        "The staging version of Metaphysics has breaking changes, this might not affect your build, but could mean your queries don't work the way you expect. See below for breaking changes:"
      )
    }

    // Show a list of the changes
    markdown(changes.map(change => `- :warning: ${change}`).join("\n"))
  }
}

 result.messages.forEach(msg => {
   const { line, message, ruleId } = msg
   const rule = ruleId || 'N/A'
   const messageText = `${filePath} line ${line} – ${message} (${rule})`
   if (msg.severity === 1) {
     warn(messageText)
   } else if (msg.severity === 2) {
     fail(messageText)
   }
 })

export default async () => {
  if (!danger.github) {
    return;
  }

  schedule(async () => {
    const tsLintResult = (await Promise.all(
      packages.map(packageName => {
        return new Promise<string>(res => {
          tslint({
            lintResultsJsonPath: resolve(__dirname, 'packages', packageName, 'lint-results.json'),
            handleResults: results => {
              if (results.length > 0) {
                const formattedResults = prettyResults(results);
                res(`TSLint failed: **@sentry/${packageName}**\n\n${formattedResults}`);
              } else {
                res('');
              }
            },
          });
        });
      }),
    )).filter(str => str.length);
    if (tsLintResult.length) {
      tsLintResult.forEach(tsLintFail => {
        fail(`${tsLintFail}`);
      });
    } else {
      message('✅ TSLint passed');
    }
  });

  const hasChangelog = danger.git.modified_files.indexOf('CHANGELOG.md') !== -1;
  const isTrivial = (danger.github.pr.body + danger.github.pr.title).includes('#trivial');

  if (!hasChangelog && !isTrivial) {
    warn('Please add a changelog entry for your changes.');
  }

  schedule(async () => {
    const result = (await promisify(exec)('cd packages/browser; yarn size:check')).stdout;
    message(`@sentry/browser bundle gzip'ed minified size: *(${result.split('\n')[3]}) (${result.split('\n')[4]})*`);
  });
};

const modifiedAppFiles = modified.filter(p => includes(p, "lib/")).filter(p => filesOnly(p) && typescriptOnly(p))

// Modified or Created can be treated the same a lot of the time
const touchedFiles = modified.concat(danger.git.created_files).filter(p => filesOnly(p))

const touchedAppOnlyFiles = touchedFiles.filter(
  p => includes(p, "src/lib/") && !includes(p, "__tests__") && typescriptOnly(p)
)

const touchedComponents = touchedFiles.filter(p => includes(p, "src/lib/components") && !includes(p, "__tests__"))

// Rules

// If it's not a branch PR
if (pr.base.repo.full_name !== pr.head.repo.full_name) {
  warn("This PR comes from a fork, and won't get JS generated for QA testing this PR inside the Emission Example app.")
}

// When there are app-changes and it's not a PR marked as trivial, expect
// there to be CHANGELOG changes.
const changelogChanges = includes(modified, "CHANGELOG.md")
if (modifiedAppFiles.length > 0 && !trivialPR && !changelogChanges) {
  fail("No CHANGELOG added.")
}

// Check that the changelog contains only H3's
if (changelogChanges && fs.readFileSync("CHANGELOG.md", "utf8").includes("\n## ")) {
  fail("Changelog must only contain H3's, but contains H2's.")
}

// Check that every file touched has a corresponding test file

import { danger, warn, fail, message } from 'danger'
import { CLIEngine } from 'eslint'
import { readFileSync } from 'fs'
import { insert } from 'markdown-toc'
import { getFileInfo, resolveConfig, check, format } from 'prettier'
import minimatch = require('minimatch')

/* eslint no-undef: off */
/* REASON: not compatible with import = require() syntax. */

// No PR is too small to include a description of why you made a change
if (danger.github) {
  if (danger.github.pr.body.length < 10) {
    warn('Please include a description of your PR changes.')
  }
}

const filesToCheck = danger.git.created_files.concat(danger.git.modified_files)

// ESLint
const cli = new CLIEngine({})
const eslintPattern = '*.{js,jsx,ts,tsx}'
const filesToLint = filesToCheck
  .filter(path => minimatch(path, eslintPattern, { matchBase: true }))
  .filter(path => !cli.isPathIgnored(path))
const report = cli.executeOnFiles(filesToLint)
report.results.forEach(result => {
  const { filePath } = result
  result.messages.forEach(msg => {
    const { line, message, ruleId } = msg
    const rule = ruleId || 'N/A'

  }

  const hasAppChanges = modifiedAppFiles.length > 0;

  const testChanges = modifiedAppFiles.filter(filepath =>
    filepath.includes('test'),
  );
  const hasTestChanges = testChanges.length > 0;

  // Warn when there is a big PR
  const bigPRThreshold = 500;
  if (
    danger.github.pr.additions + danger.github.pr.deletions >
    bigPRThreshold
  ) {
    warn(':exclamation: Big PR');
  }

  // Warn if there are library changes, but not tests
  if (hasAppChanges && !hasTestChanges) {
    warn(
      "There are library changes, but not tests. That's OK as long as you're refactoring existing code",
    );
  }

  // Be careful of leaving testing shortcuts in the codebase
  const onlyTestFiles = testChanges.filter(x => {
    const content = fs.readFileSync(x).toString();
    return (
      content.includes('it.only') ||
      content.includes('describe.only') ||