/* eslint-disable import/order */

'use strict';

const fs = require('fs');
const path = require('path');

require('../../require-main');

const packageInstall = require('./package-install');
const { paths } = require('../constants');

try {
	fs.accessSync(paths.currentPackage, fs.constants.R_OK); // throw on missing package.json
	try { // handle missing node_modules/ directory
		fs.accessSync(paths.nodeModules, fs.constants.R_OK);
	} catch (e) {
		if (e.code === 'ENOENT') {
			// run package installation just to sync up node_modules/ with existing package.json
			packageInstall.installAll();
		} else {
			throw e;
		}
	}
	fs.accessSync(path.join(paths.nodeModules, 'semver/package.json'), fs.constants.R_OK);

	const semver = require('semver');
	const defaultPackage = require('../../install/package.json');

	const checkVersion = function (packageName) {
		const { version } = JSON.parse(fs.readFileSync(path.join(paths.nodeModules, packageName, 'package.json'), 'utf8'));
		if (!semver.satisfies(version, defaultPackage.dependencies[packageName])) {
			const e = new TypeError(`Incorrect dependency version: ${packageName}`);
			e.code = 'DEP_WRONG_VERSION';
			throw e;
		}
	};

	checkVersion('nconf');
	checkVersion('async');
	checkVersion('commander');
	checkVersion('chalk');
	checkVersion('lodash');
	checkVersion('lru-cache');
} catch (e) {
	if (['ENOENT', 'DEP_WRONG_VERSION', 'MODULE_NOT_FOUND'].includes(e.code)) {
		console.warn('Dependencies outdated or not yet installed.');
		console.log('Installing them now...\n');

		packageInstall.updatePackageFile();
		packageInstall.preserveExtraneousPlugins();
		packageInstall.installAll();

		// delete the module from require cache so it doesn't break rest of the upgrade
		// https://github.com/NodeBB/NodeBB/issues/11173
		const packages = ['nconf', 'async', 'commander', 'chalk', 'lodash', 'lru-cache'];
		packages.forEach((packageName) => {
			const resolvedModule = require.resolve(packageName);
			if (require.cache[resolvedModule]) {
				delete require.cache[resolvedModule];
			}
		});

		const chalk = require('chalk');
		console.log(`${chalk.green('OK')}\n`);
	} else {
		throw e;
	}
}

const chalk = require('chalk');
const nconf = require('nconf');
const { program } = require('commander');
const yargs = require('yargs');

const pkg = require('../../install/package.json');
const file = require('../file');
const prestart = require('../prestart');

program.configureHelp(require('./colors'));

program
	.name('./nodebb')
	.description('Welcome to NodeBB')
	.version(pkg.version)
	.option('--json-logging', 'Output to logs in JSON format', false)
	.option('--log-level <level>', 'Default logging level to use', 'info')
	.option('--config <value>', 'Specify a config file', 'config.json')
	.option('-d, --dev', 'Development mode, including verbose logging', false)
	.option('-l, --log', 'Log subprocess output to console', false)
	.option('-y, --unattended', 'Answer yes to any prompts, like plugin upgrades', false);

// provide a yargs object ourselves
// otherwise yargs will consume `--help` or `help`
// and `nconf` will exit with useless usage info
const opts = yargs(process.argv.slice(2)).help(false).exitProcess(false);
nconf.argv(opts).env({
	separator: '__',
});

process.env.NODE_ENV = process.env.NODE_ENV || 'production';
global.env = process.env.NODE_ENV || 'production';

prestart.setupWinston();

// Alternate configuration file support
const configFile = path.resolve(paths.baseDir, nconf.get('config') || 'config.json');
const configExists = file.existsSync(configFile) || (nconf.get('url') && nconf.get('secret') && nconf.get('database'));

prestart.loadConfig(configFile);
prestart.versionCheck();

if (!configExists && process.argv[2] !== 'setup') {
	require('./setup').webInstall();
	return;
}

if (configExists) {
	process.env.CONFIG = configFile;
}

// running commands
program
	.command('start')
	.description('Start the NodeBB server')
	.action(() => {
		require('./running').start(program.opts());
	});
program
	.command('slog', null, {
		noHelp: true,
	})
	.description('Start the NodeBB server and view the live output log')
	.action(() => {
		require('./running').start({ ...program.opts(), log: true });
	});
program
	.command('dev', null, {
		noHelp: true,
	})
	.description('Start NodeBB in verbose development mode')
	.action(() => {
		process.env.NODE_ENV = 'development';
		global.env = 'development';
		require('./running').start({ ...program.opts(), dev: true });
	});
program
	.command('stop')
	.description('Stop the NodeBB server')
	.action(() => {
		require('./running').stop(program.opts());
	});
program
	.command('restart')
	.description('Restart the NodeBB server')
	.action(() => {
		require('./running').restart(program.opts());
	});
program
	.command('status')
	.description('Check the running status of the NodeBB server')
	.action(() => {
		require('./running').status(program.opts());
	});
program
	.command('log')
	.description('Open the output log (useful for debugging)')
	.action(() => {
		require('./running').log(program.opts());
	});

// management commands
program
	.command('setup [config]')
	.description('Run the NodeBB setup script, or setup with an initial config')
	.option('--skip-build', 'Run setup without building assets')
	.action((initConfig) => {
		if (initConfig) {
			try {
				initConfig = JSON.parse(initConfig);
			} catch (e) {
				console.warn(chalk.red('Invalid JSON passed as initial config value.'));
				console.log('If you meant to pass in an initial config value, please try again.\n');

				throw e;
			}
		}
		require('./setup').setup(initConfig);
	});

program
	.command('install [plugin]')
	.description('Launch the NodeBB web installer for configuration setup or install a plugin')
	.option('-f, --force', 'Force plugin installation even if it may be incompatible with currently installed NodeBB version')
	.action((plugin, options) => {
		if (plugin) {
			require('./manage').install(plugin, options);
		} else {
			require('./setup').webInstall();
		}
	});

program
	.command('build [targets...]')
	.description(`Compile static assets ${chalk.red('(JS, CSS, templates, languages)')}`)
	.option('-s, --series', 'Run builds in series without extra processes')
	.option('-w, --webpack', 'Bundle assets with webpack', true)
	.action((targets, options) => {
		if (program.opts().dev) {
			process.env.NODE_ENV = 'development';
			global.env = 'development';
		}
		require('./manage').build(targets.length ? targets : true, options);
	})
	.on('--help', () => {
		require('../meta/aliases').buildTargets();
	});
program
	.command('activate [plugin]')
	.description('Activate a plugin for the next startup of NodeBB (nodebb-plugin- prefix is optional)')
	.action((plugin) => {
		require('./manage').activate(plugin);
	});
program
	.command('plugins')
	.action(() => {
		require('./manage').listPlugins();
	})
	.description('List all installed plugins');
program
	.command('events [count]')
	.description('Outputs the most recent administrative events recorded by NodeBB')
	.action((count) => {
		require('./manage').listEvents(count);
	});
program
	.command('info')
	.description('Outputs various system info')
	.action(() => {
		require('./manage').info();
	});
program
	.command('maintenance <toggle>')
	.description('Toggle maintenance mode true/false')
	.action((toggle) => {
		require('./manage').maintenance(toggle);
	});

// reset
const resetCommand = program.command('reset');

resetCommand
	.description('Reset plugins, themes, settings, etc')
	.option('-t, --theme [theme]', 'Reset to [theme] or to the default theme')
	.option('-p, --plugin [plugin]', 'Disable [plugin] or all plugins')
	.option('-w, --widgets', 'Disable all widgets')
	.option('-s, --settings', 'Reset settings to their default values')
	.option('-a, --all', 'All of the above')
	.action((options) => {
		const valid = ['theme', 'plugin', 'widgets', 'settings', 'all'].some(x => options[x]);
		if (!valid) {
			console.warn(`\n${chalk.red('No valid options passed in, so nothing was reset.')}`);
			resetCommand.help();
		}

		require('./reset').reset(options, (err) => {
			if (err) {
				return process.exit(1);
			}

			process.exit(0);
		});
	});

// user
program
	.addCommand(require('./user')());

// upgrades
program
	.command('upgrade [scripts...]')
	.description('Run NodeBB upgrade scripts and ensure packages are up-to-date, or run a particular upgrade script')
	.option('-m, --package', 'Update package.json from defaults', false)
	.option('-i, --install', 'Bringing base dependencies up to date', false)
	.option('-p, --plugins', 'Check installed plugins for updates', false)
	.option('-s, --schema', 'Update NodeBB data store schema', false)
	.option('-b, --build', 'Rebuild assets', false)
	.on('--help', () => {
		console.log(`\n${[
			'When running particular upgrade scripts, options are ignored.',
			'By default all options are enabled. Passing any options disables that default.',
			'\nExamples:',
			`  Only package and dependency updates: ${chalk.yellow('./nodebb upgrade -mi')}`,
			`  Only database update: ${chalk.yellow('./nodebb upgrade -s')}`,
		].join('\n')}`);
	})
	.action((scripts, options) => {
		options.unattended = program.opts().unattended;
		if (program.opts().dev) {
			process.env.NODE_ENV = 'development';
			global.env = 'development';
		}
		require('./upgrade').upgrade(scripts.length ? scripts : true, options);
	});

program
	.command('upgrade-plugins', null, {
		noHelp: true,
	})
	.alias('upgradePlugins')
	.description('Upgrade plugins')
	.action(() => {
		const { unattended } = program.opts();
		require('./upgrade-plugins').upgradePlugins(unattended, (err) => {
			if (err) {
				throw err;
			}
			console.log(chalk.green('OK'));
			process.exit();
		});
	});

program
	.command('help [command]')
	.description('Display help for [command]')
	.action((name) => {
		if (!name) {
			return program.help();
		}

		const command = program.commands.find(command => command._name === name);
		if (command) {
			command.help();
		} else {
			console.log(`error: unknown command '${command}'.`);
			program.help();
		}
	});

if (process.argv.length === 2) {
	program.help();
}

program.executables = false;

program.parse();
