export function provideCompletionItems()

in experimental/adaptive-tool/server/lu/src/providers/completion.ts [32:178]
119 lines of code
11 McCabe index (conditional complexity)

export function provideCompletionItems(_textDocumentPosition: TextDocumentPositionParams, documents: TextDocuments<TextDocument>) {
	const document = documents.get(_textDocumentPosition.textDocument.uri)!;
	const fspath = Files.uriToFilePath(document.uri);
	const position = _textDocumentPosition.position;
	const curLineContent = document?.getText({
		start: {
			line: position.line,
			character: 0
		},
		end: position
	}).toString();

    if(!util.isLuFile(path.basename(document.uri)) ) 
		return;

    const fullContent = document.getText();
    const lines = fullContent.split('\n');
	const textExceptCurLine = lines
		.slice(0, position.line)
		.concat(lines.slice(position.line + 1))
		.join('\n');

    const completionList: CompletionItem[] = [];

    if (/\[[^\]]*\]\([^)]*$/.test(curLineContent)) {
		// []() import suggestion
		const paths = Array.from(new Set(LuFilesStatus.luFilesOfWorkspace));

		return paths.filter(u => u !== fspath).reduce((prev : any[], curr: string) => {
			const relativePath = path.relative(path.dirname(fspath!), curr);
			const item = {
				label: relativePath, 
				kind: CompletionItemKind.Reference,
				detail: curr
			};
			prev.push(item);
			return prev;
		}, []);
	}

	// if (matchingPattern.isEntityType(curLineContent)) {
	// 	const entityTypes: string[] = EntityTypesObj.EntityType;
	// 	entityTypes.forEach(entity => {
	// 		const item = {
	// 			label: entity,
	// 			kind: CompletionItemKind.Keyword,
	// 			insertText: `${entity}`,
	// 			documentation: `Enitity type: ${entity}`,
	// 		};
	// 		completionList.push(item);
	// 	});
	// }

    if (matchingPattern.isPrebuiltEntity(curLineContent)) {
		const prebuiltTypes: string[] = EntityTypesObj.Prebuilt;
		prebuiltTypes.forEach(entity => {
			const item = {
				label: entity,
				kind: CompletionItemKind.Keyword,
				insertText: `${entity}`,
				documentation: `Prebuilt enitity: ${entity}`,
			};
			completionList.push(item);
		});
	}

    if (matchingPattern.isRegexEntity(curLineContent)) {
		const item = {
			label: 'RegExp Entity',
			kind: CompletionItemKind.Keyword,
			insertText: `//`,
			documentation: `regex enitity`,
		};
		completionList.push(item);
	}

    if (matchingPattern.isEntityName(curLineContent)) {
		const item = {
			label: 'hasRoles?',
			kind: CompletionItemKind.Keyword,
			insertText: `hasRoles`,
			documentation: `Entity name hasRole?`,
		};
		completionList.push(item);
		const item2 = {
			label: 'usesFeature?',
			kind: CompletionItemKind.Keyword,
			insertText: `usesFeature`,
			documentation: `Entity name usesFeature?`,
		};
		completionList.push(item2);
	}

    if (matchingPattern.isPhraseListEntity(curLineContent)) {
		const item = {
			label: 'interchangeable synonyms?',
			kind: CompletionItemKind.Keyword,
			insertText: `interchangeable`,
			documentation: `interchangeable synonyms as part of the entity definition`,
		};
		completionList.push(item);
	}

    if (matchingPattern.isEntityType(curLineContent)) {
		// @ can be followed by entity like ml, regex or entity
		const entityTypes: string[] = EntityTypesObj.EntityType;
		entityTypes.forEach(entity => {
			const item = {
				label: entity,
				kind: CompletionItemKind.Keyword,
				insertText: `${entity}`,
				documentation: `Enitity type: ${entity}`,
			};
			completionList.push(item);
		});
		return extractLUISContent(fullContent).then(
			luisJson => {
				if (!luisJson) {
					return extractLUISContent(textExceptCurLine).then(
						newluisJson => {
							return addEntities(newluisJson, completionList);}
					);
				} else {
					return addEntities(luisJson, completionList);
				}
			}
		);
    }
    // completion for entities and patterns, use the text without current line due to usually it will cause parser errors, the luisjson will be undefined
    if (completionList.length === 0){
		
		return extractLUISContent(fullContent).then(
			luisJson => {
				if (!luisJson) {
					extractLUISContent(textExceptCurLine).then(
						newluisJson => {
							return processSuggestions(newluisJson, curLineContent, fullContent);}
					)
				} else {
					return processSuggestions(luisJson, curLineContent, fullContent)
				}
			}
		);
	}
	
	return completionList;
}