async getPaginatedRecommendation()

in packages/core/src/codewhisperer/service/inlineCompletionService.ts [78:165]
75 lines of code
14 McCabe index (conditional complexity)

    async getPaginatedRecommendation(
        client: DefaultCodeWhispererClient,
        editor: vscode.TextEditor,
        triggerType: CodewhispererTriggerType,
        config: ConfigurationEntry,
        autoTriggerType?: CodewhispererAutomatedTriggerType,
        event?: vscode.TextDocumentChangeEvent
    ): Promise<GetRecommendationsResponse> {
        if (vsCodeState.isCodeWhispererEditing || RecommendationHandler.instance.isSuggestionVisible()) {
            return {
                result: 'Failed',
                errorMessage: 'Amazon Q is already running',
                recommendationCount: 0,
            }
        }

        // Call report user decisions once to report recommendations leftover from last invocation.
        RecommendationHandler.instance.reportUserDecisions(-1)
        TelemetryHelper.instance.setInvokeSuggestionStartTime()
        ClassifierTrigger.instance.recordClassifierResultForAutoTrigger(editor, autoTriggerType, event)

        const triggerChar = event?.contentChanges[0]?.text
        if (autoTriggerType === 'SpecialCharacters' && triggerChar) {
            TelemetryHelper.instance.setTriggerCharForUserTriggerDecision(triggerChar)
        }
        const isAutoTrigger = triggerType === 'AutoTrigger'
        if (AuthUtil.instance.isConnectionExpired()) {
            await AuthUtil.instance.notifyReauthenticate(isAutoTrigger)
            return {
                result: 'Failed',
                errorMessage: 'auth',
                recommendationCount: 0,
            }
        }

        await this.setState('loading')

        RecommendationHandler.instance.checkAndResetCancellationTokens()
        RecommendationHandler.instance.documentUri = editor.document.uri
        let response: GetRecommendationsResponse = {
            result: 'Failed',
            errorMessage: undefined,
            recommendationCount: 0,
        }
        try {
            let page = 0
            while (page < this.maxPage) {
                response = await RecommendationHandler.instance.getRecommendations(
                    client,
                    editor,
                    triggerType,
                    config,
                    autoTriggerType,
                    true,
                    page
                )
                if (RecommendationHandler.instance.checkAndResetCancellationTokens()) {
                    RecommendationHandler.instance.reportUserDecisions(-1)
                    await vscode.commands.executeCommand('aws.amazonq.refreshStatusBar')
                    if (triggerType === 'OnDemand' && session.recommendations.length === 0) {
                        void showTimedMessage(response.errorMessage ? response.errorMessage : noSuggestions, 2000)
                    }
                    return {
                        result: 'Failed',
                        errorMessage: 'cancelled',
                        recommendationCount: 0,
                    }
                }
                if (!RecommendationHandler.instance.hasNextToken()) {
                    break
                }
                page++
            }
        } catch (error) {
            getLogger().error(`Error ${error} in getPaginatedRecommendation`)
        }
        await vscode.commands.executeCommand('aws.amazonq.refreshStatusBar')
        if (triggerType === 'OnDemand' && session.recommendations.length === 0) {
            void showTimedMessage(response.errorMessage ? response.errorMessage : noSuggestions, 2000)
        }
        TelemetryHelper.instance.tryRecordClientComponentLatency()

        return {
            result: 'Succeeded',
            errorMessage: undefined,
            recommendationCount: session.recommendations.length,
        }
    }