import { ExecutorContext } from '@nx/devkit';
import chalk from 'chalk';
import { join, relative } from 'path';
import { extractPackageJsonData } from '../shared/metadata-utils/extract-package-json-data';
import { JournalExecutorSchema } from './schema';
import { generateJournal } from './utils/generate-journal';
import { writeJournal } from './write-journal';

export default async function runJournalExecutor(
  options: JournalExecutorSchema,
  context: ExecutorContext
) {
  const logger = createLogger();
  logger.info(`Running Journal Executor on '${options.project}'`);

  // TODO: infer project path from executor context
  const projectPath = join(context.root, options.project);
  // TODO: use sane default for outputFile
  const outputFile = join(context.root, options.outputFile);

  const { name: packageName } = extractPackageJsonData(projectPath);

  const data = await generateJournal({
    libraryFolder: projectPath,
    packageName,
    logger
  });

  await writeJournal(outputFile, data);

  if (logger.hasErrors()) {
    logger.error('The executor failed to create a proper Journal file due to the above error(s).');
    return {
      success: false
    };
  }

  logger.success(`Success ✓\nJournal written to '${relative(context.root, outputFile)}'`);
  return { success: true };
}

export interface JournalLogger {
  info: (message: string) => void;
  error: (message: string) => void;
  success: (message: string) => void;
  warn: (message: string) => void;
  hasErrors: () => boolean;
}

export function createLogger(): JournalLogger {
  let hasError = false;

  return {
    info: (message: string) => console.info(message),
    error: (message: string) => {
      hasError = true;
      console.error(chalk.red(message));
    },
    success: (message: string) => console.info(chalk.green(message)),
    warn: (message: string) => console.warn(chalk.yellow(message)),
    hasErrors: () => hasError
  };
}