function transform(file, { j }, options) {
  const root = j(file.source);
  const dirty = transformArrayMethod('array-every', 'every', root, j);
  return dirty ? root.toSource(options) : file.source;
}

export default transform;


function transformArrayMethod(method, identifierName, root, j) {
	const { identifier, dirtyFlag: importDirtyFlag } = removeImport(
		method,
		root,
		j,
	);

	let dirtyFlag = importDirtyFlag;

	root
		.find(j.CallExpression, {
			callee: {
				type: 'Identifier',
				name: identifier,
			},
		})
		.forEach((path) => {
			const [arrayArg, ...otherArgs] = path.node.arguments;
			if (j.Identifier.check(arrayArg) || j.ArrayExpression.check(arrayArg)) {
				path.replace(
					j.callExpression(
						j.memberExpression(arrayArg, j.identifier(identifierName)),
						otherArgs,
					),
				);
				dirtyFlag = true;
			}
		});

	return dirtyFlag;
}


function removeImport(name, root, j) {
	// Find the import or require statement for 'is-boolean-object'
	const importDeclaration = root.find(j.ImportDeclaration, {
		source: {
			value: name,
		},
	});

	const requireDeclaration = root
		.find(j.CallExpression, {
			callee: {
				name: 'require',
			},
			arguments: [
				{
					value: name,
				},
			],
		})
		.closest(j.VariableDeclarator);

	// Require statements without declarations like `Object.is = require("object-is");`
	const requireAssignment = root.find(j.AssignmentExpression, {
		operator: '=',
		right: {
			callee: {
				name: 'require',
			},
			arguments: [
				{
					value: name,
				},
			],
		},
	});

	// Side effect requires statements like `require("error-cause/auto");`
	const sideEffectRequireExpression = root.find(j.ExpressionStatement, {
		expression: {
			callee: {
				name: 'require',
			},
			arguments: [
				{
					value: name,
				},
			],
		},
	});

	// Return the identifier name, e.g. 'fn' in `import { fn } from 'is-boolean-object'`
	// or `var fn = require('is-boolean-object')`
	const identifier =
		importDeclaration.paths().length > 0
			? importDeclaration.get().node.specifiers[0].local.name
			: requireDeclaration.paths().length > 0
				? requireDeclaration.find(j.Identifier).get().node.name
				: requireAssignment.paths().length > 0
					? requireAssignment.find(j.Identifier).get().node.name
					: null;

	importDeclaration.remove();
	requireDeclaration.remove();
	requireAssignment.remove();
	sideEffectRequireExpression.remove();

	const dirtyFlag =
		importDeclaration.length > 0 ||
		requireDeclaration.length > 0 ||
		requireAssignment.length > 0 ||
		sideEffectRequireExpression.length > 0;

	return { identifier, dirtyFlag };
}