#!/usr/bin/env node

'use strict';

const chalk = require('chalk');
const commander = require('commander');
const fs = require('fs-extra');
const path = require('path');
const spawn = require('cross-spawn');
const validateProjectName = require('validate-npm-package-name');

const packageJson = require('../package.json');

// These files should be allowed to remain on a failed install,
// but then silently removed during the next create.
const errorLogFilePatterns = ['npm-debug.log', 'yarn-error.log', 'yarn-debug.log', 'lerna-debug.log'];

const program = new commander.Command(packageJson.name)
  .version(packageJson.version)
  .option('-r, --repo-directory <repo-directory>', 'create mono-repo from template')
  .option('-s, --skip-configs', 'do not create configs from template')
  .option('-x, --skip-examples', 'do not create example shared components from template')
  .usage(`--repo-directory <repo-directory>`)
  .usage(`--skip-configs`)
  .parse(process.argv)
  .on('--help', () => {
    console.log(`    Only ${chalk.green('<repo-directory>')} is required.`);
    console.log();
  });

if (typeof program.repoDirectory === 'undefined') {
  console.error('Please specify the repo directory:');
  console.log(`  ${chalk.cyan(`${program.name()} --repo-directory`)} ${chalk.green('<repo-directory>')}`);
  console.log();
  console.log('For example:');
  console.log(`  ${chalk.cyan(`${program.name()} --repo-directory`)} ${chalk.green('my-monorepo')}`);
  console.log();
  console.log(`Run ${chalk.cyan(`${program.name()} --help`)} to see all options.`);
  process.exit(1);
}

// call main function
createRepo(program.repoDirectory);

// main function
function createRepo(repoDir) {
  // fullRepoDirPath = resolve the full path to the repo directory specified.
  // The user may have specified a relative or absolute path.
  // repoDirName = the last directory in the path = name of repo to create.
  const fullRepoDirPath = path.resolve(repoDir);
  const repoDirName = path.basename(fullRepoDirPath);

  // check repo name against npm naming restrictions and dependency names
  checkRepoName(repoDirName);

  // equivalent to mkdir -p; creates the directory and any required paths to it
  if (!fs.ensureDirSync(fullRepoDirPath)) {
    process.exit(1);
  }

  // ensure created directory is either empty or only contains allowed files or error logs
  if (!isSafeToCreateProjectIn(fullRepoDirPath, repoDir)) {
    process.exit(1);
  }

  console.log(`Creating mono-repo in ${chalk.green(fullRepoDirPath)}.`);
  console.log();

  // save location cli was run from
  const originalDirectory = process.cwd();

  // move into newly created repo direcotry
  process.chdir(fullRepoDirPath);

  // self-explanatory?
  if (!checkThatNpmCanReadCwd()) {
    process.exit(1);
  }

  // call run command to create monorepo
  run(fullRepoDirPath, repoDirName, originalDirectory);
}

function printValidationResults(results) {
  if (typeof results !== 'undefined') {
    results.forEach(error => {
      console.error(chalk.red(`  *  ${error}`));
    });
  }
}

// arg: repoName = repository name / directory name to create
function checkRepoName(repoName) {
  const validationResult = validateProjectName(repoName);
  if (!validationResult.validForNewPackages) {
    console.error(
      `Could not create a repo called ${chalk.red(`"${repoName}"`)} because of npm naming restrictions:`,
    );
    printValidationResults(validationResult.errors);
    printValidationResults(validationResult.warnings);
    process.exit(1);
  }

  const dependencies = Object.keys(packageJson.dependencies).sort();
  if (dependencies.indexOf(repoName) >= 0) {
    console.error(
      chalk.red(
        `We cannot create a project called ${chalk.green(
          repoName,
        )} because a dependency with the same name exists.\n` +
          `Due to the way npm works, the following names are not allowed:\n\n`,
      ) +
        chalk.cyan(dependencies.map(depName => `  ${depName}`).join('\n')) +
        chalk.red('\n\nPlease choose a different project name.'),
    );
    process.exit(1);
  }
}

function isSafeToCreateProjectIn(repoDirPath, repoDirName) {
  const validFiles = [
    '.DS_Store',
    'Thumbs.db',
    '.git',
    '.gitignore',
    'README.md',
    'LICENSE',
    '.hg',
    '.hgignore',
    '.hgcheck',
    '.npmignore',
    'mkdocs.yml',
    'docs',
    '.travis.yml',
    '.gitlab-ci.yml',
    '.gitattributes',
  ];
  console.log();

  const conflicts = fs
    .readdirSync(repoDirPath)
    .filter(file => !validFiles.includes(file))
    // Don't treat log files from previous installation as conflicts
    .filter(file => !errorLogFilePatterns.some(pattern => file.indexOf(pattern) === 0));

  if (conflicts.length > 0) {
    console.log(`The directory ${chalk.green(repoDirName)} contains files that could conflict:`);
    console.log();
    for (const file of conflicts) {
      console.log(`  ${file}`);
    }
    console.log();
    console.log('Either try using a new directory name, or remove the files listed above.');

    return false;
  }

  // Remove any remnant files from a previous installation
  const currentFiles = fs.readdirSync(path.join(repoDirPath));
  currentFiles.forEach(file => {
    errorLogFilePatterns.forEach(errorLogFilePattern => {
      // This will catch `(npm-debug|yarn-error|yarn-debug|lerna-debug).log*` files
      if (file.indexOf(errorLogFilePattern) === 0) {
        fs.removeSync(path.join(repoDirPath, file));
      }
    });
  });
  return true;
}

function checkThatNpmCanReadCwd() {
  const cwd = process.cwd();
  let childOutput = null;
  try {
    childOutput = spawn.sync('npm', ['config', 'list']).output.join('');
  } catch (err) {
    return true;
  }
  if (typeof childOutput !== 'string') {
    return true;
  }
  const lines = childOutput.split('\n');
  // `npm config list` output includes the following line:
  // "; cwd = C:\path\to\current\dir" (unquoted)
  // I couldn't find an easier way to get it.
  const prefix = '; cwd = ';
  const line = lines.find(line => line.indexOf(prefix) === 0);
  if (typeof line !== 'string') {
    // Fail gracefully. They could remove it.
    return true;
  }
  const npmCWD = line.substring(prefix.length);
  if (npmCWD === cwd) {
    return true;
  }
  console.error(
    chalk.red(
      `Could not start an npm process in the right directory.\n\n` +
        `The current directory is: ${chalk.bold(cwd)}\n` +
        `However, a newly started npm process runs in: ${chalk.bold(npmCWD)}\n\n` +
        `This is probably caused by a misconfigured system terminal shell.`,
    ),
  );
  if (process.platform === 'win32') {
    console.error(
      chalk.red(`On Windows, this can usually be fixed by running:\n\n`) +
        `  ${chalk.cyan('reg')} delete "HKCU\\Software\\Microsoft\\Command Processor" /v AutoRun /f\n` +
        `  ${chalk.cyan('reg')} delete "HKLM\\Software\\Microsoft\\Command Processor" /v AutoRun /f\n\n` +
        chalk.red(`Try to run the above two lines in the terminal.\n`) +
        chalk.red(
          // eslint-disable-next-line max-len
          `To learn more about this problem, read: https://blogs.msdn.microsoft.com/oldnewthing/20071121-00/?p=24433/`,
        ),
    );
  }
  return false;
}

/* 
  params:
    repoDirPath: full path to repo dir
    repoDirName: name of repo / repo dir
    originalDirectory: dir from which cli called from
  run: create the mono-repo from template
*/
function run(repoDirPath, repoDirName, originalDirectory) {
  console.log(`repoDirPath: ${JSON.stringify(repoDirPath)}`);
  console.log(`repoDirName: ${JSON.stringify(repoDirName)}`);
  console.log(`originalDirectory: ${JSON.stringify(originalDirectory)}`);
  console.log(`argv: ${JSON.stringify(process.argv)}`);

  // we use the monorepo-template package, which contains the cli, as our template
  const templateDir = path.resolve(path.join(process.argv[1], '../..'));
  console.log(`path: ${JSON.stringify(path.resolve(path.join(process.argv[1], '../..')))}`);

  // copy the template to the target directory, don't copy bin folder or node_modules
  if (fs.existsSync(templateDir)) {
    fs.copySync(templateDir, repoDirPath, {
      dereference: true,
      filter: (src, dest) =>
        !dest.match(/node_modules/) &&
        !dest.match(/bin/) &&
        !dest.match(/LICENSE/) &&
        !dest.match(/CHANGELOG.md/) &&
        !(program.skipConfigs && dest.match(/packages\/configs/)) &&
        !(program.skipExamples && dest.match(/packages\/shared-components\/input/)) &&
        !(program.skipExamples && dest.match(/packages\/shared-components\/input-ts/)),
    });
  } else {
    console.error(`Could not locate supplied template: ${chalk.green(templateDir)}`);
    process.exit(1);
  }

  // create the new project's package.json
  const newJsonPath = path.resolve(repoDirPath, 'package.json');
  const { bin, dependencies, description, version, ...rest } = packageJson;
  const newJson = {
    ...rest,
    devDependencies: {
      ...Object.keys(packageJson.devDependencies)
        .map(key => (skipConfigs ? key : key.replace('@jsdevtools', `@${repoDirName}`)))
        .reduce((acc, curr, i, arr) => {
          return packageJson.devDependencies[curr]
            ? { ...acc, [curr]: packageJson.devDependencies[curr] }
            : { ...acc, [curr]: '^0.0.1' };
        }, {}),
    },
    eslintConfig: {
      ...Object.keys(packageJson.eslintConfig).reduce(
        (acc, curr, i, arr) =>
          skipConfigs
            ? {
                ...acc,
                [curr]: packageJson.eslintConfig[curr],
              }
            : {
                ...acc,
                [curr]: packageJson.eslintConfig[curr].replace('@jsdevtools', `@${repoDirName}`),
              },
        {},
      ),
    },
    name: `@${repoDirName}/${repoDirName}`,
    prettier: skipConfigs
      ? packageJson.prettier
      : packageJson.prettier.replace('@jsdevtools', `@${repoDirName}`),
    private: true,
    scripts: {
      ...packageJson.scripts,
      'clean-packages': packageJson.scripts['clean-packages'].replace('@jsdevtools', `@${repoDirName}`),
      commit: `git-cz`,
    },
    workspaces: [...packageJson.workspaces.filter(workspace => workspace !== './')],
  };
  fs.writeFileSync(newJsonPath, JSON.stringify(newJson, null, 2));

  const lernaJson = require(path.resolve(templateDir, 'lerna.json'));
  const newLernaPath = path.resolve(repoDirPath, 'lerna.json');
  const newLerna = {
    ...lernaJson,
    packages: [...lernaJson.packages.filter(pkg => pkg !== './')],
  };
  fs.writeFileSync(newLernaPath, JSON.stringify(newLerna, null, 2));
}