Método gigante no DocumentService

DocumentService.cs

 public async Task<Document> Update(int id, UpdateDocumentMutation mutation)
        {
            var document = _context.Documents
                .Include(d => d.Category)
                .Include(d => d.SuggestedCode)
                .Include(d => d.Revisions)
                    .ThenInclude(r => r.Files)
                .Include(d => d.Revisions)
                    .ThenInclude(r => r.Stages)
                        .ThenInclude(s => s.Stage)
                .Include(d => d.Revisions)
                    .ThenInclude(r => r.StagesResults)
                .Include(d => d.Revisions)
                    .ThenInclude(r => r.RevisionRequestHistory)
                .Include(d => d.Stages)
                    .ThenInclude(s => s.Responsibles)
                .FirstOrDefault(d => d.Id == id);
            var category = _context.Categories
                .Include(c => c.Stages)
                    .ThenInclude(s => s.Stage)
                .FirstOrDefault(c => c.Id == mutation.Category);

            #region UpdateFile
            var lastRevision = document.GetLastRevision();
            var lastCycleFile = lastRevision.GetLastCycleFile();
            if (mutation.File != null)
            {
                if (lastCycleFile == null)
                {
                    lastCycleFile = new File() { Cycle = lastRevision.GetLastCycle() };
                    lastRevision.Files.Add(lastCycleFile);
                }
                lastCycleFile.Name = mutation.File.Name;
                lastCycleFile.Path = mutation.File.Path;
            }
            else if (lastRevision != null && lastRevision.Stages.Count() == 0 && lastCycleFile != null)
            {
                lastRevision.Files.Remove(lastCycleFile);
            }
            #endregion

            #region UpdateStages
            var documentStagesIds = document.Stages.Select(s => s.StageId);
            var mutationStagesIds = mutation.Stages.Select(s => s.Id);
            var removedStagesIds = documentStagesIds.Except(mutationStagesIds).ToList();
            var addedStagesIds = mutationStagesIds.Except(documentStagesIds).ToList();
            foreach (var removedStageId in removedStagesIds)
            {
                var removedStage = document.Stages.First(s => s.StageId == removedStageId);
                document.Stages.Remove(removedStage);
            }
            foreach (var addedStageId in addedStagesIds)
            {
                var mutationStage = mutation.Stages.First(s => s.Id == addedStageId);
                var responsibles = mutationStage.Responsibles
                    .Select(r => new DocumentStageResponsible() { ResponsibleId = r })
                    .ToList();
                var stage = new DocumentStage()
                {
                    Responsibles = responsibles,
                    StageId = mutationStage.Id
                };
                document.Stages.Add(stage);
            }
            #endregion

            #region UpdatePendencies
            var currentStage = lastRevision.GetCurrentStage();
            var currentStageCreationDate = lastRevision.GetCurrentStageCreationDate();
            var lastCycle = lastRevision.GetLastCycle();

            foreach (var categoryStage in category.Stages)
            {
                var stage = document.Stages.FirstOrDefault(s => s.StageId == categoryStage.StageId);
                var mutationStage = mutation.Stages.FirstOrDefault(s => s.Id == stage.StageId);
                var stageResponsibles = stage.Responsibles.Select(r => r.ResponsibleId).ToList();
                var removedIds = stageResponsibles.Except(mutationStage.Responsibles);
                var addedIds = mutationStage.Responsibles.Except(stageResponsibles);

                foreach (var removedId in removedIds)
                {
                    var removedResponsible = stage.Responsibles.FirstOrDefault(r => r.ResponsibleId == removedId);
                    stage.Responsibles.Remove(removedResponsible);
                }

                foreach (var addedId in addedIds)
                {
                    var addedResponsible = new DocumentStageResponsible() { ResponsibleId = addedId };
                    stage.Responsibles.Add(addedResponsible);
                }

                if (!lastRevision.IsPublished()) 
                {
                    if (categoryStage.StageId == currentStage.Id)
                    {
                        foreach (var removedId in removedIds) 
                        {
                            var result = lastRevision
                                .StagesResults
                                .First(r => r.ResponsibleId == removedId 
                                    && r.Cycle == lastCycle
                                    && r.StageId == categoryStage.StageId);
                            if (result.Approved != true) 
                            {
                                lastRevision.StagesResults.Remove(result);
                            }
                        }

                        foreach (var addedId in addedIds) 
                        {
                            var existingResult = lastRevision
                                .StagesResults
                                .FirstOrDefault(r => r.ResponsibleId == addedId 
                                    && r.Cycle == lastCycle
                                    && r.StageId == categoryStage.StageId);
                            if (existingResult == null) {
                                var result = new StageResult()
                                {
                                    Cycle = lastCycle,
                                    ResponsibleId = addedId,
                                    StageId = categoryStage.StageId,
                                    CreationDate = currentStageCreationDate.Value,
                                };
                                lastRevision.StagesResults.Add(result);
                            }
                        }
                    }
                } else if (categoryStage.Stage.Type == StageType.Elaboration) {
                    var hasChangedElaborator = addedIds.Count() != 0;
                    var newElaboratorId = addedIds.FirstOrDefault();
                    var revisionRequest = lastRevision.GetOpenRevisionRequest();
                    if (hasChangedElaborator && revisionRequest != null)
                    {
                        revisionRequest.ResponsibleId = newElaboratorId;
                        revisionRequest.TransferRejectedBy = null;
                        revisionRequest.TransferRejectionReason = null;
                    }
                }
            }
            #endregion

            document.ProcessId = mutation.Process;
            document.Code = mutation.Code;
            document.CategoryId = mutation.Category;
            document.Title = mutation.Title;

            _business.EnsureCanUpdate(document);

            document.UpdateSuggestedCode();

            #region UpdateStatus
            if (!lastRevision.IsPublished()) 
            {
                var shouldAdvanceStage = lastRevision
                    .GetCurrentStagePendingResults()
                    .Count() == 0;
                
                if (shouldAdvanceStage) 
                {
                    var nextStage = category.NextStage(lastRevision);
                    if (nextStage != null) 
                    {
                        lastRevision.GoToStage(nextStage, false);
                    } else 
                    {
                        lastRevision.Publish();
                    }
                }
            }
            #endregion

            await _context.SaveChangesAsync();
            return document;
        }