// getChangedFunctions.ts

import { basename, dirname, join, resolve } from 'path';
import { createProgram, SourceFile } from 'typescript';

const FUNCTIONS_REGEXP = /.*src\/(?<type>functions)\/(?<resourceName>[A-Za-z]*)\/(?<filename>.*)/u;

interface SourceNode extends SourceFile {
  readonly imports?: ReadonlyArray<{ text: string }>;
}

const program = createProgram(
  [join(__dirname, '../../../../src/index.ts')],
  {},
);
const sources = program.getSourceFiles() as SourceNode[];

const dependantsMap = new Map<string, string[]>();

sources.forEach((source: SourceNode): void => {
  const sourcePath = source.fileName;
  const sourceDirectory = dirname(sourcePath);
  const resolvedSourcePath = require.resolve(sourcePath);

  if (sourcePath.includes('node_modules') === false) {
    (source.imports ?? []).forEach(
      ({ text: importPath }: { text: string }): void => {
        if (importPath.startsWith('.')) {
          const resolvedDependencyPath = require.resolve(
            resolve(sourceDirectory, importPath),
          );

          // Get or create a reference to dependants for a module.
          const maybeDependants: string[] | undefined = dependantsMap.get(
            resolvedDependencyPath,
          );
          const dependants = maybeDependants ?? [];

          if (maybeDependants === undefined) {
            dependantsMap.set(resolvedDependencyPath, dependants);
          }

          // Add a current source file as a dependant of an imported file.
          dependants.push(resolvedSourcePath);
        }
      },
    );
  }
});

const findChangedDeep = (
  root: string,
  traversed: Set<string> = new Set(),
): string[] => {
  // Get dependants of a file which were not already traversed.
  const dependants = dependantsMap.get(root);
  const traversableDependants =
    dependants?.filter(
      (dependant: string): boolean => traversed.has(dependant) === false,
    ) ?? [];

  // Add all dependants to the list of traversed.
  dependants?.forEach((dependant: string): void => {
    traversed.add(dependant);
  });

  return [
    root,
    ...traversableDependants.flatMap((dependant: string): string[] =>
      findChangedDeep(dependant, traversed),
    ),
  ];
};

export const getChangedFunctions = async (
  deployableFunctions: string[],
  affectedFiles: string[],
): Promise<string[]> => {
  const processedFiles = affectedFiles.flatMap(
    (affectedFile: string): string[] =>
      affectedFile.includes('.spec.ts') ? [] : findChangedDeep(affectedFile),
  );

  return processedFiles
    .reduce((accumulator: string[], path: string): string[] => {
      const matches = FUNCTIONS_REGEXP.exec(path);

      if (matches?.groups !== undefined) {
        const { resourceName: functionName } = matches.groups;

        return deployableFunctions
          .filter((deployableFunction): boolean =>
            deployableFunction.startsWith(functionName),
          )
          .reduce((functionAccumulator, matchingFunction): string[] => {
            if (
              deployableFunctions.includes(matchingFunction) &&
              functionAccumulator.includes(matchingFunction) === false
            ) {
              return [matchingFunction, ...functionAccumulator];
            }

            return functionAccumulator;
          }, accumulator);
      }

      return accumulator;
    }, [])
    .sort((first: string, second: string): number =>
      first < second ? -1 : second < first ? 1 : 0,
    );
};

// index.ts

import * as depcheck from 'depcheck';
import { getLastCommit } from 'git-last-commit';
import { getChangedFilesForRoots } from 'jest-changed-files';
import { join } from 'path';
import { splitEvery } from 'ramda';
import { promisify } from 'util';

import { runFirebaseDeploy } from '../utils/firebaseDeploymentHelper';
import { getChangedFunctions } from './getChangedFunctions';

/* eslint-disable @typescript-eslint/no-require-imports */
/* eslint-disable @typescript-eslint/no-var-requires */

// Only built program can be deployed.
const functions = require('../../../../lib');

/* eslint-enable @typescript-eslint/no-require-imports */
/* eslint-enable @typescript-eslint/no-var-requires */

const DEPLOYMENT_BATCH_SIZE = 25;

const PRODUCTION_PROJECT_ID = '!!!change-me!!!';

const DEPENDENCY_CHECK_OPTIONS: depcheck.Options = {
  detectors: [
    depcheck.detector.typescriptImportEqualsDeclaration,
    depcheck.detector.typescriptImportType,
    depcheck.detector.requireCallExpression,
    depcheck.detector.importDeclaration,
  ],
  ignoreBinPackage: false,
  ignoreDirs: ['scripts', 'test'],
  parsers: {
    '*.ts': depcheck.parser.typescript,
  },
  skipMissing: false,
};

/**
 * Commit message that should trigger update of all functions.
 */
const deployAllFunctions = (commitSubject: string): boolean =>
  commitSubject.startsWith('chore(deps-dev): bump firebase-tools') ||
  commitSubject.startsWith('chore(deps-dev): bump json-perf-loader') ||
  commitSubject.startsWith('chore(deps-dev): bump typescript') ||
  commitSubject.startsWith('chore(deps-dev): bump webpack') ||
  commitSubject.startsWith('chore(deps): bump source-map-support');

/**
 * Exhaustive search of which functions should be deployed.
 * - If the commit message starts with 'chore(deps)' it builds a dependency
 * tree and updates the functions using the updated dependency.
 * - Otherwise check the files that were changed in the previous commit and
 * determine which functions are affected.
 */
const getFunctionsToDeploy = async (): Promise<string[]> => {
  const deployableFunctions = Object.keys(functions);

  const lastCommit = await promisify(getLastCommit)();

  if (deployAllFunctions(lastCommit.subject)) {
    console.info('Deploying all functions.');

    return deployableFunctions;
  }

  if (lastCommit.subject.startsWith('chore(deps') === true) {
    console.info('Dependency update, checking dependant functions.');

    const dependencies = await depcheck(
      join(__dirname, '../../../../'),
      DEPENDENCY_CHECK_OPTIONS,
    );

    /**
     * Dependency commit messages are structures as follow:
     * - chore(deps): bump firebase-functions from 3.6.0 to 3.6.1
     * - chore(deps): bump @google-cloud/firestore from 3.7.4 to 3.7.5
     */
    const [, , updatedDependency] = lastCommit.subject.split(' ');

    const filesUsingDependency = dependencies.using[updatedDependency];

    return getChangedFunctions(deployableFunctions, filesUsingDependency);
  }

  console.info('Running file change check.');

  const { changedFiles } = await getChangedFilesForRoots(
    [join(__dirname, '../../../../src')],
    { lastCommit: true, withAncestor: true },
  );

  const changedFunctions = await getChangedFunctions(
    deployableFunctions,
    Array.from(changedFiles),
  );

  if (changedFunctions.length > 0) {
    console.info('Changed functions detected.');

    return changedFunctions;
  }

  /**
   * Unable to determine minimum functions to deploy, deploy everything.
   */
  console.info('Unable to detect changed functions, deploying everything.');

  return deployableFunctions;
};

export const deploy = async (projectId: string): Promise<boolean> => {
  const functionNames = await getFunctionsToDeploy();

  const sortedFunctionNames = functionNames.sort(
    (first: string, second: string): number =>
      first < second ? -1 : second < first ? 1 : 0,
  );

  if (sortedFunctionNames.length > 0) {
    console.info('Deploying the following functions: ');
    console.table(sortedFunctionNames);
  }

  const functionNamesGroups = splitEvery(
    DEPLOYMENT_BATCH_SIZE,
    sortedFunctionNames,
  );

  const runFirebaseDeployPromises: Array<Promise<boolean>> = [];

  for (const functionNamesGroup of functionNamesGroups) {
    const functionDeploymentFilteringSentinel = functionNamesGroup
      .map((functionName: string): string => `functions:${functionName}`)
      .join(',');

    runFirebaseDeployPromises.push(
      runFirebaseDeploy(`${functionDeploymentFilteringSentinel}`, projectId),
    );

    /*
     * Cloud Functions allow a maximum of 30 deployments per minute, but that is
     * independent of the time it takes to deploy a function.
     */
    /* eslint-disable-next-line no-await-in-loop */
    await new Promise((resolve: (_: unknown) => void): void => {
      setTimeout(resolve, 60_000);
    });
  }

  return (await Promise.all(runFirebaseDeployPromises)).every(
    (succeeded: boolean): boolean => succeeded,
  );
};

// utils/firebaseDeploymentHelper.ts

import { spawn } from 'child_process';
import { join } from 'path';
import { env as environment } from 'process';

const ROOT_PATH = join(__dirname, '..', '..', '..', '..');

export const runFirebaseDeploy = async (
  component: string,
  projectId: string,
): Promise<boolean> => {
  /* eslint-disable unicorn/prevent-abbreviations */
  const deploymentProcess = spawn(
    'firebase',
    ['deploy', '--force', `--only=${component}`, `--project=${projectId}`],
    { cwd: ROOT_PATH, env: environment },
  );
  /* eslint-enable unicorn/prevent-abbreviations */

  deploymentProcess.stdout.on('data', (data: Buffer): void => {
    console.log(data.toString());
  });

  deploymentProcess.stderr.on('data', (data: Buffer): void => {
    console.error(data.toString());
  });

  return new Promise<boolean>((resolve: (result: boolean) => void): void => {
    deploymentProcess.on('close', (code: number): void => {
      console.log(`Exit code: ${code.toString()}.`);

      resolve(code === 0);
    });
  });
};