#!/usr/bin/env node

import { redBright, green, greenBright, yellow } from 'ansi-colors';
import { program } from 'commander';
import dedent from 'ts-dedent';
import webpack from 'webpack';
import path from 'path';
import fs from 'fs';

import { parseEnvFlags } from '../cli/parseEnvFlags';

const defaultConfig = path.resolve(
	__dirname,
	'../stubs/default.config.stub.js',
);
const tag = `[${green('@nativescript/webpack')}]`;

function error(message: string) {
	console.error(`${tag} ${redBright(dedent(message))}`);
}

function info(message: string) {
	console.info(`${tag} ${greenBright(dedent(message))}`);
}

program.enablePositionalOptions();

program
	.command('init')
	.description('Initialize a new webpack.config.js in the current directory.')
	.action(() => {
		const targetPath = path.resolve(process.cwd(), 'webpack.config.js');

		if (fs.existsSync(targetPath)) {
			return error(`File Already Exists: ${targetPath}`);
		}

		fs.copyFileSync(defaultConfig, targetPath);

		info('Initialized config.');
	});

program
	.command('build')
	.description('Build...')
	.option('--env [name]', 'environment name')
	.option('--config [path]', 'config path')
	.option('--watch', 'watch for changes')
	.allowUnknownOption()
	.allowExcessArguments()
	.action((options, command) => {
		const env = parseEnvFlags(command.args);
		// add --env <val> into the env object
		// for example if we use --env prod
		// we'd have env.env = 'prod'
		if (options.env) {
			env['env'] = options.env;
		}

		env['stats'] ??= true;
		env['watch'] ??= options.watch;

		// if --env.config is passed, we'll set an environment
		// variable to it's value so that the config Util
		// reads from the correct config file.
		process.env.NATIVESCRIPT_CONFIG_NAME ??= env['config'];

		const configPath = (() => {
			if (options.config) {
				return path.resolve(options.config);
			}

			return path.resolve(process.cwd(), 'webpack.config.js');
		})();

		// todo: validate config exists
		// todo: guard against invalid config
		let configuration: webpack.Configuration;
		try {
			configuration = require(configPath)(env);
		} catch (err) {
			console.log(err);
		}

		if (!configuration) {
			console.log('No configuration!');
			process.exitCode = 1;
			return;
		}

		const compiler = webpack(configuration);

		const webpackCompilationCallback = (
			err: webpack.WebpackError,
			stats: webpack.Stats,
		) => {
			if (err) {
				// Do not keep cache anymore
				compiler.purgeInputFileSystem();

				console.error(err.stack || err);
				if (err.details) {
					console.error(err.details);
				}

				process.exitCode = 1;
				return;
			}

			if (stats) {
				// Set the process exit code depending on errors
				process.exitCode = stats.hasErrors() ? 1 : 0;

				if (env.stats) {
					console.log(
						stats.toString({
							chunks: false,
							colors: true,
							errorDetails: env.verbose,
						}),
					);
				}

				// if webpack profile is enabled we write the stats to a JSON file
				if (configuration.profile || env.profile) {
					console.log(
						[
							'',
							'|',
							`|  The build profile has been written to ${yellow(
								'webpack.stats.json',
							)}`,
							`|  You can analyse the stats at ${green(
								'https://webpack.github.io/analyse/',
							)}`,
							'|',
							'',
						].join('\n'),
					);
					fs.writeFileSync(
						path.join(process.cwd(), 'webpack.stats.json'),
						JSON.stringify(stats.toJson()),
					);
				}
			}
		};

		if (options.watch) {
			env.stats && console.log('webpack is watching the files...');
			compiler.watch(
				configuration.watchOptions ?? {},
				webpackCompilationCallback,
			);
		} else {
			compiler.run((err, status) => {
				compiler.close((err2) =>
					webpackCompilationCallback(
						(err || err2) as webpack.WebpackError,
						status,
					),
				);
			});
		}
	});

program.version(require('../../package.json').version, '-v, --version');

program.parse(process.argv);