public Response AnalyzeSolution()

in packages/csharp/PortingAssistant/PortingAssistant.Common/Services/AssesmentService.cs [33:162]
117 lines of code
9 McCabe index (conditional complexity)

        public Response<SolutionDetails, string> AnalyzeSolution(AnalyzeSolutionRequest request)
        {
            try
            {
                var startTime = DateTime.Now;
                string tgtFramework = request.settings.TargetFramework;

                var solutionAnalysisResult = _client.AnalyzeSolutionAsync(request.solutionFilePath, request.settings);
                solutionAnalysisResult.Wait();

                if (solutionAnalysisResult.IsCompletedSuccessfully)
                {
                    TelemetryCollectionUtils.CollectSolutionMetrics(solutionAnalysisResult.Result, request, startTime, tgtFramework);
                    solutionAnalysisResult.Result.ProjectAnalysisResults.ForEach(projectAnalysisResult =>
                    {
                        if (projectAnalysisResult == null)
                        {
                            return;
                        }
                        TelemetryCollectionUtils.CollectProjectMetrics(projectAnalysisResult, request, tgtFramework);

                        projectAnalysisResult.PackageAnalysisResults.ToList()
                        .ForEach(p =>
                        {
                            p.Value.ContinueWith(result =>
                            {
                                if (result.IsCompletedSuccessfully)
                                {
                                    TelemetryCollectionUtils.CollectNugetMetrics(result, request, tgtFramework);

                                    _nugetPackageListeners.ForEach(l => l.Invoke(new Response<PackageAnalysisResult, PackageVersionPair>
                                    {
                                        Value = result.Result,
                                        Status = Response<PackageAnalysisResult, PackageVersionPair>.Success()
                                    }));
                                    return;
                                }

                                _nugetPackageListeners.ForEach(l => l.Invoke(new Response<PackageAnalysisResult, PackageVersionPair>
                                {
                                    ErrorValue = p.Key,
                                    Status = Response<PackageAnalysisResult, PackageVersionPair>.Failed(result.Exception)
                                }));
                            });
                        });

                        if (projectAnalysisResult.SourceFileAnalysisResults != null &&
                            projectAnalysisResult.ProjectGuid != null &&
                            projectAnalysisResult.ProjectFilePath != null) {
                            var selectedApis = projectAnalysisResult.SourceFileAnalysisResults.SelectMany(s => s.ApiAnalysisResults);
                            var allActions = projectAnalysisResult.SourceFileAnalysisResults.SelectMany(a => a.RecommendedActions);
                            allActions.ToList().ForEach(action => {
                                    var selectedApi = selectedApis.FirstOrDefault(s => s.CodeEntityDetails.TextSpan.Equals(action.TextSpan));
                                    selectedApi?.Recommendations?.RecommendedActions?.Add(action);
                                });
                            TelemetryCollectionUtils.FileAssessmentCollect(selectedApis, request);
                            }

                        if (projectAnalysisResult.IsBuildFailed)
                        {
                            _apiAnalysisListeners.ForEach(listener =>
                                listener.Invoke(new Response<ProjectApiAnalysisResult, SolutionProject>
                                {
                                    ErrorValue = new SolutionProject
                                    {
                                        ProjectPath = projectAnalysisResult.ProjectFilePath,
                                        SolutionPath = request.solutionFilePath
                                    },
                                    Status = Response<ProjectApiAnalysisResult, SolutionProject>
                                    .Failed(new PortingAssistantClientException($"Errors during compilation in {projectAnalysisResult.ProjectName}.", null))
                                }));

                            return;
                        }

                        _apiAnalysisListeners.ForEach(listener =>
                        {
                            listener.Invoke(new Response<ProjectApiAnalysisResult, SolutionProject>
                            {
                                Value = new ProjectApiAnalysisResult
                                {
                                    Errors = projectAnalysisResult.Errors,
                                    SolutionFile = request.solutionFilePath,
                                    ProjectFile = projectAnalysisResult.ProjectFilePath,
                                    ProjectGuid = projectAnalysisResult.ProjectGuid,
                                    SourceFileAnalysisResults = projectAnalysisResult.SourceFileAnalysisResults
                                },
                                Status = Response<ProjectApiAnalysisResult, SolutionProject>.Success()
                            });
                        });

                        return;
                    });

                    solutionAnalysisResult.Result.FailedProjects.ForEach(projectFilePath =>
                    {
                        _apiAnalysisListeners.ForEach(listener =>
                            listener.Invoke(new Response<ProjectApiAnalysisResult, SolutionProject>
                            {
                                ErrorValue = new SolutionProject
                                {
                                    ProjectPath = projectFilePath,
                                    SolutionPath = request.solutionFilePath
                                },
                                Status = Response<ProjectApiAnalysisResult, SolutionProject>
                                .Failed(new PortingAssistantClientException($"Errors during compilation in {projectFilePath}.", null))
                            }));
                    });

                    return new Response<SolutionDetails, string>
                    {
                        Value = solutionAnalysisResult.Result.SolutionDetails,
                        Status = Response<SolutionDetails, string>.Success()
                    };
                }
                else
                {
                    throw new PortingAssistantClientException($"anaylze solution {request.solutionFilePath} failed", solutionAnalysisResult.Exception);
                }
            }
            catch (Exception ex)
            {
                return new Response<SolutionDetails, string>
                {
                    ErrorValue = request.solutionFilePath,
                    Status = Response<SolutionDetails, string>.Failed(ex)
                };

            }
        }