private ensureDeploymentDocumentEventsHookedUp()

in src/AzureRMTools.ts [1015:1128]
62 lines of code
2 McCabe index (conditional complexity)

    private ensureDeploymentDocumentEventsHookedUp(): void {
        if (this._areDeploymentTemplateEventsHookedUp) {
            return;
        }
        this._areDeploymentTemplateEventsHookedUp = true;

        // tslint:disable-next-line: no-suspicious-comment
        // tslint:disable-next-line: max-func-body-length // TODO: Refactor
        callWithTelemetryAndErrorHandlingSync("ensureDeploymentTemplateEventsHookedUp", (actionContext: IActionContext) => {
            actionContext.telemetry.suppressIfSuccessful = true;

            vscode.window.onDidChangeTextEditorSelection(this.onTextSelectionChanged, this, ext.context.subscriptions);

            const hoverProvider: vscode.HoverProvider = {
                provideHover: async (document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken): Promise<vscode.Hover | undefined> => {
                    return await this.onProvideHover(document, position, token);
                }
            };
            ext.context.subscriptions.push(vscode.languages.registerHoverProvider(templateDocumentSelector, hoverProvider));

            const codeLensProvider: vscode.CodeLensProvider = {
                onDidChangeCodeLenses: this._codeLensChangedEmitter.event,
                provideCodeLenses: (document: vscode.TextDocument, token: vscode.CancellationToken): vscode.CodeLens[] | undefined => {
                    return this.onProvideCodeLenses(document, token);
                },
                resolveCodeLens: async (codeLens: vscode.CodeLens, token: vscode.CancellationToken): Promise<vscode.CodeLens | undefined> => {
                    return await this.onResolveCodeLens(codeLens, token);
                }
            };
            ext.context.subscriptions.push(vscode.languages.registerCodeLensProvider(templateDocumentSelector, codeLensProvider));

            // Code actions provider
            const codeActionProvider: vscode.CodeActionProvider = {
                provideCodeActions: async (
                    textDocument: vscode.TextDocument,
                    range: vscode.Range | vscode.Selection,
                    context: vscode.CodeActionContext,
                    token: vscode.CancellationToken
                ): Promise<(vscode.Command | vscode.CodeAction)[] | undefined> => {
                    return await this.onProvideCodeActions(textDocument, range, context, token);
                }
            };
            ext.context.subscriptions.push(
                vscode.languages.registerCodeActionsProvider(
                    templateOrParameterDocumentSelector,
                    codeActionProvider,
                    {
                        providedCodeActionKinds: [
                            vscode.CodeActionKind.QuickFix,
                            vscode.CodeActionKind.RefactorExtract
                        ]
                    }
                ));

            // tslint:disable-next-line:no-suspicious-comment
            const definitionProvider: vscode.DefinitionProvider = {
                provideDefinition: async (document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken): Promise<vscode.Definition | undefined> => {
                    return await this.onProvideDefinition(document, position, token);
                }
            };
            ext.context.subscriptions.push(
                vscode.languages.registerDefinitionProvider(
                    templateOrParameterDocumentSelector,
                    definitionProvider));

            const referenceProvider: vscode.ReferenceProvider = {
                provideReferences: async (document: vscode.TextDocument, position: vscode.Position, context: vscode.ReferenceContext, token: vscode.CancellationToken): Promise<vscode.Location[] | undefined> => {
                    return this.onProvideReferences(document, position, context, token);
                }
            };
            ext.context.subscriptions.push(vscode.languages.registerReferenceProvider(templateOrParameterDocumentSelector, referenceProvider));

            const signatureHelpProvider: vscode.SignatureHelpProvider = {
                provideSignatureHelp: async (document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken): Promise<vscode.SignatureHelp | undefined> => {
                    return await this.onProvideSignatureHelp(document, position, token);
                }
            };
            ext.context.subscriptions.push(vscode.languages.registerSignatureHelpProvider(templateDocumentSelector, signatureHelpProvider, ",", "(", "\n"));

            const renameProvider: vscode.RenameProvider = {
                provideRenameEdits: async (document: vscode.TextDocument, position: vscode.Position, newName: string, token: vscode.CancellationToken): Promise<vscode.WorkspaceEdit | undefined> => {
                    return await this.onProvideRename(document, position, newName, token);
                },
                prepareRename: async (document: vscode.TextDocument, position: vscode.Position, token: vscode.CancellationToken): Promise<vscode.Range | { range: vscode.Range; placeholder: string } | undefined> => {
                    return await this.prepareRename(document, position, token);
                }
            };
            ext.context.subscriptions.push(vscode.languages.registerRenameProvider(templateOrParameterDocumentSelector, renameProvider));

            const documentLinkProvider: vscode.DocumentLinkProvider = {
                provideDocumentLinks: async (document: vscode.TextDocument, token: vscode.CancellationToken): Promise<vscode.DocumentLink[] | undefined> => {
                    return await this.provideDocumentLinks(document, token);
                }
            };
            ext.context.subscriptions.push(
                vscode.languages.registerDocumentLinkProvider(templateDocumentSelector, documentLinkProvider));

            const linkedTemplateDocumentProvider: vscode.TextDocumentContentProvider = {
                onDidChange: this._linkedTemplateDocProviderChangedEmitter.event,
                provideTextDocumentContent: async (uri: vscode.Uri, _token: vscode.CancellationToken): Promise<string | undefined> => {
                    return await this.provideContentForNonlocalUri(uri);
                }
            };
            ext.context.subscriptions.push(
                vscode.workspace.registerTextDocumentContentProvider(
                    documentSchemes.linkedTemplate,
                    linkedTemplateDocumentProvider));

            ext.context.subscriptions.push(notifyTemplateGraphAvailable(this.onTemplateGraphAvailable, this));
            ext.context.subscriptions.push(ext.languageServerStateChanged(this.onLanguageServerStateChanged, this));

            startArmLanguageServerInBackground();
        });
    }