public static async Task GetReviewContentAsync()

in src/dotnet/APIView/APIViewWeb/Helpers/PageModelHelpers.cs [245:375]
110 lines of code
15 McCabe index (conditional complexity)

        public static async Task<ReviewContentModel> GetReviewContentAsync(
            IConfiguration configuration, IReviewManager reviewManager, UserPreferenceCache preferenceCache,
            ICosmosUserProfileRepository userProfileRepository, IAPIRevisionsManager reviewRevisionsManager, ICommentsManager commentManager,
            IBlobCodeFileRepository codeFileRepository, IHubContext<SignalRHub> signalRHubContext, ClaimsPrincipal user, ReviewListItemModel review = null, string reviewId = null,
            string revisionId = null, string diffRevisionId = null, bool showDocumentation = false, bool showDiffOnly = false, int diffContextSize = 3,
            string diffContextSeperator = "<br><span>.....</span><br>")
        {
            var reviewPageContent = new ReviewContentModel()
            {
                Directive = ReviewContentModelDirective.ProceedWithPageLoad
            };

            var userId = user.GetGitHubLogin();
            if (review == null)
            {
                review = await reviewManager.GetReviewAsync(user, reviewId);
            }
           
            if (review == null)
            {
                reviewPageContent.Directive = ReviewContentModelDirective.TryGetlegacyReview;
                return reviewPageContent;
            }

            var apiRevisions = await reviewRevisionsManager.GetAPIRevisionsAsync(review.Id);

            // Try getting latest Automatic Revision, otherwise get latest of any type or default
            var activeRevision = await reviewRevisionsManager.GetLatestAPIRevisionsAsync(review.Id, apiRevisions, APIRevisionType.Automatic);
            if (activeRevision == null)
            {
                reviewPageContent.Directive = ReviewContentModelDirective.ErrorDueToInvalidAPIRevisonRedirectToIndexPage;
                reviewPageContent.NotificationMessage = $"Review with ID {review.Id} has no valid APIRevisions";
                return reviewPageContent;
            }

            APIRevisionListItemModel diffRevision = null;
            if (!string.IsNullOrEmpty(revisionId)) {
                if (apiRevisions.Where(x => x.Id == revisionId).Any())
                {
                    activeRevision = apiRevisions.First(x => x.Id == revisionId);
                }
                else
                {
                    reviewPageContent.NotificationMessage = $"A revision with ID {revisionId} does not exist for review with id {review.Id}";
                    reviewPageContent.Directive = ReviewContentModelDirective.ErrorDueToInvalidAPIRevisonRedirectToIndexPage;
                    return reviewPageContent;
                }
            }

            if (activeRevision.Files[0].ParserStyle == ParserStyle.Tree)
            {
                reviewPageContent.Directive = ReviewContentModelDirective.RedirectToSPAUI;
                reviewPageContent.ActiveAPIRevision = activeRevision;
                return reviewPageContent;
            }

            var comments = await commentManager.GetReviewCommentsAsync(review.Id);
            var activeRevisionRenderableCodeFile = await codeFileRepository.GetCodeFileAsync(activeRevision.Id, activeRevision.Files[0], activeRevision.Language);
            var activeRevisionReviewCodeFile = activeRevisionRenderableCodeFile.CodeFile;
            var fileDiagnostics = activeRevisionReviewCodeFile.Diagnostics ?? Array.Empty<CodeDiagnostic>();
            var activeRevisionHtmlLines = activeRevisionRenderableCodeFile.Render(showDocumentation: showDocumentation);
            var codeLines = new CodeLineModel[0];
            var getCodeLines = false;



            if (!string.IsNullOrEmpty(diffRevisionId))
            {
                if (apiRevisions.Where(x => x.Id == diffRevisionId).Any())
                {
                    diffRevision = await reviewRevisionsManager.GetAPIRevisionAsync(user, diffRevisionId);
                    var diffRevisionRenderableCodeFile = await codeFileRepository.GetCodeFileAsync(diffRevisionId, diffRevision.Files[0], activeRevision.Language);
                    var diffRevisionHTMLLines = diffRevisionRenderableCodeFile.RenderReadOnly(showDocumentation: showDocumentation);
                    var diffRevisionTextLines = diffRevisionRenderableCodeFile.RenderText(showDocumentation: showDocumentation);

                    var activeRevisionTextLines = activeRevisionRenderableCodeFile.RenderText(showDocumentation: showDocumentation);

                    var diffLines = InlineDiff.Compute(diffRevisionTextLines, activeRevisionTextLines, diffRevisionHTMLLines, activeRevisionHtmlLines);
                    var headingsOfSectionsWithDiff = activeRevision.HeadingsOfSectionsWithDiff.ContainsKey(diffRevision.Id) ? activeRevision.HeadingsOfSectionsWithDiff[diffRevision.Id] : new HashSet<int>();

                    codeLines = CreateLines(diagnostics: fileDiagnostics, lines: diffLines, comments: comments, showDiffOnly: showDiffOnly,
                        reviewDiffContextSize: diffContextSize, diffContextSeparator: diffContextSeperator, headingsOfSectionsWithDiff: headingsOfSectionsWithDiff,
                        language: activeRevision.Language);

                    if (!codeLines.Any())
                    {
                        getCodeLines = true;
                        reviewPageContent.NotificationMessage = $"There is no diff between the two revisions. {activeRevision.Id} : {diffRevisionId}";
                        reviewPageContent.Directive = ReviewContentModelDirective.ErrorDueToInvalidAPIRevisonProceedWithPageLoad;
                    }
                }
                else
                {
                    getCodeLines = true;
                    reviewPageContent.NotificationMessage = $"A diffRevision with ID {diffRevisionId} does not exist for this review.";
                    reviewPageContent.Directive = ReviewContentModelDirective.ErrorDueToInvalidAPIRevisonProceedWithPageLoad;
                }
            }

            if (string.IsNullOrEmpty(diffRevisionId) || getCodeLines)
            {
                codeLines = CreateLines(diagnostics: fileDiagnostics, lines: activeRevisionHtmlLines, comments: comments, language: activeRevision.Language);
            }

            if (codeLines == null || codeLines.Length == 0)
            {
                reviewPageContent.NotificationMessage = $"A revision with ID {activeRevision.Id} has no content.";
                reviewPageContent.Directive = ReviewContentModelDirective.ErrorDueToInvalidAPIRevisonRedirectToIndexPage;
                return reviewPageContent;
            }

            reviewPageContent.codeLines = codeLines;
            reviewPageContent.ActiveConversationsInActiveAPIRevision = ComputeActiveConversationsInActiveRevision(activeRevisionHtmlLines, comments);

            HashSet<string> preferredApprovers = await GetPreferredApprovers(configuration, preferenceCache, userProfileRepository, user, review);

            reviewPageContent.Review = review;
            reviewPageContent.Navigation = activeRevisionRenderableCodeFile.CodeFile.Navigation;
            reviewPageContent.APIRevisions = apiRevisions.OrderByDescending(c => c.CreatedOn);
            reviewPageContent.ActiveAPIRevision = activeRevision;
            reviewPageContent.DiffAPIRevision = diffRevision;
            reviewPageContent.TotalActiveConversations = comments.Threads.Count(t => !t.IsResolved);
            reviewPageContent.HasFatalDiagnostics = fileDiagnostics.Any(d => d.Level == APIView.CodeDiagnosticLevel.Fatal);
            reviewPageContent.ActiveConversationsInActiveAPIRevision = ComputeActiveConversationsInActiveRevision(activeRevisionHtmlLines, comments);
            reviewPageContent.ActiveConversationsInSampleRevisions = comments.Threads.Count(t => t.Comments.FirstOrDefault()?.CommentType == CommentType.SampleRevision);
            reviewPageContent.PreferredApprovers = preferredApprovers;
            reviewPageContent.TaggableUsers = commentManager.GetTaggableUsers();
            reviewPageContent.PageHasLoadableSections = activeRevisionReviewCodeFile.LeafSections?.Any() ?? false;

            return reviewPageContent;
        }