import { promisify } from 'util';
import fs from 'fs';
import path from 'path';

import marked from 'marked';
import rules from '../src/rules';

// Promise api of fs is available for node 10+, for node 8 we have to use util
const existsAsync = promisify(fs.exists);
const readFileAsync = promisify(fs.readFile);
const readdirAsync = promisify(fs.readdir);

const docsRoot = path.resolve(__dirname, '../docs/rules');
const rulesData = Object.entries(rules);

function createRuleLink(ruleName: string): string {
  return `[\`@typescript-eslint/${ruleName}\`](./docs/rules/${ruleName}.md)`;
}

function parseReadme(): marked.Tokens.Table {
  const readmeRaw = fs.readFileSync(
    path.resolve(__dirname, '../README.md'),
    'utf8',
  );
  const readme = marked.lexer(readmeRaw, {
    gfm: true,
    silent: false,
  });

  // find the table
  const rulesTable = readme.find(
    token => token.type === 'table',
  ) as marked.Tokens.Table;
  if (!rulesTable) {
    throw Error('Could not find the rules table in README.md');
  }

  return rulesTable;
}

describe('Validating rule docs', () => {
  it(`check if all files are present`, async () => {
    const files = await readdirAsync(docsRoot);
    const ruleFiles = Object.keys(rules)
      .map(rule => `${rule}.md`)
      .sort();

    expect(files.sort()).toEqual(ruleFiles);
  });

  it.each(rulesData)(
    'Description of %s.md must match',
    async (ruleName, rule) => {
      const filePath = path.join(docsRoot, `${ruleName}.md`);
      expect(await existsAsync(filePath)).toBeTruthy();
      // validate if description of rule is same as in docs
      const file = await readFileAsync(filePath, 'utf-8');
      expect((/^\s*#[^\r\n]*/.exec(file) ?? [])[0]).toEqual(
        `# ${rule.meta.docs.description} (\`${ruleName}\`)`,
      );
    },
  );
});

describe('Validating rule metadata', () => {
  describe.each(rulesData)('%s', (ruleName, rule) => {
    it(`name field in rule must be correct`, () => {
      // validate if rule name is same as url
      // there is no way to access this field but its used only in generation of docs url
      expect(rule.meta.docs.url.endsWith(`rules/${ruleName}.md`)).toBeTruthy();
    });

    it('Expects type checking to be set for rule', async () => {
      // quick-and-dirty check to see if it uses parserServices
      // not perfect but should be good enough
      const ruleFileContents = await readFileAsync(
        path.resolve(__dirname, `../src/rules/${ruleName}.ts`),
      );

      const usesTypeInformation =
        ruleFileContents.includes('getParserServices') || undefined;
      expect(usesTypeInformation).toEqual(rule.meta.docs.requiresTypeChecking);
    });
  });
});

describe('Validating README.md', () => {
  const rulesTable = parseReadme().cells;
  const notDeprecated = rulesData.filter(
    ([, rule]) => rule.meta.deprecated !== true,
  );

  it('Checking table structure...', () => {
    const ruleNames = notDeprecated
      .map(([ruleName]) => ruleName)
      .sort()
      .map(createRuleLink);

    expect(rulesTable.map(row => row[0])).toStrictEqual(ruleNames);
  });

  describe.each(notDeprecated)(`Checking rule %s`, (ruleName, rule) => {
    const ruleRow =
      rulesTable.find(row => row[0].includes(`/${ruleName}.md`)) ?? [];

    it(`Link column should be set correctly`, () => {
      expect(ruleRow[0]).toEqual(createRuleLink(ruleName));
    });

    it(`Description column should be set correctly`, () => {
      expect(ruleRow[1]).toEqual(rule.meta.docs.description);
    });

    it(`Recommended column should be set correctly`, () => {
      expect(ruleRow[2]).toEqual(
        rule.meta.docs.recommended ? ':heavy_check_mark:' : '',
      );
    });

    it(`Fixable column should be set correctly`, () => {
      expect(ruleRow[3]).toEqual(
        rule.meta.fixable !== undefined ? ':wrench:' : '',
      );
    });

    it(`Requiring type information column should be set correctly`, () => {
      expect(ruleRow[4]).toEqual(
        rule.meta.docs.requiresTypeChecking === true ? ':thought_balloon:' : '',
      );
    });
  });
});