using IRaCIS.Core.Domain.Share;
using Microsoft.AspNetCore.Mvc;
using IRaCIS.Core.Application.Service.Reading.Dto;
using MassTransit;
using IRaCIS.Core.Infra.EFCore.Common;
using Panda.DynamicWebApi.Attributes;
using AutoMapper;
using IRaCIS.Core.Application.Contracts;
using IRaCIS.Core.Infrastructure;
using IRaCIS.Core.Application.Service;
using IRaCIS.Core.Application.ViewModel;
using IRaCIS.Core.Application.Interfaces;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Microsoft.Extensions.Caching.Memory;
using IRaCIS.Core.Application.Filter;
using DocumentFormat.OpenXml.Drawing;
using EasyCaching.Core;
using DocumentFormat.OpenXml.Drawing.Charts;
using IRaCIS.Core.Application.Service.ReadingCalculate.Interface;
using AutoMapper.QueryableExtensions;
using IRaCIS.Application.Contracts;
using IRaCIS.Core.Domain.Models;

namespace IRaCIS.Application.Services
{
    /// <summary>
    /// IR影像阅片
    /// </summary>
    [ApiExplorerSettings(GroupName = "Reading")]
    public partial class ReadingImageTaskService : BaseService, IReadingImageTaskService
    {

        private readonly IRepository<NoneDicomStudy> _noneDicomStudyRepository;
        private readonly IRepository<VisitTask> _visitTaskRepository;
        private readonly IRepository<Trial> _trialRepository;
        private readonly IRepository<ReadingTableQuestionAnswer> _readingTableQuestionAnswerRepository;
        private readonly IRepository<ReadingOncologyTaskInfo> _readingOncologyTaskInfoRepository;
        private readonly IVisitTaskHelpeService _visitTaskHelpeService;
        private readonly IVisitTaskService _visitTaskService;
        private readonly IReadingClinicalDataService _readingClinicalDataService;
        private readonly IReadingCalculateService _readingCalculateService;
        private readonly IRepository<SubjectVisit> _subjectVisitRepository;
        private readonly IRepository<Subject> _subjectRepository;
        private readonly IRepository<ReadingGlobalTaskInfo> _readingGlobalTaskInfoRepository;
        private readonly IRepository<ReadingCriterionPage> _readingCriterionPageRepository;
        private readonly IRepository<ReadingTaskRelation> _readingTaskRelationRepository;
        private readonly IRepository<ReadingJudgeInfo> _readingJudgeInfoRepository;
        private readonly IRepository<ReadModule> _readModuleRepository;
        private readonly IRepository<DicomInstance> _dicomInstanceRepository;
        private readonly IRepository<OrganInfo> _organInfoRepository;
        private readonly IRepository<TrialDocument> _trialDocumentRepository;
        private readonly IRepository<User> _userRepository;
        private readonly IEasyCachingProvider _provider;
        private readonly ILuganoCalculateService _luganoCalculateService;
        private readonly IRepository<ReadingCustomTag> _readingCustomTagRepository;
        private readonly IRepository<ReadingTaskQuestionMark> _readingTaskQuestionMarkRepository;
        private readonly IRepository<ReadingSystemCriterionDictionary> _readingCriterionDictionaryRepository;
        private readonly IRepository<ReadingTrialCriterionDictionary> _readingTrialCriterionDictionaryRepository;
        private readonly IRepository<TumorAssessment_RECIST1Point1> _tumorAssessmentRepository;
        private readonly IRepository<ReadingTableAnswerRowInfo> _readingTableAnswerRowInfoRepository;
        private readonly IRepository<ReadingTableQuestionSystem> _readingTableQuestionSystemRepository;
        private readonly IRepository<ReadingTableQuestionTrial> _readingTableQuestionTrialRepository;
        private readonly IRepository<ReadingTaskQuestionAnswer> _readingTaskQuestionAnswerRepository;
        private readonly IRepository<ReadingQuestionCriterionTrial> _readingQuestionCriterionTrialRepository;
        private readonly IRepository<ReadingQuestionCriterionSystem> _readingQuestionCriterionSystemRepository;
        private readonly IRepository<ReadingQuestionSystem> _readingQuestionSystem;
        private readonly IRepository<NoneDicomStudyFile> _noneDicomStudyFileSystem;
        private readonly IGeneralCalculateService _generalCalculateService;
        private readonly IRepository<ReadingQuestionTrial> _readingQuestionTrialRepository;

        private readonly ITrialEmailNoticeConfigService _trialEmailNoticeConfigService;


        public ReadingImageTaskService(
                  IRepository<NoneDicomStudy> noneDicomStudyRepository,
                  IRepository<VisitTask> visitTaskRepository,
                  IRepository<Trial> TrialRepository,
                  IRepository<ReadingTableQuestionAnswer> ReadingTableQuestionAnswerRepository,
                  IRepository<ReadingOncologyTaskInfo> ReadingOncologyTaskInfoRepository,
                  IVisitTaskHelpeService visitTaskHelpeService,
                  IVisitTaskService visitTaskService,
                  IReadingClinicalDataService readingClinicalDataService,
                  IReadingCalculateService readingCalculateService,
                  IRepository<SubjectVisit> subjectVisitRepository,
                  IRepository<Subject> subjectRepository,
                  IRepository<ReadingGlobalTaskInfo> readingGlobalTaskInfoRepository,
                  IRepository<ReadingCriterionPage> readingCriterionPageRepository,
                  IRepository<ReadingTaskRelation> readingTaskRelationRepository,
                  IRepository<ReadingJudgeInfo> readingJudgeInfoRepository,
                  IRepository<ReadModule> readModuleRepository,
                  IRepository<DicomInstance> dicomInstanceRepository,
                  IRepository<OrganInfo> organInfoRepository,
                  IRepository<TrialDocument> trialDocumentRepository,
                  IRepository<User> userRepository,
                  IEasyCachingProvider provider,
                  ILuganoCalculateService luganoCalculateService,
                  IRepository<ReadingCustomTag> readingCustomTagRepository,
                  IRepository<ReadingTaskQuestionMark> readingTaskQuestionMarkRepository,
                  IRepository<ReadingSystemCriterionDictionary> readingCriterionDictionaryRepository,
                  IRepository<ReadingTrialCriterionDictionary> readingTrialCriterionDictionaryRepository,
                  IRepository<TumorAssessment_RECIST1Point1> tumorAssessmentRepository,
                  IRepository<ReadingTableAnswerRowInfo> readingTableAnswerRowInfoRepository,
                  IRepository<ReadingTableQuestionSystem> readingTableQuestionSystemRepository,
                  IRepository<ReadingTableQuestionTrial> readingTableQuestionTrialRepository,
                  IRepository<ReadingTaskQuestionAnswer> readingTaskQuestionAnswerRepository,
                  IRepository<ReadingQuestionCriterionTrial> readingQuestionCriterionTrialRepository,
                  IRepository<ReadingQuestionCriterionSystem> readingQuestionCriterionSystemRepository,
                  IRepository<ReadingQuestionSystem> ReadingQuestionSystem,
                  ITrialEmailNoticeConfigService trialEmailNoticeConfigService,
                  IRepository<NoneDicomStudyFile> noneDicomStudyFileSystem,

                 IGeneralCalculateService generalCalculateService,
          IRepository<ReadingQuestionTrial> readingQuestionTrialRepository
          )
        {
            this._noneDicomStudyRepository = noneDicomStudyRepository;
            this._visitTaskRepository = visitTaskRepository;
            this._trialRepository = TrialRepository;
            this._readingTableQuestionAnswerRepository = ReadingTableQuestionAnswerRepository;
            this._readingOncologyTaskInfoRepository = ReadingOncologyTaskInfoRepository;
            this._visitTaskHelpeService = visitTaskHelpeService;
            this._visitTaskService = visitTaskService;
            this._readingClinicalDataService = readingClinicalDataService;
            this._readingCalculateService = readingCalculateService;
            this._subjectVisitRepository = subjectVisitRepository;
            this._subjectRepository = subjectRepository;
            this._readingGlobalTaskInfoRepository = readingGlobalTaskInfoRepository;
            this._readingCriterionPageRepository = readingCriterionPageRepository;
            this._readingTaskRelationRepository = readingTaskRelationRepository;
            this._readingJudgeInfoRepository = readingJudgeInfoRepository;
            this._readModuleRepository = readModuleRepository;
            this._dicomInstanceRepository = dicomInstanceRepository;
            this._organInfoRepository = organInfoRepository;
            this._trialDocumentRepository = trialDocumentRepository;
            this._userRepository = userRepository;
            this._provider = provider;
            this._luganoCalculateService = luganoCalculateService;
            this._readingCustomTagRepository = readingCustomTagRepository;
            this._readingTaskQuestionMarkRepository = readingTaskQuestionMarkRepository;
            this._readingCriterionDictionaryRepository = readingCriterionDictionaryRepository;
            this._tumorAssessmentRepository = tumorAssessmentRepository;
            this._readingTableAnswerRowInfoRepository = readingTableAnswerRowInfoRepository;
            this._readingTableQuestionSystemRepository = readingTableQuestionSystemRepository;
            this._readingTableQuestionTrialRepository = readingTableQuestionTrialRepository;
            this._readingTaskQuestionAnswerRepository = readingTaskQuestionAnswerRepository;
            this._readingQuestionCriterionTrialRepository = readingQuestionCriterionTrialRepository;
            this._readingQuestionCriterionSystemRepository = readingQuestionCriterionSystemRepository;
            this._readingTrialCriterionDictionaryRepository = readingTrialCriterionDictionaryRepository;

            this._readingQuestionSystem = ReadingQuestionSystem;
            this._noneDicomStudyFileSystem = noneDicomStudyFileSystem;
            this._generalCalculateService = generalCalculateService;
            this._readingQuestionTrialRepository = readingQuestionTrialRepository;
            this._trialEmailNoticeConfigService = trialEmailNoticeConfigService;
        }

        #region 计算

        /// <summary>
        /// 获取阅片的计算数据
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<object> GetReadingCalculationData(GetReadingCalculationDataInDto inDto)
        {
            return await _readingCalculateService.GetReadingCalculationData(inDto);

        }
        #endregion

        /// <summary>
        /// 获取既往病灶的OtherPicture
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<GetPreviousOtherPicturePathOutDto>> GetPreviousOtherPicturePath(GetPreviousOtherPicturePathInDto inDto)
        {
            List<GetPreviousOtherPicturePathOutDto> result = new List<GetPreviousOtherPicturePathOutDto>() { };

            if (inDto.RowId != null)
            {
                var rowinfo = await _readingTableAnswerRowInfoRepository.Where(x => x.Id == inDto.RowId).FirstNotNullAsync();
                var taskInfoList = await _generalCalculateService.GetReadingReportTaskList(rowinfo.VisitTaskId);
                var visitTaskIds = taskInfoList.Where(x => x.VisitTaskId != rowinfo.VisitTaskId).Select(x => x.VisitTaskId).ToList();
                result = await _readingTableAnswerRowInfoRepository.Where(x => x.QuestionId == rowinfo.QuestionId && x.RowIndex == rowinfo.RowIndex && visitTaskIds.Contains(x.VisitTaskId))

                    .OrderBy(x => x.VisitTask.VisitTaskNum).Select(x => new GetPreviousOtherPicturePathOutDto()
                    {
                        VisitTaskId = x.VisitTaskId,
                        PicturePath = x.OtherPicturePath,
                        TaskBlindName = x.VisitTask.TaskBlindName
                    }).ToListAsync();
            }
            else if (inDto.VisitTaskId != null && inDto.QuestionType != null)
            {
                var taskInfoList = await _generalCalculateService.GetReadingReportTaskList(inDto.VisitTaskId.Value);
                var visitTaskIds = taskInfoList.Where(x => x.VisitTaskId != inDto.VisitTaskId.Value).Select(x => x.VisitTaskId).ToList();
                result = await _readingTaskQuestionMarkRepository.Where(x => x.ReadingQuestionTrial.QuestionType == inDto.QuestionType && visitTaskIds.Contains(x.VisitTaskId))

                 .OrderBy(x => x.VisitTask.VisitTaskNum).Select(x => new GetPreviousOtherPicturePathOutDto()
                 {
                     VisitTaskId = x.VisitTaskId,
                     PicturePath = x.OtherPicturePath,
                     TaskBlindName = x.VisitTask.TaskBlindName
                 }).ToListAsync();
            }


            return result.Where(x => x.PicturePath != string.Empty && x.PicturePath != null).ToList();
        }

        /// <summary>
        /// 提交自定义标记
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IResponseOutput> SubmitCustomTag(ReadingCustomTagDto inDto)
        {
            var entity = await _readingCustomTagRepository.InsertOrUpdateAsync(inDto, true);
            return ResponseOutput.Ok(entity.Id.ToString());
        }

        /// <summary>
        /// 删除自定义标记
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpPost("{id:guid}")]
        public async Task<IResponseOutput> DeleteCustomTag(Guid id)
        {
            var success = await _readingCustomTagRepository.DeleteFromQueryAsync(t => t.Id == id, true);
            return ResponseOutput.Ok();
        }


        /// <summary>
        /// 获取自定义标记
        /// </summary>
        /// <param name="inQuery"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<ReadingCustomTagDto>> GetCustomTag(GetCustomTagInDto inQuery)
        {
            var result = await _readingCustomTagRepository.Where(x => x.VisitTaskId == inQuery.VisitTaskId).ProjectTo<ReadingCustomTagDto>(_mapper.ConfigurationProvider).ToListAsync();
            return result;
        }

        /// <summary>
        /// 获取手册
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<GetManualListOutDto>> GetManualList(GetManualListInDto inDto)
        {
            UserTypeEnum userType = (UserTypeEnum)_userInfo.UserTypeEnumInt;


            List<UserTypeEnum> canViewUserType = new List<UserTypeEnum>()
            {
                UserTypeEnum.IndependentReviewer,
                UserTypeEnum.IQC,

            };

            return await _trialDocumentRepository.Where(x => x.TrialId == inDto.TrialId
            && x.TrialDocConfirmedUserList.Any(y => y.ConfirmUserId == _userInfo.Id && y.ConfirmTime != null)
            && x.NeedConfirmedUserTypeList.Any(y => y.NeedConfirmUserTypeId == _userInfo.UserTypeId))
            .WhereIf(userType == UserTypeEnum.IndependentReviewer, t => t.FileType.Code == "2" || t.FileType.Code == "6")
            .WhereIf(userType == UserTypeEnum.IQC, t => t.FileType.Code == "4" || t.FileType.Code == "5")
            .WhereIf(!canViewUserType.Contains(userType), t => false)
             .IgnoreQueryFilters()
                   .Select(x => new GetManualListOutDto()
                   {
                       Id = x.Id,
                       Name = x.Name,
                       Path = x.Path
                   }).ToListAsync();
        }

        /// <summary>
        /// 获取任务附加问题
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<(List<TrialAdditionaQuestion>, bool)> GetTaskAdditionalQuestion(GetTaskAdditionalQuestionInDto inDto)
        {

            var answerList = await _readingTaskQuestionAnswerRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId).IgnoreAutoIncludes().ToListAsync();
            var taskInfo = await _visitTaskRepository.Where(x => inDto.VisitTaskId == x.Id).FirstNotNullAsync();
            var result = await _readingQuestionTrialRepository.Where(x => x.IsAdditional && x.ReadingQuestionCriterionTrialId == taskInfo.TrialReadingCriterionId).IgnoreAutoIncludes().IgnoreQueryFilters().ProjectTo<TrialAdditionaQuestion>(_mapper.ConfigurationProvider).OrderBy(x => x.ShowOrder).ToListAsync();

            result.ForEach(x =>
            {

                var answer = answerList.Where(y => y.ReadingQuestionTrialId == x.Id).FirstOrDefault();
                if (answer != null)
                {
                    x.Answer = answer.Answer;
                }
            });


            var resultData = result.Where(x => x.Type == "group").ToList();

            resultData.ForEach(x =>
            {
                x.Childrens = result.Where(y => y.GroupId == x.Id).ToList();

            });


            return (resultData, true);
        }


        /// <summary>
        /// 提交附加问题
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<bool> SubmitTaskAdditionalQuestion(SubmitTaskAdditionalQuestionInDto inDto)
        {
            var taskInfo = await _visitTaskRepository.Where(x => inDto.VisitTaskId == x.Id).FirstNotNullAsync();
            var questionids = inDto.AnswerList.Select(x => x.QuestionId).ToList();
            await _readingTaskQuestionAnswerRepository.BatchDeleteNoTrackingAsync(x => x.VisitTaskId == inDto.VisitTaskId && questionids.Contains(x.ReadingQuestionTrialId));

            await _readingTaskQuestionAnswerRepository.AddRangeAsync(inDto.AnswerList.Select(x => new ReadingTaskQuestionAnswer()
            {
                VisitTaskId = inDto.VisitTaskId,
                ReadingQuestionCriterionTrialId = taskInfo.TrialReadingCriterionId,
                Answer = x.Answer,
                ReadingQuestionTrialId = x.QuestionId,
                TrialId = taskInfo.TrialId,
                SubjectId = taskInfo.SubjectId
            }).ToList());

            return await _readingTaskQuestionAnswerRepository.SaveChangesAsync();

        }

        /// <summary>
        /// 维护任务关系
        /// </summary>
        /// <returns></returns>
        public async Task MaintainTaskRelated()
        {
            List<ReadingTaskRelation> relations = new List<ReadingTaskRelation>();
            var visitList = await _visitTaskRepository.Where(x => x.PastResultTaskIds != "[]" && x.RelatedVisitTaskIds != "[]").Select(x => new
            {
                x.Id,
                x.RelatedVisitTaskIds,
                x.PastResultTaskIds
            }).ToListAsync();


            List<Guid> relatedIds = new List<Guid>();

            List<Guid> PastResultds = new List<Guid>();

            foreach (var item in visitList)
            {
                try
                {
                    PastResultds = JsonConvert.DeserializeObject<List<Guid>>(item.PastResultTaskIds) ?? new List<Guid>();
                }
                catch (Exception)
                {

                    PastResultds = new List<Guid>();
                }

                try
                {
                    relatedIds = JsonConvert.DeserializeObject<List<Guid>>(item.RelatedVisitTaskIds) ?? new List<Guid>();
                }
                catch (Exception)
                {

                    relatedIds = new List<Guid>();
                }

                relations.AddRange(PastResultds.Select(x => new ReadingTaskRelation()
                {

                    RelevanceTaskId = x,
                    TaskId = item.Id,
                    RelevanceType = RelevanceType.PastResult,
                }));

                relations.AddRange(relatedIds.Select(x => new ReadingTaskRelation()
                {

                    RelevanceTaskId = x,
                    TaskId = item.Id,
                    RelevanceType = RelevanceType.Related,
                }));

                await _readingTaskRelationRepository.BatchDeleteNoTrackingAsync(x => x.TaskId == item.Id);

            }

            await _readingTaskRelationRepository.AddRangeAsync(relations);
            await _readingTaskRelationRepository.SaveChangesAsync();
        }



        /// <summary>
        /// 修改计算问题
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        [TypeFilter(typeof(TrialResourceFilter), Arguments = new object[] { "AfterStopCannNotOpt" })]
        public async Task ChangeCalculationAnswer(ChangeCalculationAnswerInDto inDto)
        {
            var visitTask = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).FirstNotNullAsync();

            var questionAnswerList = await _readingTaskQuestionAnswerRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId).ToListAsync();

            var tableQuestionAnswerList = await _readingTableQuestionAnswerRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId).ToListAsync();

            var rowInfoList = await _readingTableAnswerRowInfoRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId).ToListAsync();


            foreach (var item in inDto.QuestionAnswer)
            {
                if (questionAnswerList.Any(x => x.ReadingQuestionTrialId == item.QuestionId))
                {
                    await _readingTaskQuestionAnswerRepository.UpdatePartialFromQueryAsync(x => x.VisitTaskId == inDto.VisitTaskId && x.ReadingQuestionTrialId == item.QuestionId, x => new ReadingTaskQuestionAnswer()
                    {
                        Answer = item.Answer,
                    });
                }
                else
                {
                    await _readingTaskQuestionAnswerRepository.AddAsync(new ReadingTaskQuestionAnswer()
                    {
                        Answer = item.Answer,
                        ReadingQuestionCriterionTrialId = visitTask.TrialReadingCriterionId,
                        ReadingQuestionTrialId = item.QuestionId,
                        SubjectId = visitTask.SubjectId,
                        VisitTaskId = inDto.VisitTaskId,
                        TrialId = visitTask.TrialId
                    });
                }


            }

            foreach (var item in inDto.TableQuestionAnswer)
            {

                if (tableQuestionAnswerList.Any(x => x.QuestionId == item.QuestionId && x.RowId == item.RowId && x.TableQuestionId == item.TableQuestionId))
                {
                    await _readingTableQuestionAnswerRepository.UpdatePartialFromQueryAsync(x => x.VisitTaskId == inDto.VisitTaskId && x.RowId == item.RowId && x.TableQuestionId == item.TableQuestionId, x => new ReadingTableQuestionAnswer()
                    {
                        Answer = item.Answer,
                    });
                }
                else
                {

                    var rowInfo = rowInfoList.Where(x => x.Id == item.RowId).FirstOrDefault() ?? new ReadingTableAnswerRowInfo();

                    await _readingTableQuestionAnswerRepository.AddAsync(new ReadingTableQuestionAnswer()
                    {
                        Answer = item.Answer,
                        QuestionId = item.QuestionId,
                        TableQuestionId = item.TableQuestionId,
                        RowIndex = rowInfo.RowIndex,
                        RowId = rowInfo.Id,
                        VisitTaskId = inDto.VisitTaskId,
                        TrialId = visitTask.TrialId
                    });
                }


            }

            await _readingTableQuestionAnswerRepository.SaveChangesAsync();
        }

        /// <summary>
        /// 阅读临床数据
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        [TypeFilter(typeof(TrialResourceFilter), Arguments = new object[] { "AfterStopCannNotOpt" })]
        public async Task ReadClinicalData(ReadClinicalDataInDto inDto)
        {
            await _visitTaskRepository.UpdatePartialFromQueryAsync(inDto.VisitTaskId, x => new VisitTask
            {
                IsReadClinicalData = true
            });
            await _visitTaskRepository.SaveChangesAsync();
        }

        /// <summary>
        /// 添加默认值到任务里面
        /// </summary>
        /// <returns></returns>
        [NonDynamicMethod]
        public async Task AddDefaultValueToTask(Guid visitTaskId)
        {
            var visitTaskInfo = await _visitTaskRepository.Where(x => x.Id == visitTaskId).FirstNotNullAsync();

            var questions = await _readingQuestionTrialRepository.Where(x => x.ReadingQuestionCriterionTrialId == visitTaskInfo.TrialReadingCriterionId).ToListAsync();
            questions = questions.Where(x => !x.DefaultValue.IsNullOrEmpty()).ToList();

            var taskAnswerIds = await _readingTaskQuestionAnswerRepository.Where(x => x.VisitTaskId == visitTaskId).Select(x => x.ReadingQuestionTrialId).ToListAsync();
            questions = questions.Where(x => !taskAnswerIds.Contains(x.Id)).ToList();

            List<ReadingTaskQuestionAnswer> questionAnswers = questions.Select(x => new ReadingTaskQuestionAnswer()
            {

                Answer = x.DefaultValue,
                Id = NewId.NextGuid(),
                ReadingQuestionCriterionTrialId = visitTaskInfo.TrialReadingCriterionId,
                ReadingQuestionTrialId = x.Id,
                SubjectId = visitTaskInfo.SubjectId,
                TrialId = visitTaskInfo.TrialId,
                VisitTaskId = visitTaskId,

            }).ToList();

            await _readingTaskQuestionAnswerRepository.AddRangeAsync(questionAnswers);
            await _readingTaskQuestionAnswerRepository.SaveChangesAsync();

        }


        #region 阅片页面   关联信息查询 以及基本验证

        /// <summary>
        /// 根据任务ID获取ReadingTool
        /// </summary>
        /// <param name="indto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<GetReadingToolOutDto> GetReadingTool(GetReadingToolInDto indto)
        {
            var visitTaskInfo = await _visitTaskRepository.Where(x => x.Id == indto.VisitTaskId).FirstNotNullAsync();

            var criterionTrialInfo = await _readingQuestionCriterionTrialRepository.Where(x => x.Id == visitTaskInfo.TrialReadingCriterionId).FirstNotNullAsync();
            GetReadingToolOutDto result = new GetReadingToolOutDto()
            {
                TrialReadingCriterionId = visitTaskInfo.TrialReadingCriterionId,
                ReadingTool = criterionTrialInfo.ReadingTool,
                CriterionType = criterionTrialInfo.CriterionType,
            };

            return result;
        }

        /// <summary>
        /// 获取关联的阅片任务
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<(List<GetRelatedVisitTaskOutDto>, object)> GetRelatedVisitTask(GetRelatedVisitTaskInDto inDto)
        {
            var taskInfo = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).Include(x => x.TrialReadingCriterion).FirstNotNullAsync();
            var baselineVisitId = await _subjectVisitRepository.Where(x => x.SubjectId == taskInfo.SubjectId && x.IsBaseLine && !x.IsLostVisit).Select(x => x.Id).FirstNotNullAsync();


            var taskQuery = _visitTaskRepository.Where(x =>
           (x.TrialId == taskInfo.TrialId &&
           x.SubjectId == taskInfo.SubjectId &&
           x.ArmEnum == taskInfo.ArmEnum &&
           x.DoctorUserId == taskInfo.DoctorUserId &&
           x.ReadingTaskState == ReadingTaskState.HaveSigned &&
           x.TrialReadingCriterionId == taskInfo.TrialReadingCriterionId &&
           x.TaskState == TaskState.Effect &&
           x.VisitTaskNum <= taskInfo.VisitTaskNum &&
           x.IsAnalysisCreate == taskInfo.IsAnalysisCreate &&
           x.ReadingCategory == ReadingCategory.Visit) || x.Id == inDto.VisitTaskId);

            if (taskInfo.ReadingTaskState == ReadingTaskState.HaveSigned)
            {
                taskQuery = _visitTaskRepository.Where(x => taskInfo.RelatedVisitTaskIdList.Contains(x.Id) || x.Id == taskInfo.Id);
            }

            var result = await taskQuery.Include(x => x.Subject).OrderBy(x => x.VisitTaskNum).ThenBy(x => x.TaskState)
                .Select(x => new GetRelatedVisitTaskOutDto()
                {
                    TaskBlindName = x.TaskBlindName,
                    TaskName = x.TaskName,
                    ReadingTaskState = x.ReadingTaskState,
                    VisitId = x.SourceSubjectVisitId,
                    SubjectCode = x.Subject.Code,
                    VisitTaskId = x.Id,
                    VisitTaskNum = x.VisitTaskNum,
                    IsBaseLineTask = x.SourceSubjectVisitId == baselineVisitId,
                    IsCurrentTask = x.Id == inDto.VisitTaskId,
                    IsConvertedTask = x.IsConvertedTask,
                    IsFirstChangeTask = x.BeforeConvertedTaskId != null,

                }).ToListAsync();


            if (taskInfo.TrialReadingCriterion.IsReadingTaskViewInOrder != ReadingOrder.InOrder)
            {
                result = result.Where(x => x.VisitTaskId == inDto.VisitTaskId).ToList();
            }


            var visitaskIds = result.Select(x => x.VisitTaskId).ToList();

            var otherStudys = await _readingTableAnswerRowInfoRepository.Where(x => visitaskIds.Contains(x.VisitTaskId))
                .Where(x => x.CTSeriesId != null && x.PTSeriesId != null)
                .Select(x => new
                {
                    x.OtherStudyId,
                    x.CTSeriesId,
                    x.PTSeriesId,
                    x.VisitTaskId,
                    x.UpdateTime
                }).ToListAsync();


            foreach (var item in result)
            {
                var clinicalDataList = await _readingClinicalDataService.GetClinicalDataList(new GetReadingOrTaskClinicalDataListInDto()
                {

                    SubjectId = taskInfo.SubjectId,
                    TrialId = taskInfo.TrialId,
                    VisitTaskId = item.VisitTaskId,
                });

                item.IsExistsClinicalData = clinicalDataList.Count > 0;
                var otherStudy = otherStudys.Where(x => x.VisitTaskId == item.VisitTaskId).OrderByDescending(x => x.UpdateTime).FirstOrDefault();
                if (otherStudy != null)
                {
                    item.PTSeriesId = otherStudy.PTSeriesId;
                    item.CTSeriesId = otherStudy.CTSeriesId;
                    item.OtherStudyId = otherStudy.OtherStudyId;
                }

            }




            return (result, new
            {
                ReadingTaskState = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).Select(x => x.ReadingTaskState).FirstOrDefaultAsync()
            });
        }

        /// <summary>
        /// 获取既往任务名称和编号
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<GetReadingPastResultListOutDto>> GetReadingPastResultList(GetReadingPastResultListInDto inDto)
        {
            var taskInfo = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).FirstNotNullAsync();

            var taskQuery = _visitTaskRepository.Where(x =>
              x.TrialId == taskInfo.TrialId &&
              x.SubjectId == taskInfo.SubjectId &&
              x.VisitTaskNum < taskInfo.VisitTaskNum &&
              x.ArmEnum == taskInfo.ArmEnum &&
              x.Id != inDto.VisitTaskId &&
              x.DoctorUserId == taskInfo.DoctorUserId &&
              x.TrialReadingCriterionId == taskInfo.TrialReadingCriterionId &&
              x.ReadingTaskState == ReadingTaskState.HaveSigned &&
              x.TaskState == TaskState.Effect &&
              x.IsSelfAnalysis == taskInfo.IsSelfAnalysis &&
              x.IsAnalysisCreate == taskInfo.IsAnalysisCreate &&
              x.ReadingCategory == taskInfo.ReadingCategory
            );

            if (taskInfo.ReadingTaskState == ReadingTaskState.HaveSigned)
            {
                taskQuery = _visitTaskRepository.Where(x => taskInfo.PastResultTaskIdList.Contains(x.Id));
            }

            var readingPastResultList = await taskQuery.OrderBy(x => x.VisitTaskNum).ThenBy(x => x.TaskState).Select(x => new GetReadingPastResultListOutDto()
            {

                VisitTaskId = x.Id,
                TaskBlindName = x.TaskBlindName,
                TaskName = x.TaskName,
                ReadModuleVisitId = x.ReadModule != null ? x.ReadModule.SubjectVisitId : null,
                VisitName = x.SourceSubjectVisit != null ? x.SourceSubjectVisit.VisitName : x.ReadModule == null ? string.Empty : x.ReadModule.SubjectVisit.VisitName,
                VisitBlindName = x.TaskBlindName,
                VisitTaskNum = x.VisitTaskNum,
                JudgeResultArm = x.JudgeResultTask == null ? null : x.JudgeResultTask.ArmEnum,

            }).ToListAsync();


            foreach (var item in readingPastResultList)
            {
                if (item.ReadModuleVisitId != null)
                {
                    item.VisitBlindName = (await _visitTaskRepository.Where(x => x.SourceSubjectVisitId == item.ReadModuleVisitId && x.IsSelfAnalysis == taskInfo.IsSelfAnalysis &&
              x.IsAnalysisCreate == taskInfo.IsAnalysisCreate).Select(x => x.TaskBlindName).FirstOrDefaultAsync()) ?? string.Empty;

                }
            }


            return readingPastResultList;
        }

        /// <summary>
        /// 获取阅片的受试者信息
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<GetReadingSubjectInfoOutDto> GetReadingSubjectInfo(GetReadingSubjectInfoInDto inDto)
        {
            var visitTask = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).FirstNotNullAsync();
            var subjectCode = await _subjectRepository.Where(x => x.Id == visitTask.SubjectId).Select(x => x.Code).FirstOrDefaultAsync();

            var criterionInfo = await _readingQuestionCriterionTrialRepository.Where(x => x.Id == visitTask.TrialReadingCriterionId).Select(x => new
            {
                x.IsReadingShowPreviousResults,
                x.IsReadingShowSubjectInfo
            }).FirstNotNullAsync();
            var trialInfo = await _trialRepository.Where(x => x.Id == visitTask.TrialId).Select(x => new
            {
                x.ClinicalInformationTransmissionEnum,
            }).FirstOrDefaultAsync();

            return new GetReadingSubjectInfoOutDto()
            {
                VisitTaskId = visitTask.Id,
                SubjectId = visitTask.SubjectId,
                SubjectCode = visitTask.BlindSubjectCode.IsNullOrEmpty() ? subjectCode ?? string.Empty : visitTask.BlindSubjectCode,
                ReadingCategory = visitTask.ReadingCategory,
                TaskBlindName = visitTask.TaskBlindName,
                IsReadingShowPreviousResults = criterionInfo.IsReadingShowPreviousResults,
                IsReadingShowSubjectInfo = criterionInfo.IsReadingShowSubjectInfo,

            };
        }


        /// <summary>
        /// 验证是否为基线访视任务
        /// </summary>
        /// <param name="visitTaskId"></param>
        /// <returns></returns>
        /// <exception cref="BusinessValidationFailedException"></exception>
        private async Task VerifyIsBaseLineTask(Guid visitTaskId)
        {
            var taskinfo = await _visitTaskRepository.Where(x => x.Id == visitTaskId).FirstNotNullAsync();
            if (taskinfo.ReadingCategory != ReadingCategory.Visit)
            {
                throw new BusinessValidationFailedException(_localizer["ReadingImage_NotVisit"]);
            }

            if (await _subjectVisitRepository.AnyAsync(x => x.Id == taskinfo.SourceSubjectVisitId && x.IsBaseLine))
            {
                throw new BusinessValidationFailedException(_localizer["ReadingImage_CantSplit"]);
            }
        }



        /// <summary>
        /// 验证任务是否签名
        /// </summary>
        /// <param name="visitTaskid"></param>
        /// <returns></returns>
        /// <exception cref="BusinessValidationFailedException"></exception>
        private async Task VerifyTaskIsSign(Guid visitTaskid)
        {
            var taskInfo = await _visitTaskRepository.Where(x => x.Id == visitTaskid).FirstNotNullAsync();

            if (await _visitTaskRepository.AnyAsync(x => x.Id == visitTaskid && x.ReadingTaskState == ReadingTaskState.HaveSigned))
            {
                throw new BusinessValidationFailedException(_localizer["ReadingImage_BeSigned"]);
            }


            if (await _visitTaskRepository.AnyAsync(x => x.Id == visitTaskid && x.TaskState != TaskState.Effect))
            {
                throw new BusinessValidationFailedException(_localizer["ReadingImage_Beinvalid"]);
            }

            if (await _visitTaskRepository.AnyAsync(x => x.TrialReadingCriterionId == taskInfo.TrialReadingCriterionId
            && x.IsAnalysisCreate && taskInfo.IsAnalysisCreate
            && x.SubjectId == taskInfo.SubjectId && x.TaskState == TaskState.Effect &&
            ((x.ReReadingApplyState == ReReadingApplyState.DocotorHaveApplyed && x.DoctorUserId == taskInfo.DoctorUserId) || x.ReReadingApplyState == ReReadingApplyState.TrialGroupHaveApplyed)

            ))
            {
                throw new BusinessValidationFailedException(_localizer["ReadingImage_PresenceReview"]);
            }

        }



        #endregion


        #region 访视任务  - Dicom 阅片 表格问题相关查询



        /// <summary>
        /// 获取DIcom阅片问题答案
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<(List<DicomReadingQuestionAnswer>, object)> GetDicomReadingQuestionAnswer(GetDicomReadingQuestionAnswerInDto inDto)
        {
            //await AddDefaultValueToTask(inDto.VisitTaskId);
            var taskInfo = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).FirstNotNullAsync();
            var result = await GetReadingQuestion(taskInfo.TrialReadingCriterionId, taskInfo.Id, inDto.QuestionClassify, inDto.GroupClassifyList);



            return (result, new
            {
                QuestionMarkInfoList = await _readingTaskQuestionMarkRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId).ProjectTo<QuestionMarkInfo>(_mapper.ConfigurationProvider).ToListAsync(),
                ReadingTaskState = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).Select(x => x.ReadingTaskState).FirstOrDefaultAsync()
            });
        }

        /// <summary>
        /// 获取阅片外层问题
        /// </summary>
        /// <param name="trialReadingCriterionId"></param>
        /// <param name="visitTaskId"></param>
        /// <param name="questionClassify"></param>
        /// <param name="groupClassifyList"></param>
        /// <returns></returns>
        [NonDynamicMethod]
        public async Task<List<DicomReadingQuestionAnswer>> GetReadingQuestion(Guid trialReadingCriterionId, Guid? visitTaskId, QuestionClassify? questionClassify, List<GroupClassify>? groupClassifyList)
        {


            var criterionIdInfo = await _readingQuestionCriterionTrialRepository.Where(x => x.Id == trialReadingCriterionId).FirstNotNullAsync();


            //排除表格问题
            var questions = await _readingQuestionTrialRepository
                .WhereIf(questionClassify != null, x => x.QuestionClassify == questionClassify)
                .WhereIf(criterionIdInfo.IseCRFShowInDicomReading, x => x.ReadingQuestionCriterionTrialId == trialReadingCriterionId && x.Type != ReadingQestionType.Table)
                .WhereIf(!criterionIdInfo.IseCRFShowInDicomReading, x => x.IsShowInDicom && x.ReadingQuestionCriterionTrialId == trialReadingCriterionId && x.Type != ReadingQestionType.Table)

                .ProjectTo<DicomReadingQuestionAnswer>(_mapper.ConfigurationProvider, new
                {
                    isEn_Us = _userInfo.IsEn_Us

                }).OrderBy(x => x.ShowOrder).ToListAsync();


            var answers = new List<ReadingTaskQuestionAnswer>();

            if (visitTaskId != null)
            {
                answers = await _readingTaskQuestionAnswerRepository.Where(x => x.VisitTaskId == visitTaskId).ToListAsync();

                var taskinfo = await _visitTaskRepository.Where(x => x.Id == visitTaskId).ProjectTo<VisitTaskDto>(_mapper.ConfigurationProvider).FirstNotNullAsync();

                if (taskinfo.VisitTaskNum == 0)
                {
                    questions = questions.Where(x => x.LimitShow == LimitShow.AllShow || x.LimitShow == LimitShow.BaseLineShow).ToList();

                }
                else
                {
                    questions = questions.Where(x => x.LimitShow == LimitShow.AllShow || x.LimitShow == LimitShow.FollowShow).ToList();
                }

                questions.ForEach(x =>
                {
                    x.CrterionDictionaryGroup = ReadingCommon.GetCrterionDictionaryGroup(taskinfo.IsConvertedTask);
                });

                if (taskinfo.IsConvertedTask && taskinfo.BeforeConvertedTaskId != null)
                {
                    questions.ForEach(x =>
                    {
                        x.IsFirstChangeTask = true;
                    });
                }
            }
            else
            {
                var crterionDictionaryGroup = new List<CrterionDictionaryGroup>() { CrterionDictionaryGroup.General, CrterionDictionaryGroup.BeforeConvert };
                questions.ForEach(x =>
                {
                    x.CrterionDictionaryGroup = crterionDictionaryGroup;
                });
            }


            //排除表格问题 同时排除组问题
            var groupids = questions.Where(x => x.Type != ReadingQestionType.Group).Select(x => x.GroupId).ToList();

            var result = questions.Where(x => x.Type == ReadingQestionType.Group && groupids.Contains(x.Id))
                .WhereIf(groupClassifyList != null, x => x.GroupClassify != null && groupClassifyList != null && groupClassifyList.Contains(x.GroupClassify.Value))
                .ToList();

            foreach (var item in result)
            {
                GetDicomReadingAnswer(item, questions, answers);
            }

            return result;
        }

        private void GetDicomReadingAnswer(DicomReadingQuestionAnswer item, List<DicomReadingQuestionAnswer> questions, List<ReadingTaskQuestionAnswer> answers)
        {
            var answer = answers.Where(x => x.ReadingQuestionTrialId == item.Id).Select(x => x.Answer).FirstIsNullReturnEmpty();
            item.Answer = answer.IsNullOrEmpty() ? item.DefaultValue : answer;


            item.Childrens = questions.Where(x => x.ParentId == item.Id || (x.GroupId == item.Id && x.ParentId == null)).ToList();
            if (item.Childrens != null && item.Childrens.Count > 0)
            {
                foreach (var question in item.Childrens)
                {
                    GetDicomReadingAnswer(question, questions, answers);
                }
            }

        }

        /// <summary>
        /// 获取阅片报告
        /// </summary>
        /// <param name="indto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<GetReadingReportEvaluationOutDto> GetReadingReportEvaluation(GetReadingReportEvaluationInDto indto)
        {
            return await _readingCalculateService.GetReadingReportEvaluation(indto);
        }

        /// <summary>
        /// 获取表格答案行信息 
        /// </summary>
        /// <param name="inDto"></param>
        /// <remarks>
        /// (QuestionId) 可为空
        /// </remarks>
        /// <returns></returns>
        [HttpGet]
        public async Task<List<GetTableAnswerRowInfoOutDto>> GetTableAnswerRowInfoList(GetTableAnswerRowInfoInDto inDto)
        {

            var result = await _readingTableAnswerRowInfoRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId)
                .WhereIf(inDto.QuestionId != null, x => x.QuestionId == inDto.QuestionId)
                .ProjectTo<GetTableAnswerRowInfoOutDto>(_mapper.ConfigurationProvider).OrderBy(x => x.ShowOrder).ThenBy(x => x.RowIndex)
                .ToListAsync();





            var taskInfo = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).ProjectTo<VisitTaskDto>(_mapper.ConfigurationProvider).FirstNotNullAsync();

            if (taskInfo.IsConvertedTask && taskInfo.BeforeConvertedTaskId != null)
            {
                result.ForEach(x =>
                {
                    x.IsFirstChangeTask = true;
                });

            }

            result.ForEach(x =>
            {

                x.OrderMarkName = x.OrderMark + x.RowIndexNum.GetLesionMark();
            });

            var questionMark = await _readingTaskQuestionMarkRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId).ProjectTo<GetTableAnswerRowInfoOutDto>(_mapper.ConfigurationProvider).ToListAsync();


            questionMark.ForEach(x =>
            {

                x.IsFirstChangeTask = x.VisitTaskId == inDto.VisitTaskId;
            });
            result.AddRange(questionMark);
            return result;
        }

        /// <summary>
        /// 获取表格问题及答案（2022-08-26）
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<(GetReadingQuestionAndAnswerOutDto, object)> GetReadingQuestionAndAnswer(GetReadingQuestionAndAnswerInDto inDto)
        {

            //await AddDefaultValueToTask(inDto.VisitTaskId);
            var result = new GetReadingQuestionAndAnswerOutDto();

            var taskinfo = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).FirstNotNullAsync();

            var criterionInfo = await _readingQuestionCriterionTrialRepository.Where(x => x.Id == taskinfo.TrialReadingCriterionId).FirstNotNullAsync();

            result.ReadingTaskState = taskinfo.ReadingTaskState;
            var baseLineVisitId = await _subjectVisitRepository.Where(x => x.SubjectId == taskinfo.SubjectId && x.IsBaseLine).Select(x => x.Id).FirstOrDefaultAsync();

            result.IsBaseLineTask = taskinfo.SourceSubjectVisitId == baseLineVisitId;

            var visitTaskInfo = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).FirstNotNullAsync();


            var tableAnswers = await _readingTableQuestionAnswerRepository
                  .ProjectTo<ReadingTableQuestionAnswerInfo>(_mapper.ConfigurationProvider)
                .Where(x => x.VisitTaskId == inDto.VisitTaskId).ToListAsync();

            var tableAnsweRowInfos = await _readingTableAnswerRowInfoRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId).ProjectTo<TableAnsweRowInfo>(_mapper.ConfigurationProvider).ToListAsync();

            var organIds = tableAnsweRowInfos.Where(x => x.OrganInfoId != null).Select(x => x.OrganInfoId).Distinct().ToList();
            var organList = await _organInfoRepository.Where(x => organIds.Contains(x.Id)).ToListAsync();
            var questionPage = await GetReadingTableQuestion(

                new GetReadingTableQuestionOrAnswerInDto()
                {

                    TrialReadingCriterionId = taskinfo.TrialReadingCriterionId,
                    TaskId = inDto.VisitTaskId,
                    TableAnswers = tableAnswers,
                    TableAnsweRowInfos = tableAnsweRowInfos,
                    OrganInfos = organList,
                    QuestionClassify = inDto.QuestionClassify,
                }


                );

            result.SinglePage = questionPage.SinglePage;
            result.MultiPage = questionPage.MultiPage;
            result.PublicPage = questionPage.PublicPage;
            result.BlindName = visitTaskInfo.TaskBlindName;
            result.TaskNum = visitTaskInfo.VisitTaskNum;
            result.QuestionMarkInfoList = await _readingTaskQuestionMarkRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId).ProjectTo<QuestionMarkInfo>(_mapper.ConfigurationProvider)
            .ToListAsync();
            var spleenLength = await _readingTaskQuestionAnswerRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId && x.ReadingQuestionTrial.QuestionType == QuestionType.SpleenLength).Select(x => x.Answer).FirstOrDefaultAsync();

            return (result, new
            {
                readingTaskState = visitTaskInfo.ReadingTaskState,
                FormType = criterionInfo.FormType,
                TaskNum = visitTaskInfo.VisitTaskNum,
                SpleenLength = spleenLength,

            }); ;
        }

        /// <summary>
        /// 获取自定义问题以及答案
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<(GetReadingTableQuestionOutDto, object)> GetCustomTableQuestionAnswer(GetCustomTableQuestionAnswerInDto inDto)
        {

            //await _readingCalculateService.AddTaskLesionAnswerFromLastTask(new AddTaskLesionAnswerFromLastTaskInDto() { 
            //VisitTaskId=inDto.VisitTaskId
            //});
            var taskInfo = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).Include(x => x.SourceSubjectVisit).FirstNotNullAsync();

            var tableAnswers = await _readingTableQuestionAnswerRepository
              .ProjectTo<ReadingTableQuestionAnswerInfo>(_mapper.ConfigurationProvider)
            .Where(x => x.VisitTaskId == inDto.VisitTaskId).ToListAsync();

            var tableAnsweRowInfos = await _readingTableAnswerRowInfoRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId).ProjectTo<TableAnsweRowInfo>(_mapper.ConfigurationProvider).ToListAsync();

            var organIds = tableAnsweRowInfos.Where(x => x.OrganInfoId != null).Select(x => x.OrganInfoId).Distinct().ToList();
            var organList = await _organInfoRepository.Where(x => organIds.Contains(x.Id)).ToListAsync();
            return (await this.GetReadingTableQuestion(
                new GetReadingTableQuestionOrAnswerInDto()
                {
                    TrialReadingCriterionId = taskInfo.TrialReadingCriterionId,
                    TaskId = taskInfo.Id,
                    TableAnswers = tableAnswers,
                    TableAnsweRowInfos = tableAnsweRowInfos,
                    IsGetallQuestion = true,
                    OrganInfos = organList,
                    QuestionClassify = inDto.QuestionClassify,

                }
              ), new
              {
                  IsBaseline = taskInfo.SourceSubjectVisit != null && taskInfo.SourceSubjectVisit.IsBaseLine,
                  ReadingTaskState = taskInfo.ReadingTaskState
              });

        }

        /// <summary>
        /// 获取表格问题及答案  只返回表格问题(任务和标准)
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [NonDynamicMethod]
        public async Task<GetReadingTableQuestionOutDto> GetReadingTableQuestion(GetReadingTableQuestionOrAnswerInDto inDto)
        {
            var criterionInfo = await _readingQuestionCriterionTrialRepository.Where(x => x.Id == inDto.TrialReadingCriterionId).FirstNotNullAsync();

            var qusetionList = await _readingQuestionTrialRepository
                .WhereIf(inDto.QuestionClassify != null, x => x.QuestionClassify == inDto.QuestionClassify)
                .Where(x => x.ReadingQuestionCriterionTrialId == inDto.TrialReadingCriterionId).ProjectTo<TrialReadQuestionData>(_mapper.ConfigurationProvider, new
                {

                    isEn_Us = _userInfo.IsEn_Us

                }).OrderBy(x => x.ShowOrder).ToListAsync();
            var taskInfo = new VisitTaskDto();
            if (inDto.TaskId != null)
            {
                taskInfo = await _visitTaskRepository.Where(x => x.Id == inDto.TaskId).ProjectTo<VisitTaskDto>(_mapper.ConfigurationProvider).FirstNotNullAsync();
                if (taskInfo.VisitTaskNum == 0)
                {
                    qusetionList = qusetionList.Where(x => x.LimitShow == LimitShow.AllShow || x.LimitShow == LimitShow.BaseLineShow).ToList();

                }
                else
                {
                    qusetionList = qusetionList.Where(x => x.LimitShow == LimitShow.AllShow || x.LimitShow == LimitShow.FollowShow).ToList();
                }


                qusetionList.ForEach(x =>
                {
                    x.CrterionDictionaryGroup = ReadingCommon.GetCrterionDictionaryGroup(taskInfo.IsConvertedTask);
                });
            }
            else
            {
                qusetionList.ForEach(x =>
                {

                    x.CrterionDictionaryGroup = new List<CrterionDictionaryGroup>() { CrterionDictionaryGroup.General, CrterionDictionaryGroup.BeforeConvert };
                });
            }

            //是否是预览
            if (inDto.IsGetPreview == false)
            {
                // 是否获取所有问题
                if (inDto.IsGetallQuestion)
                {
                    if (!criterionInfo.IseCRFShowInDicomReading)
                    {
                        qusetionList = qusetionList.Where(x => x.IsShowInDicom).OrderBy(x => x.ShowOrder).ToList();
                    }
                }
                else
                {
                    if (!criterionInfo.IseCRFShowInDicomReading)
                    {
                        qusetionList = qusetionList.Where(x => x.IsShowInDicom && (x.Type == ReadingQestionType.Table || x.Type == ReadingQestionType.Group)).OrderBy(x => x.ShowOrder).ToList();
                    }


                    if (inDto.TaskId != null)
                    {
                        if (taskInfo.IsConvertedTask)
                        {
                            qusetionList = qusetionList.Where(x => x.ConvertShowType == ConvertShowType.All || x.ConvertShowType == ConvertShowType.AfterShow).OrderBy(x => x.ShowOrder).ToList();
                        }
                        else
                        {
                            qusetionList = qusetionList.Where(x => x.ConvertShowType == ConvertShowType.All || x.ConvertShowType == ConvertShowType.BeforeShow).OrderBy(x => x.ShowOrder).ToList();
                        }

                    }

                    var usedGuropIds = qusetionList.Where(x => x.Type == ReadingQestionType.Table).Select(x => x.GroupId).ToList();
                    qusetionList = qusetionList.Where(x => usedGuropIds.Contains(x.Id) || usedGuropIds.Contains(x.GroupId)).ToList();
                }
            }



            var answers = await _readingTaskQuestionAnswerRepository.Where(x => x.VisitTaskId == inDto.TaskId).ToListAsync();
            qusetionList.ForEach(x =>
            {
                var answer = answers.Where(y => y.ReadingQuestionTrialId == x.Id).Select(x => x.Answer).FirstOrDefault() ?? string.Empty;
                x.Answer = answer.IsNullOrEmpty() ? x.DefaultValue : answer;
            });

            #endregion

            var groupList = new List<TrialReadQuestionData>();
            var qusetionIds = qusetionList.Select(x => x.Id).ToList();

            var tableQuestionList = await _readingTableQuestionTrialRepository
                   .WhereIf(inDto.QuestionClassify != null, x => x.QuestionClassify == inDto.QuestionClassify)
                .Where(x => qusetionIds.Contains(x.ReadingQuestionId))
                .ProjectTo<TableQuestionTrial>(_mapper.ConfigurationProvider, new
                {

                    isEn_Us = _userInfo.IsEn_Us
                })
               .OrderBy(x => x.ShowOrder).ToListAsync();

            var result = new GetReadingTableQuestionOutDto();


            List<ReadingTableQuestionAnswer> baseLineTableAnswer = new List<ReadingTableQuestionAnswer>();
            List<ReadingTableQuestionAnswer> lastTaskTableAnswer = new List<ReadingTableQuestionAnswer>();
            bool isFirstChangeTask = false;

            if (inDto.TaskId != null)
            {
                taskInfo = await _visitTaskRepository.Where(x => x.Id == inDto.TaskId).ProjectTo<VisitTaskDto>(_mapper.ConfigurationProvider).FirstNotNullAsync();
                // 取基线
                var baseLineVisitId = await _subjectVisitRepository.Where(x => x.SubjectId == taskInfo.SubjectId && x.IsBaseLine).Select(x => x.Id).FirstNotNullAsync();

                var baselineTaskId = await _visitTaskRepository.Where(x => x.SourceSubjectVisitId == baseLineVisitId
                  && x.ArmEnum == taskInfo.ArmEnum
                  && x.DoctorUserId == taskInfo.DoctorUserId
                  && x.IsAnalysisCreate == taskInfo.IsAnalysisCreate
                  && x.TaskState == TaskState.Effect
                  && x.TrialReadingCriterionId == taskInfo.TrialReadingCriterionId
                ).Select(x => x.Id).FirstNotNullAsync();
                baseLineTableAnswer = await _readingTableQuestionAnswerRepository.Where(x => x.VisitTaskId == baselineTaskId).Include(x => x.ReadingTableQuestionTrial).ToListAsync();


                var laskTaskId = await _visitTaskRepository.Where(x =>
                (x.SubjectId == taskInfo.SubjectId && x.TaskState == TaskState.Effect
               && x.IsAnalysisCreate == taskInfo.IsAnalysisCreate
               && x.DoctorUserId == taskInfo.DoctorUserId
               && x.IsSelfAnalysis == taskInfo.IsSelfAnalysis
               && x.VisitTaskNum < taskInfo.VisitTaskNum
               && x.ArmEnum == taskInfo.ArmEnum
               && x.TrialReadingCriterionId == taskInfo.TrialReadingCriterionId
               && x.ReadingCategory == ReadingCategory.Visit) || x.Id == taskInfo.BeforeConvertedTaskId
                ).OrderByDescending(x => x.VisitTaskNum).Select(x => x.Id).FirstOrDefaultAsync();
                if (criterionInfo.IsReadingTaskViewInOrder != ReadingOrder.InOrder)
                {
                    // 无序的话 不要查
                    laskTaskId = Guid.NewGuid();
                }

                lastTaskTableAnswer = await _readingTableQuestionAnswerRepository.Where(x => x.VisitTaskId == laskTaskId).Include(x => x.ReadingTableQuestionTrial).ToListAsync();


                if (taskInfo.BeforeConvertedTaskId != null)
                {
                    isFirstChangeTask = true;


                }
            }
            if (criterionInfo.FormType == FormType.MultiplePage)
            {
                qusetionList = qusetionList.Where(x => x.ReadingCriterionPageId != null).ToList();
                var readingCriterionPageIds = qusetionList.OrderBy(x => x.PageShowOrder).Select(x => x.ReadingCriterionPageId).Distinct().ToList();
                foreach (var item in readingCriterionPageIds)
                {
                    var newPageQusetionList = qusetionList.Where(x => x.ReadingCriterionPageId == item).ToList();
                    var firstData = newPageQusetionList.FirstOrDefault();
                    var page = new TrialReadQuestionData()
                    {
                        PageName = firstData!.PageName,
                        IsPage = true,
                        IsPublicPage = firstData.IsPublicPage,
                    };

                    var pageGroupList = newPageQusetionList.Where(x => x.Type == ReadingQestionType.Group).ToList();
                    pageGroupList.ForEach(x =>
                    {
                        this.FindChildQuestion(x, newPageQusetionList, tableQuestionList, inDto.TableAnswers, inDto.TableAnsweRowInfos, inDto.OrganInfos, baseLineTableAnswer, isFirstChangeTask, lastTaskTableAnswer, inDto.TaskId);
                    });

                    page.Childrens = pageGroupList.Where(x => !(x.Type == ReadingQestionType.Group && x.Childrens.Count == 0)).ToList();
                    groupList.Add(page);
                }

                result.PublicPage = groupList.Where(x => x.IsPublicPage!.Value).ToList();
                result.MultiPage = groupList.Where(x => !x.IsPublicPage!.Value).ToList();
            }
            else
            {
                qusetionList = qusetionList.Where(x => x.ReadingCriterionPageId == null).ToList();

                groupList = qusetionList.Where(x => x.Type == ReadingQestionType.Group).ToList();
                groupList.ForEach(x =>
                {
                    this.FindChildQuestion(x, qusetionList, tableQuestionList, inDto.TableAnswers, inDto.TableAnsweRowInfos, inDto.OrganInfos, baseLineTableAnswer, isFirstChangeTask, lastTaskTableAnswer, inDto.TaskId);
                });

                groupList = groupList.Where(x => !(x.Type == ReadingQestionType.Group && x.Childrens.Count == 0)).ToList();

                result.SinglePage = groupList;


            }


            return result;
        }

        /// <summary>
        ///  获取子元素
        /// </summary>
        /// <param name="item"></param>
        /// <param name="questionlists"></param>
        /// <param name="tableQuestionLists"></param>
        /// <param name="tableAnswers"></param>
        /// <param name="tableAnsweRowInfos"></param>
        /// <param name="organInfos"></param>
        /// <param name="baseLineTableAnswer"></param>
        /// <param name="isFirstChangeTask"></param>
        /// <param name="lastTaskTableAnswer"></param>
        /// <param name="TaskId"></param>
        private async void FindChildQuestion(TrialReadQuestionData item, List<TrialReadQuestionData> questionlists, List<TableQuestionTrial> tableQuestionLists, List<ReadingTableQuestionAnswerInfo> tableAnswers, List<TableAnsweRowInfo> tableAnsweRowInfos, List<OrganInfo> organInfos, List<ReadingTableQuestionAnswer> baseLineTableAnswer, bool isFirstChangeTask, List<ReadingTableQuestionAnswer> lastTaskTableAnswer, Guid? TaskId)
        {
            item.Childrens = questionlists.Where(x => x.ParentId == item.Id || (x.GroupId == item.Id && x.ParentId == null)).ToList();
            item.TableQuestions = new TrialReadTableQuestion();

            item.TableQuestions.Questions = tableQuestionLists.Where(x => x.ReadingQuestionId == item.Id).OrderBy(x => x.ShowOrder).ToList();

            item.TableQuestions.Questions.ForEach(x =>
            {

                x.RelationQuestions = tableQuestionLists.Where(z => (z.DependParentId ?? default(Guid)) == x.Id).Select(x => new GetTrialReadingQuestionOutDto
                {
                    Childrens = new List<GetTrialReadingQuestionOutDto>(),
                    ShowOrder = x.ShowOrder,
                    GroupName = string.Empty,
                    Id = x.Id,
                    DictionaryCode = x.DictionaryCode,
                    Type = x.Type,
                    TableQuestionType = x.TableQuestionType,
                    DependParentId = x.DependParentId,
                    IsDepend = x.IsDepend,
                    QuestionMark = x.QuestionMark,
                    TypeValue = x.TypeValue,
                    RelevanceId = x.RelevanceId,
                    RelevanceValue = x.RelevanceValue,
                    ImageCount = 0,
                    ParentId = item.Id,
                    DataTableColumn = x.DataTableColumn,
                    LesionType = item.LesionType,
                    QuestionName = x.QuestionName.LanguageName(x.QuestionEnName, _userInfo.IsEn_Us),
                    RelationQuestions = new List<GetTrialReadingQuestionOutDto>(),
                    Remark = x.Remark,
                    ValueType = x.ValueType,
                    Unit = x.Unit,
                }).ToList();
            });

            var thisAnswer = tableAnswers.Where(x => x.QuestionId == item.Id).ToList();
            var orders = thisAnswer.Select(x => x.RowIndex).Distinct().OrderBy(x => x).ToList();
            item.TableQuestions.Answers = new List<Dictionary<string, string>>();


            var needChangeType = new List<QuestionMark?>() {
                QuestionMark.Organ,
                QuestionMark.Location,
                QuestionMark.Part,
            };

            foreach (var x in orders)
            {
                Dictionary<string, string> answers = new Dictionary<string, string>();
                var rowInfo = tableAnsweRowInfos.First(y => y.RowIndex == x && y.QuestionId == item.Id);
                if (rowInfo == null)
                {
                    continue;
                }

                var rowAnswer = thisAnswer.Where(y => y.RowId == rowInfo.Id).OrderBy(y => y.ShowOrder).ToList();

                var organInfo = organInfos.Where(x => x.Id == rowInfo.OrganInfoId).FirstOrDefault();

                rowAnswer.ForEach(z =>
                {

                    if (organInfo != null && needChangeType.Contains(z.QuestionMark))
                    {
                        if (_userInfo.IsEn_Us)
                        {
                            switch (z.QuestionMark)
                            {
                                case QuestionMark.Organ:
                                    answers.Add(z.TableQuestionId.ToString(), organInfo.TULOCEN);

                                    break;
                                case QuestionMark.Location:
                                    if (organInfo.IsCanEditPosition)
                                    {
                                        answers.Add(z.TableQuestionId.ToString(), z.Answer);
                                    }
                                    else
                                    {
                                        answers.Add(z.TableQuestionId.ToString(), organInfo.TULATEN);

                                    }
                                    break;
                                case QuestionMark.Part:
                                    answers.Add(z.TableQuestionId.ToString(), organInfo.PartEN);
                                    break;

                            }

                        }
                        else
                        {
                            switch (z.QuestionMark)
                            {
                                case QuestionMark.Organ:
                                    answers.Add(z.TableQuestionId.ToString(), organInfo.TULOC);
                                    break;
                                case QuestionMark.Location:
                                    if (organInfo.IsCanEditPosition)
                                    {
                                        answers.Add(z.TableQuestionId.ToString(), z.Answer);
                                    }
                                    else
                                    {
                                        answers.Add(z.TableQuestionId.ToString(), organInfo.TULAT);

                                    }
                                    break;
                                case QuestionMark.Part:
                                    answers.Add(z.TableQuestionId.ToString(), organInfo.Part);
                                    break;

                            }
                        }

                    }
                    else
                    {
                        answers.Add(z.TableQuestionId.ToString(), z.Answer);
                    }

                });


                answers.Add("LesionType", rowInfo.LesionType.GetEnumNullInt());
                answers.Add("BlindName", rowInfo.BlindName);
                answers.Add("IsFirstChangeTask", isFirstChangeTask.ToString());
                answers.Add("FromMark", rowInfo.FromMark);
                answers.Add("IsDicomReading", rowInfo.IsDicomReading.ToString());
                answers.Add("MeasureData", rowInfo == null ? string.Empty : rowInfo.MeasureData);
                answers.Add("OtherMeasureData", rowInfo == null || rowInfo.OtherMeasureData == null ? string.Empty : rowInfo.OtherMeasureData.ToString());
                answers.Add("OtherStudyId", rowInfo == null || rowInfo.OtherStudyId == null ? string.Empty : rowInfo.OtherStudyId.ToString());
                answers.Add("OtherSeriesId", rowInfo == null || rowInfo.OtherSeriesId == null ? string.Empty : rowInfo.OtherSeriesId.ToString());
                answers.Add("OtherInstanceId", rowInfo == null || rowInfo.OtherInstanceId == null ? string.Empty : rowInfo.OtherInstanceId.ToString());
                answers.Add("OtherPicturePath", rowInfo == null || rowInfo.OtherPicturePath == null ? string.Empty : rowInfo.OtherPicturePath.ToString());
                answers.Add("OtherNumberOfFrames", rowInfo == null || rowInfo.OtherNumberOfFrames == null ? string.Empty : rowInfo.OtherNumberOfFrames.ToString());
                answers.Add("OtherMarkTool", rowInfo == null || rowInfo.OtherMarkTool == null ? string.Empty : rowInfo.OtherMarkTool.ToString());
                answers.Add("RowIndex", x.ToString());
                answers.Add("RowId", rowInfo == null ? string.Empty : rowInfo.Id.ToString());
                answers.Add("MarkTool", rowInfo.MarkTool);
                answers.Add("StudyId", rowInfo.StudyId.ToString());
                answers.Add("OrganInfoId", rowInfo.OrganInfoId.ToString());
                answers.Add("IsFristAdd", (rowInfo.FristAddTaskId == TaskId).ToString());
                answers.Add("IsCanEditPosition", rowInfo.IsCanEditPosition.ToString());
                answers.Add("InstanceId", rowInfo == null ? string.Empty : rowInfo.InstanceId.ToString());
                answers.Add("PTSeriesId", rowInfo == null ? string.Empty : rowInfo.PTSeriesId.ToString());
                answers.Add("CTSeriesId", rowInfo == null ? string.Empty : rowInfo.CTSeriesId.ToString());
                answers.Add("SeriesId", rowInfo == null ? string.Empty : rowInfo.SeriesId.ToString());
                answers.Add("IsCurrentTaskAdd", rowInfo == null ? false.ToString() : rowInfo.IsCurrentTaskAdd.ToString());
                answers.Add("SplitOrMergeLesionName", rowInfo == null ? string.Empty : rowInfo.SplitName.IsNullOrEmpty() ? rowInfo.MergeName : rowInfo.SplitName);
                answers.Add("SplitOrMergeType", rowInfo == null ? string.Empty : rowInfo.SplitOrMergeType == null ? string.Empty : ((int)rowInfo.SplitOrMergeType).ToString());
                answers.Add("LastTaskState", lastTaskTableAnswer.Where(n => n.QuestionId == item.Id && n.ReadingTableQuestionTrial.QuestionMark == QuestionMark.State && n.RowIndex == x).Select(n => n.Answer).FirstOrDefault() ?? string.Empty);
                answers.Add("LastTaskMajorAxis", lastTaskTableAnswer.Where(n => n.QuestionId == item.Id && n.ReadingTableQuestionTrial.QuestionMark == QuestionMark.MajorAxis && n.RowIndex == x).Select(n => n.Answer).FirstOrDefault() ?? string.Empty);
                answers.Add("LastTaskShortAxis", lastTaskTableAnswer.Where(n => n.QuestionId == item.Id && n.ReadingTableQuestionTrial.QuestionMark == QuestionMark.ShortAxis && n.RowIndex == x).Select(n => n.Answer).FirstOrDefault() ?? string.Empty);
                if (rowInfo.LesionType == LesionType.BaselineLesions)
                {
                    answers.Add("BaseLineLesionNumber", baseLineTableAnswer.Where(n => n.ReadingTableQuestionTrial.QuestionMark == QuestionMark.LesionNumber && n.RowIndex == rowInfo.RowIndex).Select(x => x.Answer).FirstIsNullReturnEmpty());
                }


                item.TableQuestions.Answers.Add(answers);
            };

            if (item.Childrens != null && item.Childrens.Count != 0)
            {
                item.Childrens.ForEach(x =>
                {
                    this.FindChildQuestion(x, questionlists, tableQuestionLists, tableAnswers, tableAnsweRowInfos, organInfos, baseLineTableAnswer, isFirstChangeTask, lastTaskTableAnswer, TaskId);
                });
            }
        }





        #region 访视任务  - Dicom 阅片 表格问题 病灶的拆分与合并


        /// <summary>
        /// 拆分病灶 分裂病灶
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        [TypeFilter(typeof(TrialResourceFilter), Arguments = new object[] { "AfterStopCannNotOpt" })]
        public async Task SplitLesion(SplitLesionInDto inDto)
        {
            await VerifyTaskIsSign(inDto.VisitTaskId);
            await this.VerifyIsBaseLineTask(inDto.VisitTaskId);
            var taskInfo = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).Include(x => x.TrialReadingCriterion).FirstNotNullAsync();
            var rowAnswer = await _readingTableAnswerRowInfoRepository.Where(x => x.Id == inDto.RowId).AsNoTracking().FirstNotNullAsync();
            var tableAnswers = await _readingTableQuestionAnswerRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId && x.RowIndex == rowAnswer.RowIndex && x.QuestionId == inDto.QuestionId).Include(x => x.ReadingTableQuestionTrial).ProjectTo<TableQuestionAnswerInfo>(_mapper.ConfigurationProvider).ToListAsync();
            var maxRowIndex = await _readingTableAnswerRowInfoRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId && x.QuestionId == inDto.QuestionId && x.RowIndex < Math.Floor(rowAnswer.RowIndex + 1)).OrderByDescending(x => x.RowIndex).Select(x => x.RowIndex).FirstOrDefaultAsync();
            var newRowIndex = maxRowIndex + (decimal)0.01;

            rowAnswer.RowIndex = newRowIndex;
            rowAnswer.MergeRowId = null;
            rowAnswer.FristAddTaskId = inDto.VisitTaskId;
            rowAnswer.SplitOrMergeType = SplitOrMergeType.Split;
            rowAnswer.FromMark = string.Empty;
            rowAnswer.ReportMark = string.Empty;
            rowAnswer.SplitRowId = rowAnswer.Id;
            rowAnswer.Id = NewId.NextGuid();
            rowAnswer.InstanceId = null;
            rowAnswer.SeriesId = null;
            rowAnswer.IsCurrentTaskAdd = true;
            rowAnswer.MeasureData = string.Empty;
            rowAnswer.OtherMeasureData = null;

            List<QuestionMark?> needSaveMark = new List<QuestionMark?>()
            {
                QuestionMark.Organ,
                QuestionMark.Location,
                QuestionMark.Part,
                QuestionMark.IsLymph,
            };

            tableAnswers.ForEach(x =>
            {
                x.Id = NewId.NextGuid();
                x.RowIndex = newRowIndex;
                x.VisitTaskId = inDto.VisitTaskId;
                x.RowId = rowAnswer.Id;
                x.Answer = needSaveMark.Contains(x.QuestionMark) ? x.Answer : string.Empty;
            });

            switch (taskInfo.TrialReadingCriterion.CriterionType)
            {
                case CriterionType.Lugano2014:

                    List<QuestionMark?> needSetNa = new List<QuestionMark?>()
                    {
                        QuestionMark.LowPPDAddPercent,
                        QuestionMark.NadirPPD,
		            	 /// <summary>
                         /// PPD最低点所在访视
                         /// </summary>
                         QuestionMark.LowPPDVisit ,
                     
                         /// <summary>
                         /// PPD最低点LDi
                         /// </summary>
                         QuestionMark.LowPPDLDi,
                     
                         /// <summary>
                         /// PPD最低点SDi
                         /// </summary>
                         QuestionMark.LowPPDSDi,
                     
                         /// <summary>
                         /// 相比最低点PPD增加百分比
                         /// </summary>
                         QuestionMark.LowPPDAddPercent,
                     
                         /// <summary>
                         /// 相比PPD最低点LDi增加值
                         /// </summary>
                         QuestionMark.LowPPDLDiAdded,
                     
                         /// <summary>
                         /// 相比PPD最低点SDi增加值
                         /// </summary>
                         QuestionMark.LowPPDSDiAdded,


                    };
                    tableAnswers.ForEach(x =>
                    {
                        x.Answer = needSetNa.Contains(x.QuestionMark) ? "NA" : x.Answer;
                    });
                    break;
            }
            await _readingTableAnswerRowInfoRepository.AddAsync(rowAnswer);
            await _readingTableQuestionAnswerRepository.AddRangeAsync(_mapper.Map<List<ReadingTableQuestionAnswer>>(tableAnswers));
            await _readingTableAnswerRowInfoRepository.UpdatePartialFromQueryAsync(x => x.Id == inDto.RowId, x => new ReadingTableAnswerRowInfo()
            {
                SplitOrMergeType = SplitOrMergeType.SplitMain
            });

            await _readingTableAnswerRowInfoRepository.SaveChangesAsync();

        }

        /// <summary>
        /// 合并病灶 融合
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public async Task MergeLesion(MergeLesionInDto inDto)
        {
            await VerifyTaskIsSign(inDto.VisitTaskId);
            await this.VerifyIsBaseLineTask(inDto.VisitTaskId);
            var taskinfo = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).Include(x => x.TrialReadingCriterion).FirstNotNullAsync();
            var mergeRow = await _readingTableAnswerRowInfoRepository.Where(x => x.Id == inDto.MergeMainRowId).Include(x => x.ReadingQuestionTrial).FirstNotNullAsync();

            var mark = mergeRow.ReadingQuestionTrial.OrderMark + mergeRow.RowIndex.GetLesionMark();

            await _readingTableQuestionAnswerRepository.BatchUpdateNoTrackingAsync(x => inDto.MergeRowIdList.Contains(x.RowId) && x.ReadingTableQuestionTrial.QuestionMark == QuestionMark.State, x => new ReadingTableQuestionAnswer()
            {
                Answer = TargetState.Loss.GetEnumInt(),
            });

            await _readingTableQuestionAnswerRepository.BatchUpdateNoTrackingAsync(x => inDto.MergeRowIdList.Contains(x.RowId) && (x.ReadingTableQuestionTrial.QuestionMark == QuestionMark.MajorAxis || x.ReadingTableQuestionTrial.QuestionMark == QuestionMark.ShortAxis), x => new ReadingTableQuestionAnswer()
            {
                Answer = "0",
            });


            await _readingTableAnswerRowInfoRepository.UpdatePartialFromQueryAsync(x => inDto.MergeRowIdList.Contains(x.Id), x => new ReadingTableAnswerRowInfo()
            {
                MergeRowId = inDto.MergeMainRowId,
                SplitOrMergeType = SplitOrMergeType.Merge,
            });

            await _readingTableAnswerRowInfoRepository.UpdatePartialFromQueryAsync(inDto.MergeMainRowId, x => new ReadingTableAnswerRowInfo()
            {
                SplitOrMergeType = SplitOrMergeType.MergeMain,
            });
            await _readingTableAnswerRowInfoRepository.SaveChangesAsync();

            await this._readingCalculateService.CalculateTask(new CalculateTaskInDto()
            {
                IsChangeOtherTask = false,
                VisitTaskId = inDto.VisitTaskId,
                ComputationTrigger = ComputationTrigger.MergeLesion,
            });

            // 保存完了计算疾病进展
            switch (taskinfo.TrialReadingCriterion.CriterionType)
            {
                case CriterionType.Lugano2014:
                    await _luganoCalculateService.CalculateMergeTargetLesionStatus(new CalculateTargetLesionStatusInDto()
                    {
                        QuestionId = inDto.QuestionId,
                        VisitTaskId = inDto.VisitTaskId,
                        RowNumber = mergeRow.RowIndex,
                    });
                    break;
            }
        }

        /// <summary>
        /// 获取可合并的病灶
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<GetCanMergeLesionOutDto>> GetCanMergeLesion(GetCanMergeLesionInDto inDto)
        {
            var rowinfo = await _readingTableAnswerRowInfoRepository.Where(x => x.Id == inDto.RowId).Include(x => x.ReadingQuestionTrial).FirstNotNullAsync();

            var taskInfo = await _visitTaskRepository.Where(x => x.Id == rowinfo.VisitTaskId).Include(x => x.TrialReadingCriterion).FirstNotNullAsync();
            // 需要排除的状态
            var needFilterState = new List<string>();

            var query = _readingTableAnswerRowInfoRepository.Where(x => x.VisitTaskId == rowinfo.VisitTaskId && x.QuestionId == rowinfo.QuestionId && x.Id != rowinfo.Id)
              .Where(x => x.SplitOrMergeType != SplitOrMergeType.Split && x.SplitOrMergeType != SplitOrMergeType.SplitMain
              && x.SplitOrMergeType != SplitOrMergeType.Merge && x.SplitOrMergeType != SplitOrMergeType.MergeMain
              && x.SplitOrMergeType != SplitOrMergeType.Merged);

            switch (taskInfo.TrialReadingCriterion.CriterionType)
            {

                case CriterionType.Lugano2014:
                    // (无法评估 或者 状态为消失的非靶病灶） 并且不能是无法评估的病灶
                    query = query.Where(x =>
                    (x.MeasureData == string.Empty ||
                    (x.LesionAnswerList.Any(y => y.ReadingTableQuestionTrial.QuestionMark == QuestionMark.State && y.Answer == TargetState.Loss.GetEnumInt()) &&
                    x.LesionAnswerList.Any(y => y.ReadingTableQuestionTrial.QuestionMark == QuestionMark.IsLymph && y.Answer == ReadingYesOrNo.No.GetEnumInt())
                    )) && !x.LesionAnswerList.Any(y => y.ReadingTableQuestionTrial.QuestionMark == QuestionMark.State && y.Answer == TargetState.UnableEvaluate.GetEnumInt())


                    );

                    break;

            }


            var result = await query
                .Select(x => new GetCanMergeLesionOutDto()
                {
                    RowId = x.Id,
                    RowIndex = x.RowIndex,
                    OrderMarkName = x.ReadingQuestionTrial.OrderMark + x.RowIndex.GetLesionMark(),
                    OrganInfoId = x.OrganInfoId
                }).OrderBy(x => x.RowIndex).ToListAsync();

            var organIds = result.Where(x => x.OrganInfoId != null).Select(x => x.OrganInfoId).Distinct().ToList();
            var organList = await _organInfoRepository.Where(x => organIds.Contains(x.Id)).ToListAsync();

            result.ForEach(x =>
            {

                if (_userInfo.IsEn_Us)
                {
                    x.Part = organList.Where(y => y.Id == x.OrganInfoId).Select(y => y.PartEN).FirstIsNullReturnEmpty();

                }
                else
                {
                    x.Part = organList.Where(y => y.Id == x.OrganInfoId).Select(y => y.Part).FirstIsNullReturnEmpty();
                }
            });

            return result;

        }

        #endregion



        #region 访视任务  - Dicom 阅片 提交、修改

        /// <summary>
        /// 保存影像质量
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]

        [TypeFilter(typeof(TrialResourceFilter), Arguments = new object[] { "AfterStopCannNotOpt" })]
        public async Task<IResponseOutput> SaveImageQuality(ChangeDicomReadingQuestionAnswerInDto inDto)
        {
            inDto.UpdateMark = true;
            return await ChangeDicomReadingQuestionAnswer(inDto);
        }

        /// <summary>
        /// 保存任务问题 带动态稽查参数
        /// </summary>
        /// <param name="inDto"></param>
        /// <param name="param">请求类型</param>
        /// <returns></returns>
        [Route("/SaveTaskQuestion/{param}")]
        [HttpPost]
        public async Task<IResponseOutput> SaveTaskQuestion(ChangeDicomReadingQuestionAnswerInDto inDto, string param)
        {
            var taskinfo = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).Include(x => x.TrialReadingCriterion).FirstNotNullAsync();
            try
            {
                param = param == string.Empty ? "0" : param;

                inDto.ComputationTrigger = (ComputationTrigger)int.Parse(param);
            }
            catch (Exception)
            {

            }
            var result = await this.SaveImageQuality(inDto);

            // 自动计算
            await this._readingCalculateService.CalculateTask(new CalculateTaskInDto()
            {
                IsChangeOtherTask = false,
                VisitTaskId = inDto.VisitTaskId,
                ComputationTrigger = inDto.ComputationTrigger,
            });
            return result;

        }

        ///// <summary>
        ///// 保存ECRF
        ///// </summary>
        ///// <param name="inDto"></param>
        ///// <returns></returns>
        //[HttpPost]
        //public async Task<IResponseOutput> SaveImageQuality(ChangeDicomReadingQuestionAnswerInDto inDto)
        //{
        //    return await ChangeDicomReadingQuestionAnswer(inDto);
        //}


        /// <summary>
        /// 修改肿瘤学评估结果
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        [TypeFilter(typeof(TrialResourceFilter), Arguments = new object[] { "AfterStopCannNotOpt" })]
        public async Task<IResponseOutput> ChangeDicomReadingQuestionAnswer(ChangeDicomReadingQuestionAnswerInDto inDto)
        {
            await VerifyTaskIsSign(inDto.VisitTaskId);



            var taskInfo = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).FirstNotNullAsync();

            var tumorQuestionId = await _readingQuestionTrialRepository.Where(x => x.ReadingQuestionCriterionTrialId == taskInfo.TrialReadingCriterionId && x.QuestionType == QuestionType.Tumor).Select(x => x.Id).FirstOrDefaultAsync();

            var tumorAnswer = inDto.Answers.Where(x => x.Id == tumorQuestionId).FirstOrDefault();
            if (tumorAnswer != null)
            {
                var isConvertedTask = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).Select(x => x.IsConvertedTask).FirstOrDefaultAsync();
                var reportVerify = await _readingCalculateService.GetReportVerify(new GetReportVerifyInDto()
                {
                    BeforeConvertedTaskId = taskInfo.BeforeConvertedTaskId,
                    IsConvertTask = isConvertedTask,
                    VisitTaskId = inDto.VisitTaskId
                });

                if (tumorAnswer.Answer == reportVerify.TumorEvaluate)
                {
                    await _visitTaskRepository.BatchUpdateNoTrackingAsync(x => x.Id == inDto.VisitTaskId, x => new VisitTask()
                    {
                        IsChangeTumorEvaluate = false
                    });
                }
                else
                {
                    await _visitTaskRepository.BatchUpdateNoTrackingAsync(x => x.Id == inDto.VisitTaskId, x => new VisitTask()
                    {
                        IsChangeTumorEvaluate = true
                    });
                }
            }


            var criterionId = taskInfo.TrialReadingCriterionId;
            var questionIds = inDto.Answers.Select(x => x.Id).ToList();
            await _readingTaskQuestionAnswerRepository.BatchDeleteNoTrackingAsync(x => x.VisitTaskId == inDto.VisitTaskId && questionIds.Contains(x.ReadingQuestionTrialId));
            var needAddAnswer = inDto.Answers.Select(x => new ReadingTaskQuestionAnswer()
            {

                Answer = x.Answer,
                SubjectId = taskInfo.SubjectId,
                ReadingQuestionCriterionTrialId = criterionId,
                ReadingQuestionTrialId = x.Id,
                TrialId = taskInfo.TrialId,
                VisitTaskId = inDto.VisitTaskId,

            }).ToList();
            await _readingTaskQuestionAnswerRepository.AddRangeAsync(needAddAnswer);

            if (inDto.UpdateMark)
            {
                var questionMarkList = await _readingTaskQuestionMarkRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId).Select(x => new
                {
                    x.QuestionId,
                    x.FirstAddTaskId,

                }).ToListAsync();

                var markquestionId = inDto.QuestionMarkInfoList.Select(y => y.QuestionId).ToList();

                var needDeleteMarkQuestonIds = inDto.Answers.Where(x => x.Answer == string.Empty).Select(x => x.Id).ToList();


                await _readingTaskQuestionMarkRepository.BatchUpdateNoTrackingAsync(x =>
                (x.QuestionType == QuestionType.SplenicTopPosition || x.QuestionType == QuestionType.SplenicBottomPosition) &&
                x.VisitTaskId == inDto.VisitTaskId && needDeleteMarkQuestonIds.Contains(x.QuestionId), x => new ReadingTaskQuestionMark()
                {
                    PicturePath = string.Empty,
                    MeasureData = string.Empty,
                });

                await _readingTaskQuestionMarkRepository.BatchUpdateNoTrackingAsync(x =>
                (x.QuestionType == QuestionType.LiverSUVmax || x.QuestionType == QuestionType.MediastinumSUVmax) &&
                x.VisitTaskId == inDto.VisitTaskId && needDeleteMarkQuestonIds.Contains(x.QuestionId), x => new ReadingTaskQuestionMark()
                {
                    OtherPicturePath = string.Empty,
                    OtherMeasureData = string.Empty,
                });


                await _readingTaskQuestionMarkRepository.BatchDeleteNoTrackingAsync(x => x.VisitTaskId == inDto.VisitTaskId && markquestionId.Contains(x.QuestionId));

                var datetime = DateTime.Now;

                var markList = _mapper.Map<List<QuestionMarkInfo>, List<ReadingTaskQuestionMark>>(inDto.QuestionMarkInfoList);
                markList.ForEach(x =>
                {
                    x.Id = NewId.NextGuid();
                    x.VisitTaskId = inDto.VisitTaskId;
                    x.CreateTime = datetime;
                    x.FirstAddTaskId = questionMarkList.Where(y => y.QuestionId == x.QuestionId).Select(x => x.FirstAddTaskId).FirstOrDefault() ?? inDto.VisitTaskId;
                });
                await _readingTaskQuestionMarkRepository.AddRangeAsync(markList);
            }


            await _readingTaskQuestionAnswerRepository.SaveChangesAsync();
            return ResponseOutput.Ok(true);
        }






        /// <summary>
        /// 删除表格行数据
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        [TypeFilter(typeof(TrialResourceFilter), Arguments = new object[] { "AfterStopCannNotOpt" })]
        public async Task<IResponseOutput> DeleteReadingRowAnswer(DeleteReadingRowAnswerInDto inDto)
        {
            await VerifyTaskIsSign(inDto.VisitTaskId);

            var taskinfo = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).Include(x => x.TrialReadingCriterion).FirstNotNullAsync();

            var deleteRowInfo = await _readingTableAnswerRowInfoRepository.Where(x => x.Id == inDto.RowId).FirstOrDefaultAsync();

            if (deleteRowInfo == null)
            {
                return ResponseOutput.Ok(true);
            }

            inDto.QuestionId = deleteRowInfo.QuestionId;

            if (await _readingTableAnswerRowInfoRepository.AnyAsync(x => x.SplitRowId == deleteRowInfo.Id && x.MergeRowId == deleteRowInfo.Id))
            {
                throw new BusinessValidationFailedException(_localizer["ReadingImage_DeleteError"]);
            }

            var index = await _readingCalculateService.GetDeleteLesionStatrIndex(inDto);


            await _readingTableQuestionAnswerRepository.BatchUpdateNoTrackingAsync(x => x.RowId == inDto.RowId, x => new ReadingTableQuestionAnswer()
            {

                IsDeleted = true
            });
            if (!(await _readingTableAnswerRowInfoRepository.AnyAsync(x => x.SplitRowId == deleteRowInfo.SplitRowId && x.Id != deleteRowInfo.Id)))
            {
                await _readingTableAnswerRowInfoRepository.BatchUpdateNoTrackingAsync(x => x.Id == deleteRowInfo.SplitRowId, x => new ReadingTableAnswerRowInfo()
                {
                    SplitOrMergeType = null,
                });
            }


            await _readingTableAnswerRowInfoRepository.UpdatePartialFromQueryAsync(x => x.Id == inDto.RowId, x => new ReadingTableAnswerRowInfo()
            {

                IsDeleted = true
            });
            await _readingTableAnswerRowInfoRepository.SaveChangesAsync();


            if (inDto.IsNeedSort)
            {
                var rowInfoList = await _readingTableAnswerRowInfoRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId && x.QuestionId == inDto.QuestionId, true).Include(x => x.ReadingQuestionTrial).OrderBy(x => x.RowIndex).ToListAsync();

                var answerlist = await _readingTableQuestionAnswerRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId && x.QuestionId == inDto.QuestionId, true).ToListAsync();



                foreach (var item in rowInfoList.Where(x => x.RowIndex % 1 == 0))
                {
                    string measureDataStr = string.Empty;
                    if (item.MeasureData != null && item.MeasureData != string.Empty)
                    {
                        dynamic measureData = JObject.Parse(item.MeasureData);
                        measureData.data.remark = item.ReadingQuestionTrial.OrderMark + ((decimal)index).GetLesionMark();
                        measureDataStr = JsonConvert.SerializeObject(measureData);
                    }
                    string? otherMeasureDataStr = null;
                    if (item.OtherMeasureData != null && item.OtherMeasureData != string.Empty)
                    {
                        dynamic otherMeasureData = JObject.Parse(item.OtherMeasureData);
                        otherMeasureData.data.remark = item.ReadingQuestionTrial.OrderMark + ((decimal)index).GetLesionMark();
                        otherMeasureDataStr = JsonConvert.SerializeObject(otherMeasureData);
                    }



                    foreach (var answerItem in answerlist.Where(x => x.RowIndex == item.RowIndex))
                    {

                        answerItem.RowIndex = index;

                    }


                    foreach (var rowAnswerItem in rowInfoList.Where(x => x.RowIndex == item.RowIndex))
                    {

                        rowAnswerItem.RowIndex = index;
                        rowAnswerItem.MeasureData = measureDataStr;
                        rowAnswerItem.OtherMeasureData = otherMeasureDataStr;

                    }

                    //await _readingTableQuestionAnswerRepository.UpdatePartialFromQueryAsync(x => x.VisitTaskId == inDto.VisitTaskId && x.RowIndex == item.RowIndex && x.QuestionId == inDto.QuestionId, x => new ReadingTableQuestionAnswer()
                    //{
                    //    RowIndex = index
                    //});

                    //await _readingTableAnswerRowInfoRepository.UpdatePartialFromQueryAsync(x => x.VisitTaskId == inDto.VisitTaskId && x.RowIndex == item.RowIndex && x.QuestionId == inDto.QuestionId, x => new ReadingTableAnswerRowInfo()
                    //{
                    //    RowIndex = index,
                    //    MeasureData = measureDataStr,
                    //});
                    var spiltList = rowInfoList.Where(x => x.RowIndex % 1 != 0 && x.RowIndex > item.RowIndex && x.RowIndex < Math.Floor(item.RowIndex + 1)).OrderBy(x => x.RowIndex).ToList();
                    decimal spiltindex = 0.01M;
                    foreach (var spiltitem in spiltList)
                    {
                        string spiltmeasureDataStr = string.Empty;
                        if (spiltitem.MeasureData != null && spiltitem.MeasureData != string.Empty)
                        {
                            dynamic spiltmeasureData = JObject.Parse(spiltitem.MeasureData);
                            spiltmeasureData.data.remark = item.ReadingQuestionTrial.OrderMark + ((decimal)index + spiltindex).GetLesionMark();
                            spiltmeasureDataStr = JsonConvert.SerializeObject(spiltmeasureData);
                        }

                        string? spiltOtherMeasureDataStr = null;
                        if (item.OtherMeasureData != null && item.OtherMeasureData != string.Empty)
                        {
                            dynamic otherMeasureData = JObject.Parse(item.OtherMeasureData);
                            otherMeasureData.data.remark = item.ReadingQuestionTrial.OrderMark + ((decimal)index).GetLesionMark();
                            spiltOtherMeasureDataStr = JsonConvert.SerializeObject(otherMeasureData);
                        }
                        foreach (var answerItem in answerlist.Where(x => x.RowIndex == spiltitem.RowIndex))
                        {
                            answerItem.RowIndex = index + spiltindex;

                        }


                        foreach (var rowAnswerItem in rowInfoList.Where(x => x.RowIndex == spiltitem.RowIndex))
                        {

                            rowAnswerItem.RowIndex = index + spiltindex;
                            rowAnswerItem.MeasureData = spiltmeasureDataStr;
                            rowAnswerItem.OtherMeasureData = spiltOtherMeasureDataStr;

                        }


                        //await _readingTableQuestionAnswerRepository.UpdatePartialFromQueryAsync(x => x.VisitTaskId == inDto.VisitTaskId && x.RowIndex == spiltitem.RowIndex && x.QuestionId == inDto.QuestionId, x => new ReadingTableQuestionAnswer()
                        //{
                        //    RowIndex = index + spiltindex
                        //});
                        //await _readingTableAnswerRowInfoRepository.UpdatePartialFromQueryAsync(x => x.VisitTaskId == inDto.VisitTaskId && x.RowIndex == spiltitem.RowIndex && x.QuestionId == inDto.QuestionId, x => new ReadingTableAnswerRowInfo()
                        //{
                        //    RowIndex = index + spiltindex,
                        //    MeasureData = spiltmeasureDataStr,
                        //});

                        spiltindex += 0.01M;
                    }
                    index++;
                }

                await _readingTableAnswerRowInfoRepository.SaveChangesAsync();
            }

            // 自动计算
            await this._readingCalculateService.CalculateTask(new CalculateTaskInDto()
            {
                IsChangeOtherTask = false,
                VisitTaskId = inDto.VisitTaskId,
                ComputationTrigger = ComputationTrigger.RemoveLesion,
            });


            switch (taskinfo.TrialReadingCriterion.CriterionType)
            {
                case CriterionType.Lugano2014:
                    if (deleteRowInfo.RowIndex % 1 != 0)
                    {
                        await _luganoCalculateService.CalculateTargetLesionStatus(new CalculateTargetLesionStatusInDto()
                        {
                            QuestionId = inDto.QuestionId,
                            VisitTaskId = inDto.VisitTaskId,
                            RowNumber = deleteRowInfo.RowIndex
                        });
                    }
                    break;
            }
            return ResponseOutput.Ok(true);
        }


        /// <summary>
        /// 提交表格问题答案  提交病灶 保存病灶
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        [TypeFilter(typeof(TrialResourceFilter), Arguments = new object[] { "AfterStopCannNotOpt" })]
        public async Task<SubmitTableQuestionOutDto> SubmitTableQuestion(SubmitTableQuestionInDto inDto)
        {
            SubmitTableQuestionOutDto result = new SubmitTableQuestionOutDto();
            await VerifyTaskIsSign(inDto.VisitTaskId);
            if (inDto.InstanceId != null && inDto.IsDicomReading)
            {
                if (!(await _dicomInstanceRepository.AnyAsync(x => x.Id == inDto.InstanceId && x.SeriesId == inDto.SeriesId)))
                {
                    throw new BusinessValidationFailedException(_localizer["ReadingImage_Idnotcorrespond"]);
                }
            }
            var taskinfo = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).Include(x => x.TrialReadingCriterion).Include(x => x.SourceSubjectVisit).FirstNotNullAsync();
            inDto.BlindName = taskinfo.TaskBlindName;
            switch (taskinfo.TrialReadingCriterion.CriterionType)
            {
                // 对于非靶病灶，如果状态选择为显著增大，请验证：
                // 1） 对于非淋巴结病灶，验证当前访视该病灶的长径 > 上一访视该病灶的长径。
                // 约束条件：两次访视该病灶的长径有测量值。
                // 提示语：当前访视该非淋巴结病灶的长径小于上一访视的值，不能设置为显著增大。
                // 2） 对于淋巴结病灶，验证当前访视该病灶的短径 > 上一访视该病灶的短径。
                // 约束条件：两次访视该病灶的短径有测量值。
                // 提示语：当前访视该淋巴结病灶的短径小于上一访视的值，不能设置为显著增大。
                case CriterionType.RECIST1Point1:
                    var lastTaskinfo = await _visitTaskRepository
                        .Where(x => x.IsAnalysisCreate == taskinfo.IsAnalysisCreate &&
                        x.SubjectId == taskinfo.SubjectId &&
                            x.ReadingCategory == taskinfo.ReadingCategory &&
                            x.DoctorUserId == taskinfo.DoctorUserId &&
                            x.ArmEnum == taskinfo.ArmEnum &&
                            x.TrialReadingCriterionId == taskinfo.TrialReadingCriterionId &&
                            x.ReadingTaskState == ReadingTaskState.HaveSigned &&
                            x.TaskState == TaskState.Effect &&
                            x.IsSelfAnalysis == taskinfo.IsSelfAnalysis &&
                            x.VisitTaskNum < taskinfo.VisitTaskNum
                            ).OrderByDescending(x => x.VisitTaskNum).FirstOrDefaultAsync();
                    if (lastTaskinfo != null)
                    {
                        var tablequestionList = await _readingTableQuestionTrialRepository.Where(x => x.TrialCriterionId == taskinfo.TrialReadingCriterionId && x.ReadingQuestionTrial.LesionType == LesionType.NonTargetLesions).ToListAsync();

                        // 判断表格问题是否为空
                        if (tablequestionList.Count > 0)
                        {
                            // 找到状态值
                            var stateQuestion = tablequestionList.Where(x => x.QuestionMark == QuestionMark.State).FirstOrDefault();

                            if (stateQuestion != null)
                            {
                                // 判断是否为非靶病灶
                                if (inDto.QuestionId == tablequestionList[0].ReadingQuestionId && inDto.AnswerList.Any(x => x.TableQuestionId == stateQuestion.Id && x.Answer.EqEnum(NoTargetState.Increase)))
                                {
                                    var lymphQuestion = tablequestionList.Where(x => x.QuestionMark == QuestionMark.IsLymph).FirstOrDefault();
                                    if (lymphQuestion != null)
                                    {

                                        // 判断是否是淋巴结
                                        if (inDto.AnswerList.Any(x => x.TableQuestionId == lymphQuestion.Id && x.Answer.EqEnum(YesOrNoOrNa.Yes)))
                                        {
                                            var shortAxisQuestion = tablequestionList.Where(x => x.QuestionMark == QuestionMark.ShortAxis).FirstOrDefault();
                                            if (shortAxisQuestion != null)
                                            {
                                                var lastAnswer = await _readingTableQuestionAnswerRepository.Where(x => x.VisitTaskId == lastTaskinfo.Id && x.TableQuestionId == shortAxisQuestion.Id
                                                  && x.RowIndex == inDto.RowIndex
                                                ).Select(x => x.Answer).FirstOrDefaultAsync();

                                                var thisAnswer = inDto.AnswerList.Where(x => x.TableQuestionId == shortAxisQuestion.Id).Select(x => x.Answer).FirstOrDefault();
                                                if (!lastAnswer.IsNullOrEmpty() && !thisAnswer.IsNullOrEmpty())
                                                {

                                                    var lastvalue = 0m;
                                                    var thisvalue = 0m;
                                                    try
                                                    {
                                                        lastvalue = decimal.Parse(lastAnswer);
                                                        thisvalue = decimal.Parse(thisAnswer);
                                                    }
                                                    catch (Exception)
                                                    {


                                                    }


                                                    if (lastvalue >= thisvalue)
                                                    {
                                                        throw new BusinessValidationFailedException(_localizer["ReadingImage_IsLymphNotbigger"]);
                                                    }


                                                }
                                            }
                                        }
                                        else

                                        {
                                            var majorAxisQuestion = tablequestionList.Where(x => x.QuestionMark == QuestionMark.MajorAxis).FirstOrDefault();
                                            if (majorAxisQuestion != null)
                                            {
                                                var lastAnswer = await _readingTableQuestionAnswerRepository.Where(x => x.VisitTaskId == lastTaskinfo.Id && x.TableQuestionId == majorAxisQuestion.Id
                                                  && x.RowIndex == inDto.RowIndex
                                                ).Select(x => x.Answer).FirstOrDefaultAsync();

                                                var thisAnswer = inDto.AnswerList.Where(x => x.TableQuestionId == majorAxisQuestion.Id).Select(x => x.Answer).FirstOrDefault();
                                                if (!lastAnswer.IsNullOrEmpty() && !thisAnswer.IsNullOrEmpty())
                                                {
                                                    var lastvalue = 0m;
                                                    var thisvalue = 0m;
                                                    try
                                                    {
                                                        lastvalue = decimal.Parse(lastAnswer);
                                                        thisvalue = decimal.Parse(thisAnswer);
                                                    }
                                                    catch (Exception)
                                                    {

                                                    }


                                                    if (lastvalue >= thisvalue)
                                                    {
                                                        throw new BusinessValidationFailedException(_localizer["ReadingImage_NotLymphNotbigger"]);
                                                    }

                                                }
                                            }
                                        }
                                    }


                                }
                            }

                        }

                    }
                    break;
                case CriterionType.Lugano2014:

                    var targetTablequestionList = await _readingTableQuestionTrialRepository.Where(x => x.TrialCriterionId == taskinfo.TrialReadingCriterionId && x.ReadingQuestionTrial.LesionType == LesionType.TargetLesion).ToListAsync();

                    var targetlymphQuestion = targetTablequestionList.Where(x => x.QuestionMark == QuestionMark.IsLymph).FirstOrDefault();

                    // 判断是否存在淋巴结问题
                    if (targetlymphQuestion != null && taskinfo.SourceSubjectVisit.VisitNum == 0)
                    {
                        // 判断是否为淋巴结
                        if (inDto.QuestionId == targetTablequestionList[0].ReadingQuestionId && inDto.AnswerList.Any(x => x.TableQuestionId == targetlymphQuestion.Id && x.Answer.EqEnum(ReadingYesOrNo.No)))
                        {
                            if (await _readingTableQuestionAnswerRepository.CountAsync(x => x.VisitTaskId == inDto.VisitTaskId && x.TableQuestionId == targetlymphQuestion.Id && x.Answer == ReadingYesOrNo.No.GetEnumInt() && x.RowId != inDto.RowId) >= 2)
                            {
                                // 靶病灶只能添加两个非淋巴结病灶
                                throw new BusinessValidationFailedException(_localizer["ReadingImage_LuganoMaxTowNoTarget"]);
                            }

                        }
                    }




                    break;
            }
            var questionInfo = await _readingQuestionTrialRepository.Where(x => x.Id == inDto.QuestionId).FirstNotNullAsync();
            var criterionId = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).Select(x => x.TrialReadingCriterionId).FirstOrDefaultAsync();
            var criterionInfo = await _readingQuestionCriterionTrialRepository.Where(x => x.Id == criterionId).FirstNotNullAsync();
            var tableQuestionIds = inDto.AnswerList.Select(x => x.TableQuestionId).ToList();
            var tableAnswerList = await _readingTableQuestionAnswerRepository.Where(x => x.RowId == inDto.RowId).ToListAsync();
            var tableQuestionIdGroup = tableQuestionIds.GroupBy(x => new { TableQuestionId = x }).Select(x => new TableQuestionData
            {
                TableQuestionId = x.Key.TableQuestionId,
                Count = x.Count()
            }).ToList();
            if (tableQuestionIdGroup.Any(x => x.Count > 1))
            {
                throw new BusinessValidationFailedException(_localizer["ReadingImage_Twice"]);
            }
            if (inDto.RowIndex % 1 == 0)
            {

                if (questionInfo.MaxQuestionCount != null && questionInfo.MaxQuestionCount != 0 && inDto.RowId == null)
                {
                    if (questionInfo.MaxQuestionCount <
                        (
                        (await _readingTableAnswerRowInfoRepository.Where(x => ((x.RowIndex % 1) == 0) && x.VisitTaskId == inDto.VisitTaskId
                       && x.QuestionId == inDto.QuestionId
                    ).CountAsync()) + 1))
                    {
                        throw new BusinessValidationFailedException(_localizer["ReadingImage_MaxQuestion", questionInfo.MaxQuestionCount]);
                    }
                }


                var tableQuestions = await _readingTableQuestionTrialRepository.Where(x => tableQuestionIds.Contains(x.Id) && x.MaxRowCount != null && x.MaxRowCount != 0).ToListAsync();

                List<QuestionMark?> questionMarks = new List<QuestionMark?>()
                {
                    QuestionMark.Part,
                    QuestionMark.Organ,

                };


                string msg = string.Empty;
                foreach (var item in tableQuestions)
                {

                    var answer = inDto.AnswerList.Where(x => x.TableQuestionId == item.Id).Select(x => x.Answer).FirstOrDefault();
                    if (!answer.IsNullOrEmpty())
                    {
                        Dictionary<CriterionType, string> errorMsgDic = new Dictionary<CriterionType, string>()
                            {
                               {CriterionType.RECIST1Point1, _localizer["ReadingImage_Maxlesion", item.MaxRowCount!.Value]},

                                {CriterionType.PCWG3, _localizer["ReadingImage_PCWGMaximum", item.MaxRowCount.Value]},
                            };
                        var rowCount = 0;
                        if ((item.QuestionMark == QuestionMark.Part || item.QuestionMark == QuestionMark.Organ) && inDto.OrganInfoId != null)
                        {
                            var organIds = await _readingTableAnswerRowInfoRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId && x.QuestionId == inDto.QuestionId && ((x.RowIndex % 1) == 0) && x.OrganInfoId != null && x.RowIndex != inDto.RowIndex).Select(x => x.OrganInfoId).ToListAsync();
                            organIds.Add(inDto.OrganInfoId);

                            var orginInfos = await _organInfoRepository.Where(x => organIds.Contains(x.Id)).ToListAsync();

                            List<OrganInfo?> orginInfoList = new List<OrganInfo?>();
                            foreach (var organId in organIds)
                            {
                                orginInfoList.Add(orginInfos.Where(x => x.Id == organId).FirstOrDefault());
                            }

                            var currentOrginInfo = orginInfos.Where(x => x.Id == inDto.OrganInfoId).FirstOrDefault() ?? new OrganInfo();

                            if (item.QuestionMark == QuestionMark.Part)
                            {
                                rowCount = orginInfoList.Where(x => x.Part == currentOrginInfo.Part).Count();
                            }
                            else
                            {
                                rowCount = orginInfoList.Where(x => x.TULOC == currentOrginInfo.TULOC).Count();
                            }

                            if (rowCount > item.MaxRowCount.Value)
                            {
                                if (rowCount > item.MaxRowCount.Value)
                                {


                                    try
                                    {
                                        msg = errorMsgDic[criterionInfo.CriterionType];
                                    }
                                    catch (Exception)
                                    {

                                        msg = _localizer["ReadingImage_Maximum", item.QuestionName.LanguageName(item.QuestionEnName, _userInfo.IsEn_Us), item.MaxRowCount.Value, item.MaxRowCount.Value];
                                    }

                                    throw new BusinessValidationFailedException(msg);
                                }
                            }

                        }

                        else
                        {
                            rowCount = await _readingTableQuestionAnswerRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId && x.TableQuestionId == item.Id && ((x.RowIndex % 1) == 0) && x.Answer == answer && x.RowIndex != inDto.RowIndex).CountAsync();

                            if (rowCount > item.MaxRowCount.Value - 1)
                            {


                                try
                                {
                                    msg = errorMsgDic[criterionInfo.CriterionType];
                                }
                                catch (Exception)
                                {

                                    msg = _localizer["ReadingImage_Maximum", item.QuestionName.LanguageName(item.QuestionEnName, _userInfo.IsEn_Us), item.MaxRowCount.Value, rowCount];
                                }

                                throw new BusinessValidationFailedException(msg);
                            }
                        }



                    }
                }
            }
            var isCurrentTaskAddList = await _readingTableAnswerRowInfoRepository.Where(x => x.Id == (inDto.RowId ?? default(Guid))).Select(x => x.IsCurrentTaskAdd).ToListAsync();
            bool isCurrentTaskAdd = true;
            if (isCurrentTaskAddList.Count > 0)
            {
                isCurrentTaskAdd = isCurrentTaskAddList[0];
            }
            ReadingTableAnswerRowInfo? rowInfo = await _readingTableAnswerRowInfoRepository.Where(x => x.Id == (inDto.RowId ?? default(Guid))).IgnoreAutoIncludes().FirstOrDefaultAsync();
            rowInfo = rowInfo == null ? new ReadingTableAnswerRowInfo() : rowInfo;

            //await _readingTableQuestionAnswerRepository.BatchDeleteNoTrackingAsync(x => x.RowId == (inDto.RowId ?? default(Guid)));
            //await _readingTableAnswerRowInfoRepository.BatchDeleteNoTrackingAsync(x => x.Id == (inDto.RowId ?? default(Guid)));
            _mapper.Map(inDto, rowInfo);
            rowInfo.Id = inDto.RowId == null ? NewId.NextGuid() : inDto.RowId.Value;
            result.RowId = rowInfo.Id;
            rowInfo.IsCurrentTaskAdd = isCurrentTaskAdd;
            rowInfo.FristAddTaskId = inDto.RowId == null ? inDto.VisitTaskId : rowInfo.FristAddTaskId;
            if (inDto.RowId == null)
            {
                rowInfo.FromMark = inDto.FromMark ?? string.Empty;
                rowInfo.ReportMark = inDto.ReportMark ?? string.Empty;
                rowInfo.MarkTool = inDto.MarkTool ?? string.Empty;
                rowInfo.PicturePath = inDto.PicturePath ?? string.Empty;
                rowInfo.MeasureData = inDto.MeasureData ?? string.Empty;
                //await _readingTableAnswerRowInfoRepository.BatchDeleteNoTrackingAsync(x => x.VisitTaskId == inDto.VisitTaskId && x.RowIndex == inDto.RowIndex && x.QuestionId == inDto.QuestionId);

                List<ReadingTableQuestionAnswer> answerList = inDto.AnswerList.Select(x => new ReadingTableQuestionAnswer()
                {
                    Answer = x.Answer,
                    Id = NewId.NextGuid(),
                    TrialId = inDto.TrialId,
                    QuestionId = inDto.QuestionId,
                    TableQuestionId = x.TableQuestionId,
                    RowIndex = inDto.RowIndex,
                    RowId = rowInfo.Id,
                    VisitTaskId = inDto.VisitTaskId
                }).ToList();


                await _readingTableAnswerRowInfoRepository.AddAsync(rowInfo);
                await _readingTableQuestionAnswerRepository.AddRangeAsync(answerList);

            }
            else
            {
                await _readingTableAnswerRowInfoRepository.UpdateFromDTOAsync(inDto);


                foreach (var item in inDto.AnswerList)
                {
                    if (tableAnswerList.Any(x => x.TableQuestionId == item.TableQuestionId))
                    {
                        await _readingTableQuestionAnswerRepository.UpdatePartialFromQueryAsync(x => x.RowId == inDto.RowId && x.TableQuestionId == item.TableQuestionId, x => new ReadingTableQuestionAnswer()
                        {

                            Answer = item.Answer

                        });
                    }
                    else
                    {
                        await _readingTableQuestionAnswerRepository.AddAsync(new ReadingTableQuestionAnswer()
                        {
                            Answer = item.Answer,
                            QuestionId = inDto.QuestionId,
                            TableQuestionId = item.TableQuestionId,
                            RowId = inDto.RowId.Value,
                            TrialId = taskinfo.TrialId,
                            RowIndex = rowInfo.RowIndex,
                            VisitTaskId = inDto.VisitTaskId,
                        });
                    }

                }


            }
            await _readingTableAnswerRowInfoRepository.SaveChangesAsync();
            await this._readingCalculateService.CalculateTask(new CalculateTaskInDto()
            {
                IsChangeOtherTask = false,
                VisitTaskId = inDto.VisitTaskId,
                ComputationTrigger = inDto.ComputationTrigger,
            });

            // 保存完了计算疾病进展
            switch (taskinfo.TrialReadingCriterion.CriterionType)
            {
                case CriterionType.Lugano2014:
                    if (inDto.RowIndex % 1 != 0)
                    {
                        await _luganoCalculateService.CalculateTargetLesionStatus(new CalculateTargetLesionStatusInDto()
                        {
                            QuestionId = inDto.QuestionId,
                            VisitTaskId = inDto.VisitTaskId,
                            RowNumber = inDto.RowIndex
                        });
                    }
                    break;
            }

            return result;
        }



        /// <summary>
        /// 提交Dicom阅片信息
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [TypeFilter(typeof(TrialResourceFilter), Arguments = new object[] { "AfterStopCannNotOpt" })]
        public async Task<IResponseOutput> SubmitDicomVisitTask(SubmitDicomVisitTaskInDto inDto)
        {


            await VerifyTaskIsSign(inDto.VisitTaskId);

            //// 修改编号
            //var taskInfo = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).FirstNotNullAsync();

            //// 获取标准表格外层问题
            //var questionList = await _readingQuestionTrialRepository.Where(x => x.ReadingQuestionCriterionTrialId == taskInfo.TrialReadingCriterionId && x.LesionType != null && x.ReadingTableQuestionTrialList.Any(x => x.QuestionMark == QuestionMark.AutoId))
            //    .SelectMany(x => x.ReadingTableQuestionTrialList).Where(x => x.QuestionMark == QuestionMark.AutoId).Select(x => new
            //    {
            //        x.ReadingQuestionId,
            //        TableQuestionId = x.Id,

            //    }).ToListAsync();

            //var questionIds = questionList.Select(x => x.ReadingQuestionId).ToList();

            //var questionMarkList = await _readingQuestionTrialRepository.Where(x => questionIds.Contains(x.Id)).Select(x => new
            //{
            //    QuestionId = x.Id,
            //    x.OrderMark,

            //}).ToListAsync();

            //var rowInfo = await _readingTableAnswerRowInfoRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId && questionIds.Contains(x.QuestionId)).ToListAsync();
            //List<ReadingTableQuestionAnswer> questionAnswerList = new List<ReadingTableQuestionAnswer>();
            //foreach (var item in questionList)
            //{
            //    await _readingTableQuestionAnswerRepository.BatchDeleteNoTrackingAsync(x => x.QuestionId == item.ReadingQuestionId
            //    && x.TableQuestionId == item.TableQuestionId && x.VisitTaskId == inDto.VisitTaskId);

            //    var orderMark = questionMarkList.Where(x => x.QuestionId == item.ReadingQuestionId).Select(x => x.OrderMark).FirstOrDefault();

            //    foreach (var row in rowInfo.Where(x => x.QuestionId == item.ReadingQuestionId))
            //    {
            //        questionAnswerList.Add(new ReadingTableQuestionAnswer()
            //        {
            //            Answer = orderMark + row.RowIndex.GetLesionMark(),
            //            Id = NewId.NextGuid(),
            //            QuestionId = item.ReadingQuestionId,
            //            RowId = row.Id,
            //            RowIndex = row.RowIndex,
            //            TableQuestionId = item.TableQuestionId,
            //            TrialId = taskInfo.TrialId,
            //            VisitTaskId = taskInfo.Id,

            //        });
            //    }
            //}
            //await _readingTableQuestionAnswerRepository.AddRangeAsync(questionAnswerList);
            //await _readingTableQuestionAnswerRepository.SaveChangesAsync();




            await this.SubmitTaskChangeState(inDto.VisitTaskId);
            return ResponseOutput.Ok(true);
        }




        #endregion


        #region Dicom  非dicom   公用

        /// <summary>
        /// 验证默认问题是否回答
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        /// <exception cref="BusinessValidationFailedException"></exception>
        [HttpPost]
        public async Task<IResponseOutput> VerifyDefaultQuestionBeAnswer(VerifyVisitTaskQuestionsInDto inDto)
        {

            var taskInfo = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).Include(x => x.TrialReadingCriterion).Include(x => x.SourceSubjectVisit).FirstNotNullAsync();

            var criterion = await _readingQuestionCriterionTrialRepository.Where(x => x.Id == taskInfo.TrialReadingCriterionId).FirstNotNullAsync();

            var readingQuestionList = await _readingQuestionTrialRepository.Where(x => x.ReadingQuestionCriterionTrialId == taskInfo.TrialReadingCriterionId)
                .WhereIf(taskInfo.SourceSubjectVisit.IsBaseLine, x => ((x.IsRequired == IsRequired.Required && x.ShowQuestion == ShowQuestion.Show) && (x.LimitEdit == LimitEdit.None || x.LimitEdit == LimitEdit.OnlyBaseLine)))
            .WhereIf(!taskInfo.SourceSubjectVisit.IsBaseLine, x => ((x.IsRequired == IsRequired.Required && x.ShowQuestion == ShowQuestion.Show) && (x.LimitEdit == LimitEdit.None || x.LimitEdit == LimitEdit.OnlyVisit)))
            .WhereIf(taskInfo.TrialReadingCriterion.CriterionType == CriterionType.PCWG3, x => x.QuestionType != QuestionType.SiteVisitForTumorEvaluation)

                //.WhereIf(!criterion.IseCRFShowInDicomReading,x=>x.IsShowInDicom)
                .ToListAsync();

            var answerQuestionIds = await _readingTaskQuestionAnswerRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId && x.Answer != string.Empty).Select(x => x.ReadingQuestionTrialId).ToListAsync();

            readingQuestionList = readingQuestionList.Where(x => !answerQuestionIds.Contains(x.Id)).ToList();

            if (readingQuestionList.Count > 0)
            {
                throw new BusinessValidationFailedException(_localizer["ReadingImage_RequiredQuestion", string.Join(',', readingQuestionList.Select(x => x.QuestionName.LanguageName(x.QuestionEnName, _userInfo.IsEn_Us)))]);
            }
            return ResponseOutput.Ok(true);
        }



        /// <summary>
        /// 验证访视提交
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IResponseOutput> VerifyVisitTaskQuestions(VerifyVisitTaskQuestionsInDto inDto)
        {
            await VerifyTaskIsSign(inDto.VisitTaskId);
            await VerifyDefaultQuestionBeAnswer(inDto);

            // 转化后的任务不应该有新病灶

            var isConvertedTask = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).Select(x => x.IsConvertedTask).FirstNotNullAsync();

            if (isConvertedTask && (await _readingTableAnswerRowInfoRepository.AnyAsync(x => x.ReadingQuestionTrial.LesionType == LesionType.NewLesions && x.VisitTaskId == inDto.VisitTaskId)))
            {
                throw new BusinessValidationFailedException(_localizer["ReadingImage_NotNewFocus"]);
            }

            var taskInfo = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).FirstNotNullAsync();
            var isBaseline = await _subjectVisitRepository.Where(x => x.Id == taskInfo.SourceSubjectVisitId).Select(x => x.IsBaseLine).FirstOrDefaultAsync();
            var readingQuestionList = await _readingQuestionTrialRepository.Where(x => x.ReadingQuestionCriterionTrialId == taskInfo.TrialReadingCriterionId
            && (x.IsJudgeQuestion || (x.IsRequired == IsRequired.Required && x.ShowQuestion == ShowQuestion.Show))
            ).ToListAsync();
            if (isBaseline)
            {
                readingQuestionList = readingQuestionList.Where(x => x.LimitEdit != LimitEdit.OnlyVisit).ToList();
            }
            else
            {
                readingQuestionList = readingQuestionList.Where(x => x.LimitEdit != LimitEdit.OnlyBaseLine).ToList();
            }
            var answerQuestionIds = await _readingTaskQuestionAnswerRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId).Select(x => x.ReadingQuestionTrialId).ToListAsync();

            readingQuestionList = readingQuestionList.Where(x => !answerQuestionIds.Contains(x.Id)).ToList();

            if (readingQuestionList.Count > 0)
            {
                throw new BusinessValidationFailedException(_localizer["ReadingImage_RequiredQuestion", string.Join(',', readingQuestionList.Select(x => x.QuestionName.LanguageName(x.QuestionEnName, _userInfo.IsEn_Us)))]);
            }

            await _readingCalculateService.VerifyVisitTaskQuestions(inDto);

            var clinicalDataList = await _readingClinicalDataService.GetClinicalDataList(new GetReadingOrTaskClinicalDataListInDto()
            {

                SubjectId = taskInfo.SubjectId,
                TrialId = taskInfo.TrialId,
                VisitTaskId = taskInfo.Id,

            });

            var isBaseLine = false;
            if (taskInfo.SourceSubjectVisitId != null)
            {
                isBaseLine = await _subjectVisitRepository.Where(x => x.Id == taskInfo.SourceSubjectVisitId).Select(x => x.IsBaseLine).FirstOrDefaultAsync();
            }

            var isNeedReadClinicalData = false;

            if (isBaseLine)
            {
                isNeedReadClinicalData = clinicalDataList.Count > 0;
            }
            else
            {
                isNeedReadClinicalData = clinicalDataList.Where(x => x.ClinicalDataLevel != ClinicalLevel.Subject).Count() > 0;
            }

            if (isNeedReadClinicalData && !taskInfo.IsReadClinicalData)
            {
                throw new BusinessValidationFailedException(_localizer["ReadingImage_ClinicalRead"]);
            }
            return ResponseOutput.Ok(true);
        }




        /// <summary>
        /// 获取下一个阅片任务
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<GetReadingTaskDto> GetNextTask(GetNextTaskInDto inDto)
        {
            if (inDto.VisitTaskId == null)
            {
                await VerifyReadingRestTime();
            }

            GetReadingTaskDto? task = new GetReadingTaskDto();

            var trialReadingCriterionId = inDto.TrialReadingCriterionId;


            if (trialReadingCriterionId == null && inDto.VisitTaskId == null)
            {
                throw new BusinessValidationFailedException(_localizer["ReadingImage_IDMust"]);
            }

            var trialReadingCriterion = await _readingQuestionCriterionTrialRepository.FindAsync(trialReadingCriterionId ?? Guid.Empty);

            if (inDto.VisitTaskId != null)
            {
                task = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).Select(x => new GetReadingTaskDto()
                {
                    VisitTaskId = x.Id,
                    TaskBlindName = x.TaskBlindName,
                    SubjectId = x.SubjectId,
                    ReadingCategory = x.ReadingCategory,
                    ArmEnum = x.ArmEnum,
                    VisistId = x.SourceSubjectVisitId != null ? x.SourceSubjectVisitId.Value : default(Guid),
                    VisitNum = x.VisitTaskNum,
                    TrialReadingCriterionId = x.TrialReadingCriterionId,

                }).FirstNotNullAsync();

                trialReadingCriterionId = task.TrialReadingCriterionId;

            }
            else if (inDto.SubjectId != null && trialReadingCriterion.IsReadingTaskViewInOrder == ReadingOrder.InOrder)
            {
                var subjectTaskList = (await _visitTaskService.GetSubjectReadingIQueryable(new GetReadingIQueryableInDto()
                {
                    TrialId = inDto.TrialId,
                    TrialReadingCriterionId = trialReadingCriterionId!.Value,
                    PageIndex = 1,
                    PageSize = 99999,

                })).CurrentPageData;

                var index = 0;
                subjectTaskList.ForEach(x =>
                {
                    x.Index = index;
                    index++;
                });

                var subjectIndex = subjectTaskList.Where(x => x.SubjectId == inDto.SubjectId && x.SubjectCode == inDto.SubjectCode).Select(x => x.Index).FirstOrDefault();

                var currentSubject = subjectTaskList.Where(x => x.Index >= subjectIndex && !x.ExistReadingApply).OrderBy(x => x.Index).FirstOrDefault();

                if (currentSubject == null)
                {
                    throw new BusinessValidationFailedException(_localizer["ReadingImage_TaskFinish"], ApiResponseCodeEnum.CloseCurrentWindows);
                }

                task = currentSubject.UnReadCanReadTaskList.Select(x => new GetReadingTaskDto()
                {
                    ReadingCategory = x.ReadingCategory,
                    SubjectCode = currentSubject.SubjectCode,
                    SubjectId = currentSubject.SubjectId,
                    TaskBlindName = x.TaskBlindName,
                    VisitNum = x.VisitNum,
                    ArmEnum = x.ArmEnum,
                    VisistId = x.VisistId ?? default(Guid),
                    VisitTaskId = x.Id,
                    TrialReadingCriterionId = x.TrialReadingCriterionId,
                }).FirstOrDefault();



            }
            else if (inDto.SubjectId != null && trialReadingCriterion.IsReadingTaskViewInOrder == ReadingOrder.SubjectRandom)
            {
                var subjectTaskList = (await _visitTaskService.GetSubjectReadingIQueryable(new GetReadingIQueryableInDto()
                {
                    TrialId = inDto.TrialId,
                    SubjectId = inDto.SubjectId,
                    TrialReadingCriterionId = trialReadingCriterionId!.Value,

                    PageIndex = 1,
                    PageSize = 99999,

                })).CurrentPageData;

                if (subjectTaskList.Count() == 0)
                {
                    throw new BusinessValidationFailedException(_localizer["ReadingImage_TaskFinish"], ApiResponseCodeEnum.CloseCurrentWindows);
                }

                var taskList = subjectTaskList.FirstOrDefault()!.UnReadCanReadTaskList;

                Random random = new Random();
                //返回的范围是 0- taskList.Count-1
                int randomIndex = random.Next(taskList.Count);
             
                var visitTaskId = taskList[randomIndex].Id;

				task = await _visitTaskRepository.Where(x=>x.Id== visitTaskId).Select(x => new GetReadingTaskDto()
				{
					VisitTaskId = x.Id,
					ArmEnum = x.ArmEnum,
					TaskBlindName = x.TaskBlindName,
					ReadingCategory = x.ReadingCategory,
					VisistId = x.SourceSubjectVisitId != null ? x.SourceSubjectVisitId.Value : x.ReadModule == null ? default(Guid) : x.ReadModule.SubjectVisitId,
					VisitNum = x.VisitTaskNum,
					SubjectId = x.SubjectId,
					SubjectCode = x.Subject.Code,
					TrialReadingCriterionId = x.TrialReadingCriterionId,
				}).FirstOrDefaultAsync();

			}
            else
            {
                var query = _visitTaskRepository.Where(x => x.TrialId == inDto.TrialId && x.TrialReadingCriterionId == trialReadingCriterionId && x.ReadingTaskState != ReadingTaskState.HaveSigned && x.DoctorUserId == _userInfo.Id
                && x.TrialReadingCriterionId == trialReadingCriterionId
                && x.TaskState == TaskState.Effect);
                var count = await query.CountAsync();
                if (count == 0)
                {
                    throw new BusinessValidationFailedException(_localizer["ReadingImage_TaskFinish"], ApiResponseCodeEnum.CloseCurrentWindows);
                }
                Random random = new Random();
                var skipcount = 0;
                if (count >= 2)
                {
                    skipcount = random.Next(0, count - 1);
                }
                task = await query
                    .Select(x => new GetReadingTaskDto()
                    {
                        VisitTaskId = x.Id,
                        ArmEnum = x.ArmEnum,
                        TaskBlindName = x.TaskBlindName,
                        ReadingCategory = x.ReadingCategory,
                        VisistId = x.SourceSubjectVisitId != null ? x.SourceSubjectVisitId.Value : x.ReadModule == null ? default(Guid) : x.ReadModule.SubjectVisitId,
                        VisitNum = x.VisitTaskNum,
                        SubjectId = x.SubjectId,
                        SubjectCode = x.Subject.Code,
                        TrialReadingCriterionId = x.TrialReadingCriterionId,
                    }).Skip(skipcount).FirstOrDefaultAsync();

            }

            if (task == null)
            {
                throw new BusinessValidationFailedException(_localizer["ReadingImage_TaskFinish"], ApiResponseCodeEnum.CloseCurrentWindows);
            }

            if (task.SubjectCode.IsNullOrEmpty())
            {
                task.SubjectCode = await _subjectRepository.Where(x => x.Id == task.SubjectId).Select(x => x.Code).FirstNotNullAsync();
            }

            await _visitTaskRepository.BatchUpdateNoTrackingAsync(x => x.Id == task.VisitTaskId && x.FirstReadingTime == null, x => new VisitTask()
            {
                FirstReadingTime = DateTime.Now,
            });
            await _visitTaskRepository.SaveChangesAsync();

            var visitTaskInfo = await _visitTaskRepository.Where(x => x.Id == task.VisitTaskId).ProjectTo<VisitTaskDto>(_mapper.ConfigurationProvider).FirstNotNullAsync();

            task.SubjectCode = visitTaskInfo.BlindSubjectCode.IsNullOrEmpty() ? task.SubjectCode : visitTaskInfo.BlindSubjectCode;


            var criterionInfo = await _readingQuestionCriterionTrialRepository.Where(x => x.Id == visitTaskInfo.TrialReadingCriterionId).Select(x => new
            {
                x.IsReadingShowPreviousResults,
                x.IsReadingShowSubjectInfo,
                x.DigitPlaces,
                x.CriterionType,
                x.IseCRFShowInDicomReading,
                x.IsReadingTaskViewInOrder,
            }).FirstNotNullAsync();

            task.IsReadingShowPreviousResults = criterionInfo.IsReadingShowPreviousResults;
            task.IsReadingShowSubjectInfo = criterionInfo.IsReadingShowSubjectInfo;
            task.IsReadingTaskViewInOrder = criterionInfo.IsReadingTaskViewInOrder;
            var isBaseLine = false;
            if (visitTaskInfo.SourceSubjectVisitId != null)
            {
                task.IsExistsNoDicomFile = await _noneDicomStudyRepository.AnyAsync(x => x.SubjectVisitId == visitTaskInfo.SourceSubjectVisitId && x.FileCount > 0);
                isBaseLine = await _subjectVisitRepository.Where(x => x.Id == visitTaskInfo.SourceSubjectVisitId).Select(x => x.IsBaseLine).FirstOrDefaultAsync();
            }

            var clinicalDataList = await _readingClinicalDataService.GetClinicalDataList(new GetReadingOrTaskClinicalDataListInDto()
            {

                SubjectId = task.SubjectId,
                TrialId = inDto.TrialId,
                VisitTaskId = task.VisitTaskId,
            });

            task.IsExistsClinicalData = clinicalDataList.Count > 0;
            task.IsReadClinicalData = visitTaskInfo.IsReadClinicalData;

            if (isBaseLine)
            {
                task.IsNeedReadClinicalData = clinicalDataList.Count > 0;
            }
            else
            {
                task.IsNeedReadClinicalData = clinicalDataList.Where(x => x.ClinicalDataLevel != ClinicalLevel.Subject).Count() > 0;
            }

            if (visitTaskInfo.ReadingTaskState == ReadingTaskState.WaitReading)
            {
                await _readingCalculateService.AddTaskLesionAnswerFromLastTask(new AddTaskLesionAnswerFromLastTaskInDto()
                {
                    VisitTaskId = task.VisitTaskId
                });
            }


            // 如果已经签名 就不需要再读了
            task.IsNeedReadClinicalData = visitTaskInfo.ReadingTaskState == ReadingTaskState.HaveSigned ? false : task.IsNeedReadClinicalData;
            task.DigitPlaces = criterionInfo.DigitPlaces;
            task.CriterionType = criterionInfo.CriterionType;
            task.IseCRFShowInDicomReading = criterionInfo.IseCRFShowInDicomReading;
            task.IsFirstChangeTask = visitTaskInfo.IsConvertedTask && visitTaskInfo.BeforeConvertedTaskId != null;
            task.IsConvertedTask = visitTaskInfo.IsConvertedTask;
            var blindSubjectCode = await _visitTaskRepository.Where(x => x.Id == task.VisitTaskId).Select(x => x.BlindSubjectCode).FirstNotNullAsync();
            task.SubjectCode = blindSubjectCode.IsNullOrEmpty() ? task.SubjectCode : blindSubjectCode;
            task.ExistsManual = (await GetManualList(new GetManualListInDto() { TrialId = visitTaskInfo.TrialId })).Count > 0;
            task.ReadingTaskState = visitTaskInfo.ReadingTaskState;
            // 添加默认答案
            if (inDto.VisitTaskId == null && visitTaskInfo.ReadingTaskState != ReadingTaskState.HaveSigned)
            {
                await AddDefaultValueToTask(task.VisitTaskId);

            }
            return task;
        }

        /// <summary>
        /// 验证阅片休息时间
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public async Task VerifyReadingRestTime()
        {
            var userTypeEnum = (UserTypeEnum)_userInfo.UserTypeEnumInt;
            if (userTypeEnum != UserTypeEnum.IndependentReviewer)
            {
                return;
            }
            var startReadingTimeKey = _userInfo.Id.ToString() + "StartReadingTime";
            var startRestTimeKey = _userInfo.Id.ToString() + "StartRestTime";

            int readingMinute = 120; // 为60整数
            int restMinute = 10; //
            var startReadingTime = _provider.Get<string>(startReadingTimeKey).Value;
            var startRestTime = _provider.Get<string>(startRestTimeKey).Value;
            if (startReadingTime == null && startRestTime == null)
            {
                _provider.Set(startReadingTimeKey, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), TimeSpan.FromHours(48));
            }
            else if (startRestTime != null)
            {
                var cacheStartRestTime = DateTime.Parse(startRestTime!.ToString());
                int timespanMin = (DateTime.Now - cacheStartRestTime).Minutes;
                if (timespanMin <= restMinute)
                {
                    throw new BusinessValidationFailedException(_localizer["ReadingImage_NeedRest", readingMinute / 60m, restMinute]);
                }
                else
                {
                    // 休息时间>10分钟  删除休息时间的缓存  记录开始阅片时间
                    _provider.Remove(startRestTimeKey);
                    _provider.Set(startReadingTimeKey, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), TimeSpan.FromHours(48));
                }

            }
            // 如果开始阅片时间 不为空
            else if (startReadingTime != null)
            {
                #region 两小时
                var cacheDate = DateTime.Parse(startReadingTime!.ToString());
                int timespanMin = (DateTime.Now - cacheDate).Minutes;
                if (timespanMin > readingMinute)
                {

                    _provider.Remove(startReadingTimeKey);
                    _provider.Set(startRestTimeKey, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), TimeSpan.FromHours(48));
                    throw new BusinessValidationFailedException(_localizer["ReadingImage_NeedRest", readingMinute / 60m, restMinute]);
                }

                #endregion
            }
        }

        /// <summary>
        /// 重置阅片时间 登录和解锁调用
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public async Task ResetReadingRestTime(Guid? userID)
        {
            if (userID == null)
            {
                userID = _userInfo.Id;
            }

            var startReadingTimeKey = userID.ToString() + "StartReadingTime";
            var startRestTimeKey = userID.ToString() + "StartRestTime";
            //int readingMinute = 120; // 为60整数
            int restMinute = 10; //

            var startReadingTime = _provider.Get<string>(startReadingTimeKey).Value;
            var startRestTime = _provider.Get<string>(startRestTimeKey).Value;
            if (startRestTime != null)
            {
                var cacheStartRestTime = DateTime.Parse(startRestTime!.ToString());
                int timespanMin = (DateTime.Now - cacheStartRestTime).Minutes;
                if (timespanMin > restMinute)
                {
                    _provider.Remove(startRestTimeKey);
                }
            }
            else if (startReadingTime != null)
            {
                _provider.Set(startReadingTimeKey, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), TimeSpan.FromHours(48));
            }
        }

        /// <summary>
        /// 签名提交任务修改状态
        /// </summary>
        /// <param name="visitTaskId"></param>
        /// <returns></returns>
        private async Task SubmitTaskChangeState(Guid visitTaskId)
        {
            await VerifyTaskIsSign(visitTaskId);
            await _visitTaskRepository.UpdatePartialFromQueryAsync(visitTaskId, x => new VisitTask()
            {
                ReadingTaskState = ReadingTaskState.HaveSigned,
                SignTime = DateTime.Now,
            });

            await _visitTaskRepository.SaveChangesAsync();

            bool isConverted = false;

            var taskinfo = await _visitTaskRepository.Where(x => x.Id == visitTaskId).Include(x => x.TrialReadingCriterion).FirstNotNullAsync();

            var isConvertedTask = await _visitTaskRepository.Where(x => x.Id == visitTaskId).Select(x => x.IsConvertedTask).FirstNotNullAsync();
            switch (taskinfo.TrialReadingCriterion.CriterionType)
            {
                case CriterionType.IRECIST1Point1:



                    if (!isConvertedTask &&
                        (await _readingTaskQuestionAnswerRepository.AnyAsync(x => x.VisitTaskId == visitTaskId
                        && x.ReadingQuestionTrial.QuestionType == QuestionType.Tumor && x.Answer == (((int)OverallAssessment.PD)).ToString()))
                        )
                    {

                        isConverted = true;
                    }
                    break;
            }

            // 创建任务关联关系
            await this.CreateTaskRelated(visitTaskId);

            // 是否触发转变任务
            if (isConverted)
            {
                await _visitTaskHelpeService.AddConvertedTask(visitTaskId);
            }
            else
            {
                // 触裁判任务
                await this.TriggerJudgeQuestion(visitTaskId);
                // 添加阅片期任务
                await this.AddReadingTask(visitTaskId);

                // 完成阅片修改状态
                //await this.FinishReadUpdateState(visitTaskId);



                await _visitTaskRepository.SaveChangesAsync();

                await _trialEmailNoticeConfigService.BaseBusinessScenarioSendEmailAsync(visitTaskId);
            }


        }


        /// <summary>
        /// 签名时创建任务关联
        /// </summary>
        /// <returns></returns>
        private async Task CreateTaskRelated(Guid visitTaskId)
        {
            var taskInfo = await _visitTaskRepository.Where(x => x.Id == visitTaskId).FirstNotNullAsync();


            // 判断是否有序阅片

            var isReadingTaskViewInOrder = await _readingQuestionCriterionTrialRepository.Where(x => x.Id == taskInfo.TrialReadingCriterionId).Select(x => x.IsReadingTaskViewInOrder).FirstNotNullAsync();

            // 判断任务类型

            // 关联访视Id
            List<Guid> relatedVisitTaskIdList = new List<Guid>();

            // 既往任务Id
            List<Guid> pastResultTaskIdList = new List<Guid>();

            // 冻结任务Id
            List<Guid> reportRelatedTaskIdList = new List<Guid>();


            if (isReadingTaskViewInOrder == ReadingOrder.InOrder)
            {




                pastResultTaskIdList = await _visitTaskRepository.Where(x =>
              x.TrialId == taskInfo.TrialId &&
              x.SubjectId == taskInfo.SubjectId &&
              x.VisitTaskNum < taskInfo.VisitTaskNum &&
              x.ArmEnum == taskInfo.ArmEnum &&
              x.DoctorUserId == taskInfo.DoctorUserId &&
              x.TrialReadingCriterionId == taskInfo.TrialReadingCriterionId &&
              x.ReadingTaskState == ReadingTaskState.HaveSigned &&
              x.TaskState == TaskState.Effect &&
              x.IsSelfAnalysis == taskInfo.IsSelfAnalysis &&
              x.IsAnalysisCreate == taskInfo.IsAnalysisCreate &&
              x.ReadingCategory == taskInfo.ReadingCategory &&
              x.Id != taskInfo.Id
              ).OrderBy(x => x.VisitTaskNum).ThenBy(x => x.TaskState).Select(x => x.Id).ToListAsync();




                reportRelatedTaskIdList = await _visitTaskRepository.Where(x =>
                    x.TrialId == taskInfo.TrialId &&
                    x.SubjectId == taskInfo.SubjectId &&
                    x.VisitTaskNum <= taskInfo.VisitTaskNum &&
                    x.ArmEnum == taskInfo.ArmEnum &&
                    x.DoctorUserId == taskInfo.DoctorUserId &&
                    x.TrialReadingCriterionId == taskInfo.TrialReadingCriterionId &&
                    x.ReadingTaskState == ReadingTaskState.HaveSigned &&
                    (x.TaskState == TaskState.Effect || x.TaskState == TaskState.Freeze) &&
                    x.IsSelfAnalysis == taskInfo.IsSelfAnalysis &&
                    x.IsAnalysisCreate == taskInfo.IsAnalysisCreate &&
                    x.ReadingCategory == taskInfo.ReadingCategory &&
                    x.Id != taskInfo.Id
                   ).OrderBy(x => x.VisitTaskNum).ThenBy(x => x.TaskState).Select(x => x.Id).ToListAsync();

                switch (taskInfo.ReadingCategory)
                {
                    case ReadingCategory.Visit:
                    case ReadingCategory.Global:
                        relatedVisitTaskIdList = await _visitTaskRepository.Where(x =>
                    x.TrialId == taskInfo.TrialId &&
                    x.SubjectId == taskInfo.SubjectId &&
                    x.ReadingCategory == ReadingCategory.Visit &&
                    x.TrialReadingCriterionId == taskInfo.TrialReadingCriterionId &&
                    x.ReadingTaskState == ReadingTaskState.HaveSigned &&
                    x.IsAnalysisCreate == taskInfo.IsAnalysisCreate &&
                    x.ArmEnum == taskInfo.ArmEnum &&
                    x.IsSelfAnalysis == taskInfo.IsSelfAnalysis &&
                    x.DoctorUserId == taskInfo.DoctorUserId &&
                    x.TaskState == TaskState.Effect && x.VisitTaskNum <= taskInfo.VisitTaskNum).Select(x => x.Id).ToListAsync();
                        break;
                    case ReadingCategory.Oncology:
                        // 肿瘤学这里很特殊  因为没有裁判的时候 可能取R1可能取R2   为了和之前阅片的时候保持统一 
                        // 所以在保存肿瘤学答案的时候就存起来  现在签名的时候 创建关系
                        relatedVisitTaskIdList = await _visitTaskRepository.Where(x => x.Id == visitTaskId).Select(x => x.RelatedVisitTaskIdList).FirstNotNullAsync();
                        break;
                }
            }
            else
            {
                if (taskInfo.ReadingCategory == ReadingCategory.Visit)
                {
                    relatedVisitTaskIdList.Add(taskInfo.Id);
                }
            }

            await _visitTaskRepository.UpdatePartialFromQueryAsync(taskInfo.Id, x => new VisitTask()
            {


                ReportRelatedTaskIds = JsonConvert.SerializeObject(reportRelatedTaskIdList),
                PastResultTaskIds = JsonConvert.SerializeObject(pastResultTaskIdList),
                RelatedVisitTaskIds = JsonConvert.SerializeObject(relatedVisitTaskIdList),
            });

            await _readingTaskRelationRepository.AddRangeAsync(pastResultTaskIdList.Select(x => new ReadingTaskRelation()
            {
                RelevanceTaskId = x,
                TaskId = visitTaskId,
                RelevanceType = RelevanceType.PastResult,
            }));

            await _readingTaskRelationRepository.AddRangeAsync(relatedVisitTaskIdList.Select(x => new ReadingTaskRelation()
            {
                RelevanceTaskId = x,
                TaskId = visitTaskId,
                RelevanceType = RelevanceType.Related,
            }));

            await _readingTaskRelationRepository.AddRangeAsync(reportRelatedTaskIdList.Select(x => new ReadingTaskRelation()
            {
                RelevanceTaskId = x,
                TaskId = visitTaskId,
                RelevanceType = RelevanceType.ReportResult,
            }));


            await _visitTaskRepository.SaveChangesAsync();
        }



        /// <summary>
        /// 阅片期 -全局和肿瘤学任务的生成
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        [TypeFilter(typeof(TrialResourceFilter), Arguments = new object[] { "AfterStopCannNotOpt" })]
        public async Task AddReadingTask(Guid visitTaskId, Guid? trialId = null)
        {
            // ****** 先生成阅片期  阅片期任务阅片完成之后生成肿瘤学的  如果没有阅片期 直接生成肿瘤学 *********////
            #region 建立关系
            // 访视阅完产生 全局
            Dictionary<ModuleTypeEnum, ReadingCategory> typeChangeDic = new Dictionary<ModuleTypeEnum, ReadingCategory>();
            typeChangeDic.Add(ModuleTypeEnum.InPlanSubjectVisit, ReadingCategory.Visit);
            typeChangeDic.Add(ModuleTypeEnum.OutPlanSubjectVisit, ReadingCategory.Visit);
            //typeChange.Add(ModuleTypeEnum.Read, ReadingCategory.ReadingPeriod);
            typeChangeDic.Add(ModuleTypeEnum.Global, ReadingCategory.Global);
            typeChangeDic.Add(ModuleTypeEnum.Referee, ReadingCategory.Judge);
            typeChangeDic.Add(ModuleTypeEnum.Oncology, ReadingCategory.Oncology);
            #endregion
            var taskInfo = await _visitTaskRepository.Where(x => x.Id == visitTaskId).Include(x => x.TrialReadingCriterion).FirstNotNullAsync();
            List<ReadingGenerataTaskDTO> needReadList = new List<ReadingGenerataTaskDTO>();
            if (!taskInfo.IsAnalysisCreate)
            {
                // 任务类型
                switch (taskInfo.ReadingCategory)
                {
                    case ReadingCategory.Visit:
                        needReadList = await _readModuleRepository.Where(x => x.SubjectVisitId == taskInfo.SourceSubjectVisitId &&

                        x.TrialReadingCriterionId == taskInfo.TrialReadingCriterionId)
                         .Select(x => new ReadingGenerataTaskDTO
                         {
                             IsUrgent = x.IsUrgent ?? false,
                             SubjectId = x.SubjectId,
                             VisitNum = x.SubjectVisit.VisitNum,
                             ReadingName = x.ModuleName,
                             ReadModuleId = x.Id,
                             ReadingCategory = typeChangeDic[x.ModuleType],
                         }).ToListAsync();



                        if (needReadList.Any(x => x.ReadingCategory == ReadingCategory.Global) && taskInfo.TrialReadingCriterion.IsGlobalReading)
                        {
                            needReadList = needReadList.Where(x => x.ReadingCategory != ReadingCategory.Oncology).ToList();
                            await _visitTaskHelpeService.AddTaskAsync(new GenerateTaskCommand()
                            {
                                OriginalVisitId = visitTaskId,
                                ReadingCategory = GenerateTaskCategory.Global,
                                TrialId = taskInfo.TrialId,

                                ReadingGenerataTaskList = needReadList
                            });
                        }
                        else if (needReadList.Any(x => x.ReadingCategory == ReadingCategory.Oncology))
                        {
                            // 添加肿瘤学 
                            if (await _visitTaskRepository.AnyAsync(x => x.Id == visitTaskId && x.JudgeVisitTaskId == null))
                            {
                                await AddOncologyTask(needReadList.Where(x => x.ReadingCategory == ReadingCategory.Oncology).First().ReadModuleId);
                            }
                        }
                        //needReadList = needReadList.Where(x => _visitTaskRepository.Where(y => y.SouceReadModuleId == x.ReadModuleId).Count() == 0).ToList();

                        break;
                    // 肿瘤学
                    case ReadingCategory.Global:
                        var subjectVisitId = await _readModuleRepository.Where(x => x.Id == taskInfo.SouceReadModuleId).Select(x => x.SubjectVisitId).FirstOrDefaultAsync();
                        var oncologyReadId = await _readModuleRepository.Where(x => x.SubjectVisitId == subjectVisitId && x.ModuleType == ModuleTypeEnum.Oncology
                        && x.TrialReadingCriterionId == taskInfo.TrialReadingCriterionId


                        ).Select(x => x.Id).FirstOrDefaultAsync();

                        if (await _visitTaskRepository.AnyAsync(x => x.Id == visitTaskId && x.JudgeVisitTaskId == null))
                        {
                            await AddOncologyTask(oncologyReadId);
                        }


                        break;
                }
            }





        }

        #endregion


    }
}
