import fs from 'fs';
import path from 'path';
import util from 'util';
import { exec } from 'child_process';
import { glob } from "glob";
import ts from 'typescript';

const readFileAsync = util.promisify(fs.readFile);
const execAsync = util.promisify(exec);

const filterAsync = async (asyncPredicate, arr) => {
	const filterResults = await Promise.all(arr.map(async item => ({
		item,
		shouldKeep: await asyncPredicate(item)
	})));

	return filterResults.filter(({shouldKeep}) => shouldKeep).map(({item}) => item);
}

const isAbstractClass = (node) => {
	if (ts.isClassDeclaration(node)) {
		return node.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.AbstractKeyword) || false;
	}
	return false;
}

const isAbstractMethod = (node) =>  {
	return ts.isMethodDeclaration(node) && Boolean(node.modifiers?.find((modifier) => modifier.kind === ts.SyntaxKind.AbstractKeyword));
}


// Function to check if a file has a function declaration, function expression, object method or class
const hasFunctionOrClass = async filePath => {
	const fileContent = await readFileAsync(filePath, 'utf-8');
	const sourceFile = ts.createSourceFile(filePath, fileContent, ts.ScriptTarget.Latest, true);

	let hasFunctionOrClass = false;
	const visit = node => {
		if (
			ts.isFunctionDeclaration(node)
			|| ts.isFunctionExpression(node)
			|| ts.isArrowFunction(node)
			|| (ts.isMethodDeclaration(node) && !isAbstractMethod(node))
			|| (ts.isClassDeclaration(node) && !isAbstractClass(node))
		) {
			hasFunctionOrClass = true;
		}
		node.forEachChild(visit);
	}

	visit(sourceFile);

	return hasFunctionOrClass;
}

const main = async () => {

  // Run a git command to get a list of all changed files in the branch (branch has to be up to date with master)
	const changedFiles = await execAsync('git diff --name-only --diff-filter=d origin/master..HEAD')
		.then(({stdout}) => stdout.trim().split('\n').filter(Boolean));

  // Get all .spec.ts and .test.ts files from the packages
	const specAndTestTsFiles = await glob('packages/*/**/{test,__tests__}/**/*.{spec,test}.ts');
	const specAndTestTsFilesNames = specAndTestTsFiles.map(file => path.parse(file).name.replace(/\.(test|spec)/, ''));

  // Filter out the .ts and .vue files from the changed files
	const changedVueFiles = changedFiles.filter(file => file.endsWith('.vue'));
	// .ts files with any kind of function declaration or class and not in any of the test folders
	const changedTsFilesWithFunction = await filterAsync(
		async filePath =>
			filePath.endsWith('.ts') &&
			!(await glob('packages/*/**/{test,__tests__}/*.ts')).includes(filePath) &&
			await hasFunctionOrClass(filePath),
		changedFiles
	);

  // For each .ts or .vue file, check if there's a corresponding .test.ts or .spec.ts file in the repository
	const missingTests = changedVueFiles.concat(changedTsFilesWithFunction).reduce((filesList, nextFile) => {
		const fileName = path.parse(nextFile).name;

		if (!specAndTestTsFilesNames.includes(fileName)) {
			filesList.push(nextFile);
		}

		return filesList;
	}, []);

	if(missingTests.length) {
		console.error(`Missing tests for:\n${missingTests.join('\n')}`);
		process.exit(1);
	}
};

main();