using IRaCIS.Application.Contracts;
using IRaCIS.Core.Application.Contracts;
using IRaCIS.Core.Application.Helper;
using IRaCIS.Core.Application.Service.Reading.Dto;
using IRaCIS.Core.Application.ViewModel;
using IRaCIS.Core.Domain.Share;
using IRaCIS.Core.Infra.EFCore.Common;
using IRaCIS.Core.Infrastructure;
using MassTransit;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Options;
using MiniSoftware;
using System.Runtime.InteropServices;

namespace IRaCIS.Core.Application.Service.ReadingCalculate
{
    [ApiExplorerSettings(GroupName = "Reading")]
    public class PCWG3CalculateService(IRepository<ReadingTableQuestionAnswer> _readingTableQuestionAnswerRepository,
        IRepository<VisitTask> _visitTaskRepository,
        IRepository<ReadingQuestionCriterionTrial> _readingQuestionCriterionTrialRepository,
        IRepository<ReadingTableQuestionTrial> _readingTableQuestionTrialRepository,
        IRepository<ReadingTableAnswerRowInfo> _readingTableAnswerRowInfoRepository,
        IRepository<ReadingQuestionTrial> _readingQuestionTrialRepository,
        IRepository<SubjectVisit> _subjectVisitRepository,
        IRepository<OrganInfo> _organInfoRepository,
        IRepository<DicomStudy> _dicomStudyRepository,
        IRepository<NoneDicomStudy> _noneDicomStudyRepository,
        IRepository<TumorAssessment_RECIST1Point1> _tumorAssessmentRepository,
        IGeneralCalculateService _generalCalculateService,
           IRepository<Subject> _subjectRepository,
              IRepository<User> _userRepository,
              IServiceProvider ServiceProvider,
              IOptionsMonitor<SystemHospitalOption> _hospital,
    IRepository<Dictionary> _dictionaryRepository,
                     IRepository<SubjectPatient> _subjectPatientRepository,
        IRepository<ReadingTaskQuestionAnswer> _readingTaskQuestionAnswerRepository, IMapper _mapper, IUserInfo _userInfo, IStringLocalizer _localizer) : BaseService, ICriterionCalculateService
    {


        private List<SiteVisitForTumor> siteVisitForTumorList;

        /// <summary>
        /// 获取阅片的计算数据
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<object> GetReadingCalculationData(GetReadingCalculationDataInDto inDto)
        {
            return new
            {
            };
        }

        /// <summary>
        /// 下载肿瘤评估
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<Stream> DownLoadTumorEvaluationStream(DownLoadReadReportInDto inDto)
        {
            throw new BusinessValidationFailedException(_localizer["ReadingCalculate_DownLoadReadReport"]);
        }

        /// <summary>
        /// 下载阅片报告
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<Stream> DownLoadReadReportStream(DownLoadReadReportInDto inDto)
        {
            var downFile = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $@"wwwroot/ReadReoprtTemplate/downLoad/{inDto.DownLoadGuid}");
            Directory.CreateDirectory(downFile);
            var taskinfo = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId && x.ReadingCategory == ReadingCategory.Visit).Include(x => x.TrialReadingCriterion).FirstNotNullAsync();
            var visitInfo = await _subjectVisitRepository.Where(x => x.Id == taskinfo.SourceSubjectVisitId).Include(x => x.StudyList).FirstNotNullAsync();
            var subjectInfo = await _subjectRepository.Where(x => x.Id == taskinfo.SubjectId).Include(x => x.SubjectPatientList).FirstNotNullAsync();
            var doctor = await _userRepository.Where(x => x.Id == taskinfo.DoctorUserId).FirstOrDefaultAsync();

            var trialQuestion = await _readingQuestionTrialRepository.Where(x => x.ReadingQuestionCriterionTrialId == taskinfo.TrialReadingCriterionId).ToListAsync();
            var tableQuestion = await _readingTableQuestionTrialRepository.Where(x => x.ReadingQuestionTrial.ReadingQuestionCriterionTrialId == taskinfo.TrialReadingCriterionId).ToListAsync();
            var dicotionCode = trialQuestion.Where(x => x.DictionaryCode != string.Empty).Select(x => x.DictionaryCode).Distinct().ToList();
            dicotionCode.AddRange(tableQuestion.Where(x => x.DictionaryCode != string.Empty).Select(x => x.DictionaryCode).Distinct());
            var dictionList = await _dictionaryRepository.Where(x => dicotionCode.Contains(x.Code)).Include(x => x.ChildList).ToListAsync();
            List<Guid> taskIds = new List<Guid>() { };
            var relatedVisitTask = await ServiceProvider.GetService<IReadingImageTaskService>().GetRelatedVisitTask(new GetRelatedVisitTaskInDto()
            {
                VisitTaskId = inDto.VisitTaskId
            });

            var relatedCount = relatedVisitTask.Item1.Count();

            if (relatedCount <= 3)
            {
                taskIds = relatedVisitTask.Item1.Select(x => x.VisitTaskId).ToList();
            }
            else
            {
                var count = relatedVisitTask.Item1.Count();
                taskIds.Add(relatedVisitTask.Item1[0].VisitTaskId);
                taskIds.Add(relatedVisitTask.Item1[count - 2].VisitTaskId);
                taskIds.Add(relatedVisitTask.Item1[count - 1].VisitTaskId);

            }
            relatedVisitTask.Item1 = relatedVisitTask.Item1.Where(x => taskIds.Contains(x.VisitTaskId)).ToList();
            // 所有访视问题的答案
            var answerList = await _readingTaskQuestionAnswerRepository.Where(x => taskIds.Contains(x.VisitTaskId)).Include(x => x.ReadingQuestionTrial).ToListAsync();

            // 单位字典
            var unitDictionary = await _dictionaryRepository.Where(x => x.Code == "ValueUnit").Include(x => x.ChildList).ToListAsync();
            var imageProblem = _generalCalculateService.GetTaskanswer(answerList, dictionList, unitDictionary, inDto.VisitTaskId, QuestionType.ImageQualityAssessment);
            var rowinfoList = await _readingTableAnswerRowInfoRepository.Where(x => taskIds.Contains(x.VisitTaskId)).Include(x => x.VisitTask).Include(x => x.ReadingQuestionTrial).ToListAsync();
            var tableAnswerList = await _readingTableQuestionAnswerRepository.Where(x => taskIds.Contains(x.VisitTaskId)).Include(x => x.ReadingQuestionTrial).Include(x => x.ReadingTableQuestionTrial).ToListAsync();

            #region 获取各个病灶 
            List<Dictionary<string, object>> getLesionInfo(LesionType lesionType)
            {
                List<decimal> targetFocusNum = rowinfoList.Where(x => x.VisitTaskId == inDto.VisitTaskId && x.ReadingQuestionTrial.LesionType == lesionType).Select(x => x.RowIndex).OrderBy(x => x).ToList();

                List<Dictionary<string, object>> targetInfo = new List<Dictionary<string, object>>();

                foreach (var item in targetFocusNum)
                {
                    var bodyPartDescription = _generalCalculateService.GetTaskTableAnswer(tableAnswerList, dictionList, unitDictionary, inDto.VisitTaskId, lesionType, QuestionMark.BodyPartDescription, item);
                    Dictionary<string, object> target = new Dictionary<string, object>()
                {
                  { "RowMark",rowinfoList.Where(x=>x.VisitTaskId == inDto.VisitTaskId &&x.RowIndex==item && x.ReadingQuestionTrial.LesionType == lesionType).Select(x=>x.RowMark).FirstIsNullReturnEmpty() },
                  { "Organ",_generalCalculateService.GetTaskTableAnswer(tableAnswerList,dictionList,unitDictionary,inDto.VisitTaskId,lesionType,QuestionMark.Organ,item)+"："+_generalCalculateService.GetTaskTableAnswer(tableAnswerList,dictionList,unitDictionary,inDto.VisitTaskId,lesionType,QuestionMark.Part,item)+ (bodyPartDescription==string.Empty?string.Empty:"，"+bodyPartDescription) },
                  { "FirstVisit",getStateInfo(0,item, lesionType) },
                  { "SecondVisit", relatedCount>=2?getStateInfo(1,item,lesionType):string.Empty },
                  { "ThirdlyVisit", relatedCount>=3?getStateInfo(2,item,lesionType):string.Empty  },
                };
                    targetInfo.Add(target);
                }
                return targetInfo;
            }

            string getStateInfo(int index, decimal item, LesionType lesionType)
            {

                var state = _generalCalculateService.GetTaskTableAnswer(tableAnswerList, dictionList, unitDictionary, taskIds[index], lesionType, QuestionMark.State, item);
                var LesionNumber = _generalCalculateService.GetTaskTableAnswer(tableAnswerList, dictionList, unitDictionary, taskIds[index], lesionType, QuestionMark.LesionNumber, item);
                var result = string.Empty;

                if (lesionType == LesionType.BaselineLesions)
                {
                    return LesionNumber;
                }
                else
                {
                    return state;

                }
            }

            #endregion


            #region 外层问题处理

            // 获取外层问题
            List<Dictionary<string, object>> getQuestionAnswerList(List<ExportReportQuestion> exports)
            {
                List<Dictionary<string, object>> questionAnswerList = new List<Dictionary<string, object>>();
                foreach (var item in exports)
                {
                    Dictionary<string, object> questionAnswer = new Dictionary<string, object>()
                     {
                        {"Name",item.QuestionName },
                        {"FirstVisit", _generalCalculateService.GetTaskanswer(answerList,dictionList,unitDictionary,taskIds[0],item.QuestionType)},
                        {"SecondVisit", relatedCount>=2? _generalCalculateService.GetTaskanswer(answerList,dictionList,unitDictionary,taskIds[1],item.QuestionType):string.Empty },
                        {"ThirdlyVisit", relatedCount>=3? _generalCalculateService.GetTaskanswer(answerList,dictionList,unitDictionary,taskIds[2],item.QuestionType):string.Empty  },
                    };
                    questionAnswerList.Add(questionAnswer);
                }
                return questionAnswerList;
            }

            #endregion

            var studyInfo = (await _dicomStudyRepository.Where(x => x.SubjectVisitId == taskinfo.SourceSubjectVisitId).Select(x => new
            {

                x.Modalities,
                x.StudyTime,
                x.BodyPartExamined,
                x.Description

            }).OrderBy(x => x.StudyTime).ToListAsync()).Select(x => new Dictionary<string, object>() {

             { "Modalities",x.Modalities},
             { "StudyTime",x.StudyTime?.ToString("yyyy-MM-dd")},
             { "Description",x.Description},
             { "ImageProblem",imageProblem},
            }).ToList();


            var subjectPatientList = await _subjectPatientRepository.Where(x => x.SubjectId == subjectInfo.Id).Include(x => x.Patient).ToListAsync();



            var value = new Dictionary<string, object>()
            {
			// { "Logo" ,await _generalCalculateService.GetWordPictureMaxWL(_options.CurrentValue.MinIO.viewEndpoint+_hospital.CurrentValue.HospitalLogoPath ,System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $@"wwwroot/ReadReoprtTemplate/downLoad/{inDto.DownLoadGuid}"),110,100) },
			 { "HospitalName",_hospital.CurrentValue.HospitalName }  ,// 医院名称
             { "SubjectName",subjectInfo.ShortName }, //患者姓名
             { "SubjectSex", subjectInfo.Sex==string.Empty?string.Empty:  subjectInfo.Sex=="M"?"男":"女" }, //患者性别
             { "SubjectAge",subjectInfo.Age==null?string.Empty: subjectInfo.Age +"岁" }, //患者年龄
             { "SubjectCode",subjectPatientList.Select(x=>x.Patient).OrderByDescending(x=>x.CreateTime).Select(x=>x.PatientIdStr).FirstIsNullReturnEmpty() }, //患者编号
             { "VisitName",visitInfo.VisitName }, //访视名称
             { "LatestScanDate",visitInfo.StudyList.Min(x=>x.StudyTime)?.ToString("yyyy-MM-dd") }, //随访日期
             { "CriterionName",taskinfo.TrialReadingCriterion.CriterionName }, //评估标准
             { "AssessmentResult", _generalCalculateService.GetTaskanswer(answerList,dictionList,unitDictionary,inDto.VisitTaskId,QuestionType.SiteVisitForTumorEvaluation) }, //评估结果
             { "DoctorName",doctor.LastName + doctor.FirstName}, //医生姓名
             { "SignTime",taskinfo.SignTime?.ToString("yyyy-MM-dd HH:mm:ss") }, //签名时间
             { "StudyInfo",studyInfo }, // 检查信息
			 { "FirstVisit", relatedVisitTask.Item1[0].TaskName},
             { "SecondVisit",relatedCount>=2?relatedVisitTask.Item1[1].TaskName:string.Empty},
             { "ThirdlyVisit", relatedCount>=3?relatedVisitTask.Item1[2].TaskName:string.Empty},
             { "BaselineLesionsInfo", getLesionInfo(LesionType.BaselineLesions)},  // 基线病灶
			 { "AlwaysNewLesionsInfo",  getLesionInfo(LesionType.AlwaysNewLesions)}, // 既往新病灶
			 { "NewTargetInfo",  getLesionInfo(LesionType.NewLesions)},// 新病灶
			 { "BaselineLesionsImage", await _generalCalculateService.GetLesionPic(rowinfoList, LesionType.BaselineLesions, inDto.DownLoadGuid)}, // 基线病灶
             { "AlwaysNewLesionsImage",await  _generalCalculateService.GetLesionPic(rowinfoList, LesionType.AlwaysNewLesions, inDto.DownLoadGuid)}, // 既往新病灶
             { "NewImage", await  _generalCalculateService.GetLesionPic(rowinfoList, LesionType.NewLesions, inDto.DownLoadGuid)}, // 新病灶图片
             { "Result",getQuestionAnswerList(new List<ExportReportQuestion>()
              { new ExportReportQuestion (){ QuestionName="基线病灶计数",QuestionType=QuestionType.BaseLineLesionsCount},
               new ExportReportQuestion (){ QuestionName="新病灶计数",QuestionType=QuestionType.NewLesionsCount},
               new ExportReportQuestion (){ QuestionName="既往新病灶计数",QuestionType=QuestionType.AlwaysNewLesionsCount},
               new ExportReportQuestion (){ QuestionName="自治疗后第二个访视点以来持续的新骨病变数量",QuestionType=QuestionType.NewBoneLesionsCount},
               new ExportReportQuestion (){ QuestionName="与前一个访视间隔天数",QuestionType=QuestionType.DaysBetween},
                })},  // 评估结果
               { "Curative",getQuestionAnswerList(new List<ExportReportQuestion>()
              { new ExportReportQuestion (){ QuestionName="访视点肿瘤评估",QuestionType=QuestionType.SiteVisitForTumorEvaluation},
               new ExportReportQuestion (){ QuestionName="访视阅片备注",QuestionType=QuestionType.AdjustReason},
                })},  // 疗效结果

                 { "ReportNo",await _generalCalculateService.GetReportExportNo(taskinfo) }  ,
            };

            value = _generalCalculateService.StringEmptyTurnedLine(value);

            var templatePath = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"wwwroot/ReadReoprtTemplate/ReportTemplate_PCWG3_CN_V1.docx");
            var outputFilePath = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $@"wwwroot/ReadReoprtTemplate/downLoad/{inDto.DownLoadGuid}.docx");
            MiniWord.SaveAsByTemplate(outputFilePath, templatePath, value);
            Directory.Delete(downFile, true);
            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            {
                Stream stream = _generalCalculateService.ReadAndReturnStream(outputFilePath);
                return stream;
            }
            else
            {
                var pdfurl = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"wwwroot/ReadReoprtTemplate/downLoad");
                FileConvertHelper.ConvertWordToPdf(outputFilePath, pdfurl);
                Stream stream = _generalCalculateService.ReadAndReturnStream(pdfurl + $"/{inDto.DownLoadGuid}.pdf");
                return stream;
            }
        }

        #region 删除病灶获取起始病灶序号
        /// <summary>
        /// 删除病灶获取起始病灶序号
        /// </summary>
        /// <returns></returns>
        public async Task<int> GetDeleteLesionStatrIndex(DeleteReadingRowAnswerInDto inDto)
        {
            var rowInfo = await _readingTableAnswerRowInfoRepository.Where(x => x.Id == inDto.RowId).Include(x => x.ReadingQuestionTrial).FirstNotNullAsync();
            if (rowInfo.ReadingQuestionTrial.LesionType == LesionType.NewLesions)
            {
                var minIndex = await _readingTableAnswerRowInfoRepository.Where(x => x.QuestionId == rowInfo.QuestionId && x.VisitTaskId == inDto.VisitTaskId).OrderBy(x => x.RowIndex).Select(x => x.RowIndex).FirstOrDefaultAsync();
                return (int)minIndex;
            }
            else
            {
                return 1;
            }


        }
        #endregion

        #region 获取阅片报告
        /// <summary>
        /// 获取阅片报告
        /// </summary>
        /// <param name="indto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<GetReadingReportEvaluationOutDto> GetReadingReportEvaluation(GetReadingReportEvaluationInDto indto)
        {
            GetReadingReportEvaluationOutDto result = new GetReadingReportEvaluationOutDto();


            result.CalculateResult = await this.GetReportVerify(new GetReportVerifyInDto()
            {
                VisitTaskId = indto.VisitTaskId
            });

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


            result.ReadingTaskState = visitTaskInfo.ReadingTaskState;
            var taskInfoList = await _generalCalculateService.GetReadingReportTaskList(indto.VisitTaskId);
            taskInfoList = taskInfoList.Where(x => x.VisitTaskNum <= visitTaskInfo.VisitTaskNum).ToList();
            result.VisitTaskList = taskInfoList;

            var visitTaskIds = taskInfoList.Select(x => x.VisitTaskId).ToList();

            var criterionId = visitTaskInfo.TrialReadingCriterionId;
            var questionList = await _readingQuestionTrialRepository.Where(x => x.ReadingQuestionCriterionTrialId == criterionId && x.ShowQuestion != ShowQuestion.Hide)
                //.Where(x => x.LesionType != LesionType.BaselineLesions)
                .Where(x => x.QuestionType != QuestionType.TherapeuticEffectEvaluationGroup)
                .ToListAsync();

            // 新病灶
            var questionNewLesions = await _readingQuestionTrialRepository.Where(x => x.ReadingQuestionCriterionTrialId == visitTaskInfo.TrialReadingCriterionId && x.LesionType == LesionType.NewLesions).FirstNotNullAsync();

            var tableQuestionList = await _readingTableQuestionTrialRepository.Where(x => x.TrialCriterionId == criterionId).OrderBy(x => x.ShowOrder).ToListAsync();
            var tableAnsweRowInfos = await _readingTableAnswerRowInfoRepository.Where(x => x.VisitTaskId == indto.VisitTaskId).ProjectTo<TableAnsweRowInfo>(_mapper.ConfigurationProvider).ToListAsync();
            var answers = await _readingTaskQuestionAnswerRepository.Where(x => visitTaskIds.Contains(x.VisitTaskId))
                .Where(x => x.ReadingQuestionTrialId != questionNewLesions.Id || x.VisitTaskId == visitTaskInfo.Id)
                .ToListAsync();
            var tableAnswers = await _readingTableQuestionAnswerRepository.Where(x => visitTaskIds.Contains(x.VisitTaskId))
                  .Where(x => x.QuestionId != questionNewLesions.Id || x.VisitTaskId == visitTaskInfo.Id)
                .ToListAsync();


            var alltableAnsweRowInfos = await _readingTableAnswerRowInfoRepository.Where(x => visitTaskIds.Contains(x.VisitTaskId)).ToListAsync();

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

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


            // 第一级 分组

            #region 构造问题
            List<ReadingReportDto> questions = questionList.Where(x => x.Type == ReadingQestionType.Group).OrderBy(x => x.ShowOrder).Select(x => new ReadingReportDto()
            {
                QuestionId = x.Id,
                GroupName = x.GroupName,
                GroupEnName = x.GroupEnName,
                IsShowInDicom = x.IsShowInDicom,
                Type = x.Type,
                GroupId = x.GroupId,
                QuestionType = x.QuestionType,
                LesionType = x.LesionType,
                QuestionGenre = x.QuestionGenre,
                DataSource = x.DataSource,
                DictionaryCode = x.DictionaryCode,
                TypeValue = x.TypeValue,
                QuestionName = x.QuestionName.LanguageName(x.QuestionEnName, _userInfo.IsEn_Us),
                ShowOrder = x.ShowOrder,
                ValueType = x.ValueType,
                CustomUnit = x.CustomUnit,
                Unit = x.Unit,
                ReportLayType = ReportLayType.Group,
                HighlightAnswer = x.HighlightAnswer,
                HighlightAnswerList = x.HighlightAnswerList,
            }).ToList();

            // 分组
            foreach (var item in questions)
            {
                // 问题
                item.Childrens = questionList.Where(x => x.GroupId == item.QuestionId).OrderBy(x => x.ShowOrder).Select(x => new ReadingReportDto()
                {
                    GroupName = x.GroupName,
                    GroupEnName = x.GroupEnName,
                    QuestionId = x.Id,
                    IsShowInDicom = x.IsShowInDicom,
                    QuestionName = x.QuestionName.LanguageName(x.QuestionEnName, _userInfo.IsEn_Us),
                    LesionType = x.LesionType,
                    QuestionGenre = x.QuestionGenre,
                    DataSource = x.DataSource,
                    DictionaryCode = x.DictionaryCode,
                    Type = x.Type,
                    QuestionType = x.QuestionType,
                    TypeValue = x.TypeValue,
                    ShowOrder = x.ShowOrder,
                    OrderMark = x.OrderMark,
                    ValueType = x.ValueType,
                    Unit = x.Unit,
                    CustomUnit = x.CustomUnit,
                    ReportLayType = ReportLayType.Question,
                    HighlightAnswer = x.HighlightAnswer,
                    HighlightAnswerList = x.HighlightAnswerList,
                }).ToList();

                // 问题
                foreach (var question in item.Childrens)
                {

                    foreach (var task in taskInfoList)
                    {

                        var answer = answers.Where(x => x.VisitTaskId == task.VisitTaskId && x.ReadingQuestionTrialId == question.QuestionId).FirstOrDefault();
                        question.Answer.Add(new TaskQuestionAnswer()
                        {
                            Answer = answer == null ? string.Empty : answer.Answer,
                            IsGlobalChange = answer == null ? false : answer.IsGlobalChange,
                            GlobalChangeAnswer = answer == null ? string.Empty : answer.GlobalChangeAnswer,
                            TaskName = task.TaskName,
                            VisitTaskId = task.VisitTaskId,

                        });
                    }

                    // 构造表格行数据


                    var rowlist = tableAnsweRowInfos.Where(x => x.QuestionId == question.QuestionId).OrderBy(x => x.RowIndex).ToList();


                    question.Childrens = rowlist.OrderBy(x => x.RowIndex).Select(x => new ReadingReportDto()
                    {
                        QuestionName = question.OrderMark + x.RowIndex.GetLesionMark(),
                        SplitOrMergeLesionName = x.MergeName.IsNullOrEmpty() ? x.SplitName : x.MergeName,
                        SplitOrMergeType = x.SplitOrMergeType,
                        LesionType = question.LesionType,
                        IsCanEditPosition = x.IsCanEditPosition,
                        RowIndex = x.RowIndex,
                        BlindName = x.BlindName,
                        RowId = x.Id,
                        ReportLayType = ReportLayType.Lesions,
                        FristAddTaskNum = x.FristAddTaskNum,
                    }).ToList();


                    foreach (var row in question.Childrens)
                    {
                        // tableQuestion
                        row.Childrens = tableQuestionList.Where(x => x.ReadingQuestionId == question.QuestionId).Select(x => new ReadingReportDto()
                        {
                            QuestionName = x.QuestionName.LanguageName(x.QuestionEnName, _userInfo.IsEn_Us),
                            QuestionId = x.ReadingQuestionId,
                            TableQuestionId = x.Id,

                            Type = x.Type,
                            LesionType = question.LesionType,
                            TableQuestionType = x.TableQuestionType,
                            DataSource = x.DataSource,
                            DictionaryCode = x.DictionaryCode,
                            QuestionMark = x.QuestionMark,
                            TypeValue = x.TypeValue,
                            RowIndex = row.RowIndex,
                            ShowOrder = x.ShowOrder,
                            ValueType = x.ValueType,
                            RowId = row.RowId,
                            Unit = x.Unit,
                            ReportLayType = ReportLayType.TableQuestion,
                            FristAddTaskNum = row.FristAddTaskNum,
                        }).ToList();


                        foreach (var tableQuestion in row.Childrens)
                        {
                            foreach (var task in taskInfoList)
                            {
                                var rowinfo = alltableAnsweRowInfos.Where(x => x.VisitTaskId == task.VisitTaskId && x.QuestionId == tableQuestion.QuestionId && x.RowIndex == tableQuestion.RowIndex).FirstOrDefault();
                                var taskQuestionAnswer = new TaskQuestionAnswer()
                                {
                                    Answer = tableAnswers.Where(x => x.VisitTaskId == task.VisitTaskId && x.QuestionId == tableQuestion.QuestionId && x.RowIndex == tableQuestion.RowIndex && x.TableQuestionId == tableQuestion.TableQuestionId).Select(x => x.Answer).FirstIsNullReturnEmpty(),
                                    TaskName = task.TaskName,
                                    VisitTaskId = task.VisitTaskId,
                                };
                                if (rowinfo != null && rowinfo.OrganInfoId != null)
                                {
                                    var organInfo = organInfos.Where(x => x.Id == rowinfo.OrganInfoId).FirstOrDefault();


                                    if (organInfo != null && needChangeType.Contains(tableQuestion.QuestionMark))
                                    {
                                        if (_userInfo.IsEn_Us)
                                        {
                                            switch (tableQuestion.QuestionMark)
                                            {
                                                case QuestionMark.Organ:
                                                    taskQuestionAnswer.Answer = organInfo.TULOCEN;

                                                    break;
                                                case QuestionMark.Location:
                                                    if (organInfo.IsCanEditPosition)
                                                    {

                                                    }
                                                    else
                                                    {
                                                        taskQuestionAnswer.Answer = organInfo.TULATEN;

                                                    }
                                                    break;
                                                case QuestionMark.Part:

                                                    taskQuestionAnswer.Answer = organInfo.PartEN;

                                                    break;

                                            }

                                        }
                                        else
                                        {
                                            switch (tableQuestion.QuestionMark)
                                            {
                                                case QuestionMark.Organ:
                                                    taskQuestionAnswer.Answer = organInfo.TULOC;
                                                    break;
                                                case QuestionMark.Location:
                                                    if (organInfo.IsCanEditPosition)
                                                    {

                                                    }
                                                    else
                                                    {
                                                        taskQuestionAnswer.Answer = organInfo.TULAT;

                                                    }
                                                    break;
                                                case QuestionMark.Part:
                                                    taskQuestionAnswer.Answer = organInfo.Part;
                                                    break;

                                            }
                                        }

                                    }
                                }
                                tableQuestion.Answer.Add(taskQuestionAnswer);
                            }
                        }


                    }


                };
            }
            #endregion



            result.TaskQuestions = questions;



            return result;

        }
        #endregion

        /// <summary>
        /// 将上一次的病灶信息添加到这一次
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<AddTaskLesionAnswerFromLastTaskOutDto> AddTaskLesionAnswerFromLastTask(AddTaskLesionAnswerFromLastTaskInDto inDto)
        {

            var visitTaskId = inDto.VisitTaskId;

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

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

            // 判断当前任务是否是基线
            if (taskinfo.SourceSubjectVisitId != baseLineVisitId)
            {
                // 判断当前任务是是否有表格问题答案
                if (!(await _readingTableQuestionAnswerRepository.AnyAsync(x => x.VisitTaskId == visitTaskId)))
                {
                    var LastVisitTaskId = await _visitTaskRepository.Where(x => x.ReadingCategory == ReadingCategory.Visit &&
                    x.TrialReadingCriterionId == taskinfo.TrialReadingCriterionId &&
                     x.IsAnalysisCreate == taskinfo.IsAnalysisCreate &&
                     x.ArmEnum == taskinfo.ArmEnum &&
                        x.IsSelfAnalysis == taskinfo.IsSelfAnalysis &&
                    x.SubjectId == taskinfo.SubjectId && x.ReadingTaskState == ReadingTaskState.HaveSigned && x.VisitTaskNum < taskinfo.VisitTaskNum && x.TaskState == TaskState.Effect && x.ArmEnum == taskinfo.ArmEnum
                    ).OrderByDescending(x => x.VisitTaskNum).Select(x => x.Id).FirstOrDefaultAsync();

                    // 上一次的表格答案
                    var copyTableAnswers = await _readingTableQuestionAnswerRepository.Where(x => x.VisitTaskId == LastVisitTaskId
                    ).Select(x => new CopyTableAnswerDto()
                    {
                        Answer = x.Answer,
                        QuestionId = x.QuestionId,
                        RowId = x.RowId,
                        QuestionMark = x.ReadingTableQuestionTrial.QuestionMark,
                        TableQuestionId = x.TableQuestionId,
                        RowIndex = x.RowIndex,
                        TrialId = x.TrialId
                    }).ToListAsync();

                    // 上一次的行信息
                    var tableRowAnswers = await _readingTableAnswerRowInfoRepository.Where(x => x.VisitTaskId == LastVisitTaskId).ProjectTo<CopyTableAnswerRowInfo>(_mapper.ConfigurationProvider).ToListAsync();

                    tableRowAnswers.ForEach(x =>
                    {
                        x.VisitTaskId = visitTaskId;
                        x.IsCurrentTaskAdd = false;
                        x.Id = NewId.NextGuid();
                        x.SeriesId = null;
                        x.InstanceId = null;
                        x.MeasureData = string.Empty;
                        x.PicturePath = string.Empty;
                    });

                    tableRowAnswers.ForEach(x =>
                    {
                        x.SplitRowId = tableRowAnswers.Where(y => y.OriginalId == x.SplitRowId).Select(y => y.Id).FirstOrDefault();
                        x.MergeRowId = tableRowAnswers.Where(y => y.OriginalId == x.MergeRowId).Select(y => y.Id).FirstOrDefault();

                    });

                    List<QuestionMark?> notNeedCopyMarks = new List<QuestionMark?>()
                    {
                         QuestionMark.State,
                         QuestionMark.LesionNumber,
                    };

                    var tableAnswers = copyTableAnswers.Select(x => new ReadingTableQuestionAnswer
                    {
                        Id = NewId.NextGuid(),
                        Answer = notNeedCopyMarks.Contains(x.QuestionMark) ? string.Empty : x.Answer,
                        QuestionId = x.QuestionId,
                        RowIndex = x.RowIndex,
                        RowId = tableRowAnswers.Where(y => y.OriginalId == x.RowId).Select(x => x.Id).FirstOrDefault(),
                        TableQuestionId = x.TableQuestionId,
                        TrialId = x.TrialId,
                        VisitTaskId = visitTaskId,
                    }).ToList();


                    try
                    {
                        // 新病灶外层问题
                        var newLesionQuestion = await _readingQuestionTrialRepository.Where(x => x.LesionType == LesionType.NewLesions && x.ReadingQuestionCriterionTrialId == taskinfo.TrialReadingCriterionId).FirstNotNullAsync();

                        // 既往病灶外层问题
                        var alwaysNewLesionsQuestion = await _readingQuestionTrialRepository.Where(x => x.LesionType == LesionType.AlwaysNewLesions && x.ReadingQuestionCriterionTrialId == taskinfo.TrialReadingCriterionId).FirstNotNullAsync();

                        // 新病灶表格问题
                        var newLesionTableQuestions = await _readingTableQuestionTrialRepository.Where(x => x.ReadingQuestionId == newLesionQuestion.Id).ToListAsync();

                        // 既往病灶表格问题
                        var alwaysNewLesionsTableQuestions = await _readingTableQuestionTrialRepository.Where(x => x.ReadingQuestionId == alwaysNewLesionsQuestion.Id).ToListAsync();

                        Dictionary<Guid, Guid> alwaysTableQuestionIdDic = new Dictionary<Guid, Guid>();

                        newLesionTableQuestions.ForEach(x =>
                        {

                            alwaysTableQuestionIdDic.Add(
                                x.Id,
                                alwaysNewLesionsTableQuestions.Where(y => y.QuestionName == x.QuestionName).Select(y => y.Id).FirstOrDefault()
                                );
                        });

                        foreach (var item in tableRowAnswers.Where(x => x.QuestionId == newLesionQuestion.Id).OrderBy(x => x.RowIndex))
                        {

                            item.QuestionId = alwaysNewLesionsQuestion.Id;


                            foreach (var tableAnswer in tableAnswers.Where(y => y.RowId == item.Id))
                            {
                                tableAnswer.QuestionId = alwaysNewLesionsQuestion.Id;
                                tableAnswer.TableQuestionId = alwaysTableQuestionIdDic[tableAnswer.TableQuestionId];

                            }
                        }

                    }
                    catch (Exception)
                    {

                        throw new BusinessValidationFailedException(_localizer["ReadingCalculate_Abnormal"]);
                    }




                    var addList = _mapper.Map<List<ReadingTableAnswerRowInfo>>(tableRowAnswers);

                    await _readingTableAnswerRowInfoRepository.AddRangeAsync(addList);
                    await _readingTableQuestionAnswerRepository.AddRangeAsync(tableAnswers);
                    await _readingTableQuestionAnswerRepository.SaveChangesAsync();

                }
            }

            return new AddTaskLesionAnswerFromLastTaskOutDto()
            {

                IsBaseLine = taskinfo.SourceSubjectVisitId == baseLineVisitId,
            };
        }

        /// <summary>
        /// 测试计算
        /// </summary>
        /// <param name="visitTaskId"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task TestCalculate(Guid visitTaskId, QuestionType type)
        {
            ReadingCalculateDto readingData = await _generalCalculateService.GetReadingCalculateDto(visitTaskId);
            await ReadingCalculate(readingData, new List<QuestionType>() { type });
        }

        /// <summary>
        /// 计算任务
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task CalculateTask(CalculateTaskInDto inDto)
        {
            ReadingCalculateDto readingData = await _generalCalculateService.GetReadingCalculateDto(inDto.VisitTaskId);
            readingData.IsChangeOtherTask = inDto.IsChangeOtherTask;
            await ReadingCalculate(readingData);
        }


        /// <summary>
        /// 自动计算
        /// </summary>
        /// <param name="inDto"></param>
        /// <param name="calculateType"></param>
        /// <returns></returns>
        public async Task ReadingCalculate(ReadingCalculateDto inDto, List<QuestionType>? calculateType = null)
        {

            #region 计算  这里顺序非常重要 后面计算的值要依赖前面计算的结果
            var needAddList = new List<ReadingTaskQuestionAnswer>();


            List<ReadingCalculateData> calculateList = new List<ReadingCalculateData>()
            {
				// 基线病灶计数
				new ReadingCalculateData (){QuestionType=QuestionType.BaseLineLesionsCount,GetIntFun=GetBaseLineLesionsCount},

				// 新病灶计数
				new ReadingCalculateData (){QuestionType=QuestionType.NewLesionsCount,GetIntFun=GetNewLesionsCount},

				// 既往新病灶
			    new ReadingCalculateData (){QuestionType=QuestionType.AlwaysNewLesionsCount,GetIntFun=GetAlwaysNewLesionsCount},

				// 自治疗后第二个访视点以来持续的新骨病变数量
			    new ReadingCalculateData (){QuestionType=QuestionType.NewBoneLesionsCount,GetIntFun=GetNewBoneLesionCount},

                 // 间隔天数
			    new ReadingCalculateData (){QuestionType=QuestionType.DaysBetween,GetIntFun=GetNumberOfDaysBetween},

                // 访视点肿瘤评估
			    new ReadingCalculateData (){QuestionType=QuestionType.SiteVisitForTumorEvaluation,GetStringFun=GetSiteVisitForTumorEvaluation},



            };

            if (calculateType != null)
            {
                calculateList = calculateList.Where(x => calculateType.Contains(x.QuestionType)).ToList();
            }



            foreach (var calculate in calculateList)
            {
                var item = inDto.QuestionInfo.FirstOrDefault(x => x.QuestionType == calculate.QuestionType);

                if (item != null)
                {
                    //计算答案  
                    if (inDto.IsOnlyChangeAllTask == false)
                    {

                        #region 计算答案



                        switch (calculate.QuestionType)
                        {
                            case QuestionType.BaseLineLesionsCount:
                                item.Answer = (await calculate.GetIntFun(inDto)).ToString();
                                break;

                            case QuestionType.NewLesionsCount:

                                if (inDto.VisitTaskNum >= 1)
                                {
                                    item.Answer = (await calculate.GetIntFun(inDto)).ToString();
                                }
                                else
                                {
                                    item.Answer = nameof(YesOrNoOrNa.NA);
                                }
                                break;
                            case QuestionType.AlwaysNewLesionsCount:
                                if (inDto.VisitTaskNum > 1)
                                {
                                    item.Answer = (await calculate.GetIntFun(inDto)).ToString();
                                }
                                else
                                {
                                    item.Answer = nameof(YesOrNoOrNa.NA);
                                }
                                break;
                            case QuestionType.NewBoneLesionsCount:


                                item.Answer = (await calculate.GetIntFun(inDto)).ToString();

                                if (item.Answer == "-1")
                                {
                                    item.Answer = nameof(YesOrNoOrNa.NA);
                                }
                                break;
                            case QuestionType.DaysBetween:
                                item.Answer = (await calculate.GetIntFun(inDto)).ToString();
                                break;
                            case QuestionType.SiteVisitForTumorEvaluation:
                                item.Answer = await calculate.GetStringFun(inDto);
                                break;
                            default:
                                item.Answer = string.Empty;
                                break;
                        }

                        #endregion

                        // 修改修约小数位数
                        try
                        {
                            List<ValueOfType?> valueOfTypes = new List<ValueOfType?>() {

                               ValueOfType.Decimals,
                               ValueOfType.Percentage
                            };

                            if (valueOfTypes.Contains(item.ValueType))
                            {
                                item.Answer = decimal.Round(decimal.Parse(item.Answer.IsNullOrEmpty() ? "0" : item.Answer), inDto.DigitPlaces).ToString("F" + inDto.DigitPlaces.ToString());
                            }
                        }
                        catch (Exception)
                        {


                        }
                        needAddList.Add(new ReadingTaskQuestionAnswer()
                        {
                            Answer = item.Answer,
                            ReadingQuestionTrialId = item.QuestionId,
                        });
                    }

                    // 修改全局
                    if (inDto.IsChangeOtherTask && calculate.ChangeAllTaskFun != null)
                    {
                        await calculate.ChangeAllTaskFun(new ChangeAllTaskDto()
                        {
                            calculateDto = inDto,
                            QuestionId = item.QuestionId,
                        });
                    }

                }
            }



            var questionIds = needAddList.Select(x => x.ReadingQuestionTrialId).ToList();

            await _readingTaskQuestionAnswerRepository.BatchDeleteNoTrackingAsync(x => questionIds.Contains(x.ReadingQuestionTrialId) && x.VisitTaskId == inDto.VisitTaskId);
            needAddList.ForEach(x =>
            {
                x.SubjectId = inDto.SubjectId;
                x.ReadingQuestionCriterionTrialId = inDto.CriterionId;
                x.VisitTaskId = inDto.VisitTaskId;
                x.TrialId = inDto.TrialId;
                x.SubjectId = inDto.SubjectId;
            });

            await _readingTaskQuestionAnswerRepository.AddRangeAsync(needAddList);

            await _readingTaskQuestionAnswerRepository.SaveChangesAsync();
            #endregion


        }


        #region 基线病灶计数
        /// <summary>
        /// 基线病灶计数
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<int> GetBaseLineLesionsCount(ReadingCalculateDto inDto)
        {

            try
            {
                return (int)(inDto.QuestionInfo.Where(x => x.LesionType == LesionType.BaselineLesions).SelectMany(x => x.TableRowInfoList)

              .Sum(x => x.TableQuestionList.Where(y => y.QuestionMark == QuestionMark.LesionNumber).Select(x => x.Answer).FirstOrDefault().IsNullOrEmptyReturn0()));
            }
            catch
            {

                return 0;
            }

        }

        #endregion

        #region 新病灶计数
        /// <summary>
        /// 获取新病灶计数
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<int> GetNewLesionsCount(ReadingCalculateDto inDto)
        {
            return inDto.QuestionInfo.Where(x => x.LesionType == LesionType.NewLesions).SelectMany(x => x.TableRowInfoList)
                .Where(x => x.TableQuestionList.Any(y => y.QuestionMark == QuestionMark.State && y.Answer == EvaluationOfState.Exists.GetEnumInt()))
                .Count();
        }

        #endregion


        #region 既往新病灶计数
        /// <summary>
        /// 既往新病灶计数
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<int> GetAlwaysNewLesionsCount(ReadingCalculateDto inDto)
        {
            return inDto.QuestionInfo.Where(x => x.LesionType == LesionType.AlwaysNewLesions).SelectMany(x => x.TableRowInfoList)
                .Where(x => x.TableQuestionList.Any(y => y.QuestionMark == QuestionMark.State && y.Answer == EvaluationOfState.Exists.GetEnumInt()))
                .Count();
        }

        #endregion


        #region 自治疗后第二个访视点以来持续的新骨病变数量
        /// <summary>
        /// 自治疗后第二个访视点以来持续的新骨病变数量
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<int> GetNewBoneLesionCount(ReadingCalculateDto inDto)
        {

            var taskList = await GetSiteVisitForTumorList(inDto);
            var result = 0;
            var findindex = taskList.OrderBy(x => x.VisitTaskNum).ToList().FindIndex(x => x.VisitTaskId == inDto.VisitTaskId);


            if (findindex < 3)
            {
                return -1;
            }
            else
            {
                var twoindex = taskList.OrderBy(x => x.VisitTaskNum).ToList()[2];


                result = inDto.QuestionInfo.Where(x => x.LesionType == LesionType.AlwaysNewLesions).SelectMany(x => x.TableRowInfoList)
             .Where(x => x.FristAddTaskNum >= twoindex.VisitTaskNum && x.TableQuestionList.Any(y => y.QuestionMark == QuestionMark.State && y.Answer == EvaluationOfState.Exists.GetEnumInt())).Count();

                //+ inDto.QuestionInfo.Where(x => x.LesionType == LesionType.NewLesions).SelectMany(x => x.TableRowInfoList)
                // .Where(x => x.TableQuestionList.Any(y => y.QuestionMark == QuestionMark.State && y.Answer == EvaluationOfState.Exists.GetEnumInt()))
                // .Count();
            }




            return result;
        }

        #endregion


        #region 间隔天数
        /// <summary>
        /// 获取
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<int> GetNumberOfDaysBetween(ReadingCalculateDto inDto)
        {
            if (inDto.IsBaseLine)
            {
                return -1;
            }
            var taskinfo = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).FirstNotNullAsync();
            var taskList = await GetSiteVisitForTumorList(inDto);
            var lastTask = taskList.Where(x => x.VisitTaskNum < taskinfo.VisitTaskNum && x.VisitTaskId != inDto.VisitTaskId).OrderByDescending(x => x.VisitTaskNum).FirstOrDefault();
            if (lastTask != null)
            {
                var thisTask = taskList.FirstOrDefault();
                if (thisTask != null && thisTask.StudyTime != null && lastTask.StudyTime != null)
                {
                    return (int)Math.Floor((thisTask.StudyTime.Value - lastTask.StudyTime.Value).TotalDays);
                }
                else
                {
                    return -1;
                }


            }
            else
            {
                return -1;
            }
        }

        #endregion



        #region 访视点肿瘤评估
        /// <summary>
        /// 访视点肿瘤评估
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<string> GetSiteVisitForTumorEvaluation(ReadingCalculateDto inDto)
        {
            if (inDto.IsBaseLine)
            {
                return VisitTumorEvaluation.NA.GetEnumInt();
            }

            //如果日期未知，不需要计算肿瘤评估结果；
            if (await GetNumberOfDaysBetween(inDto) == -1)
            {
                return string.Empty;
            }
            var isPD = await ChangeLastTaskSiteVisitForTumorEvaluation(inDto);
            var newLesionsCount = inDto.QuestionInfo.Where(x => x.QuestionType == QuestionType.NewLesionsCount).Select(x => x.Answer).FirstOrDefault().IsNullOrEmptyReturn0();
            var baseLineLesionsCount = inDto.QuestionInfo.Where(x => x.QuestionType == QuestionType.BaseLineLesionsCount).Select(x => x.Answer).FirstOrDefault().IsNullOrEmptyReturn0();
            var alwaysNewLesionsCount = inDto.QuestionInfo.Where(x => x.QuestionType == QuestionType.AlwaysNewLesionsCount).Select(x => x.Answer).FirstOrDefault().IsNullOrEmptyReturn0();

            if (isPD)
            {
                return VisitTumorEvaluation.PD.GetEnumInt();
            }
            else if (newLesionsCount == 0 &&
                baseLineLesionsCount == 0 &&
                alwaysNewLesionsCount == 0)
            {
                return VisitTumorEvaluation.ND.GetEnumInt();
            }
            else
            {
                return VisitTumorEvaluation.NoPD.GetEnumInt();
            }
        }

        /// <summary>
        /// 修改上一次访视结果
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<bool> ChangeLastTaskSiteVisitForTumorEvaluation(ReadingCalculateDto inDto)
        {
            var taskinfo = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).FirstNotNullAsync();
            var taskList = await GetSiteVisitForTumorList(inDto);
            var lastTask = taskList.Where(x => x.VisitTaskNum < taskinfo.VisitTaskNum && x.VisitTaskId != inDto.VisitTaskId).OrderByDescending(x => x.VisitTaskNum).FirstOrDefault();

            var baseLineTask = taskList.OrderBy(x => x.VisitTaskNum).FirstOrDefault();
            var newLesionsCountQuestionId = inDto.QuestionInfo.Where(x => x.QuestionType == QuestionType.NewLesionsCount).Select(x => x.QuestionId).FirstOrDefault();

            var isPDResult = false;

            if (lastTask != null)
            {

                #region 1、基线后第一个访视：新病灶计数≥ 2个；2、基线后第二个访视（应满足访视间隔6周以上，否则顺延）新病灶≥ 2个；
                //1、基线后第一个访视：新病灶计数≥ 2个；2、基线后第二个访视（应满足访视间隔6周以上，否则顺延）新病灶≥ 2个；


                var firstVisit = taskList.FirstOrDefault();
                if (baseLineTask != null && baseLineTask.StudyTime != null)
                {
                    //基线后第二个访视（应满足访视间隔6周以上，否则顺延）
                    var secondVisit = taskList.Where(x => x.VisitTaskNum >= 2 && x.StudyTime >= baseLineTask.StudyTime.Value.AddDays(42)).FirstOrDefault();
                    if (secondVisit != null)
                    {

                        var firstTaskNewLesionsCount = (await _readingTaskQuestionAnswerRepository.Where(x => x.VisitTaskId == firstVisit!.VisitTaskId && x.ReadingQuestionTrialId == newLesionsCountQuestionId).Select(x => x.Answer).FirstOrDefaultAsync()).IsNullOrEmptyReturn0();

                        // 第二访视数量
                        var secondVisitLesionsCount = (await _readingTaskQuestionAnswerRepository.Where(x => x.VisitTaskId == lastTask.VisitTaskId && x.ReadingQuestionTrialId == newLesionsCountQuestionId).Select(x => x.Answer).FirstOrDefaultAsync()).IsNullOrEmptyReturn0();

                        // 判断是否是当前访视  当前访视还未入库
                        if (secondVisit.VisitTaskId == inDto.VisitTaskId)
                        {
                            secondVisitLesionsCount = (inDto.QuestionInfo.Where(x => x.QuestionType == QuestionType.NewLesionsCount).Select(x => x.Answer).FirstOrDefault()).IsNullOrEmptyReturn0();
                        }

                        if (firstTaskNewLesionsCount >= 2 && secondVisitLesionsCount >= 2)
                        {
                            isPDResult = true;
                        }
                    }

                    #endregion



                    if (lastTask.VisitTaskNum >= 2m)
                    {

                        var lastTasknewLesionsCount = (await _readingTaskQuestionAnswerRepository.Where(x => x.VisitTaskId == lastTask.VisitTaskId && x.ReadingQuestionTrialId == newLesionsCountQuestionId).Select(x => x.Answer).FirstOrDefaultAsync()).IsNullOrEmptyReturn0();
                        var thisVisitTaskNewLesionsCount = (inDto.QuestionInfo.Where(x => x.QuestionType == QuestionType.NewLesionsCount).Select(x => x.Answer).FirstOrDefault()).IsNullOrEmptyReturn0();

                        var thisVisitTask = taskList.LastOrDefault();

                        if (thisVisitTask != null && thisVisitTask.StudyTime != null && lastTask.StudyTime != null &&


                            lastTasknewLesionsCount >= 2 && thisVisitTaskNewLesionsCount >= 2 && lastTask.StudyTime.Value.AddDays(42) <= thisVisitTask.StudyTime)
                        {
                            isPDResult = true;
                        }
                    }
                }

            }
            if (isPDResult)
            {
                var visitForTumorEvaluationQuestionId = inDto.QuestionInfo.Where(x => x.QuestionType == QuestionType.SiteVisitForTumorEvaluation).Select(x => x.QuestionId).FirstOrDefault();

                if (lastTask != null)
                {
                    await _readingTaskQuestionAnswerRepository.BatchUpdateNoTrackingAsync(x => x.VisitTaskId == lastTask.VisitTaskId && x.ReadingQuestionTrialId == visitForTumorEvaluationQuestionId, x => new ReadingTaskQuestionAnswer
                    {
                        Answer = VisitTumorEvaluation.PD.GetEnumInt(),
                    });
                }
            }


            return isPDResult;
        }

        #endregion

        /// <summary>
        /// 获取访视日期信息
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<List<SiteVisitForTumor>> GetSiteVisitForTumorList(ReadingCalculateDto inDto)
        {


            if (siteVisitForTumorList == null)
            {
                var taskinfo = await _visitTaskRepository.Where(x => x.Id == inDto.VisitTaskId).FirstNotNullAsync();
                siteVisitForTumorList = await _visitTaskRepository.Where(x => (x.ReadingCategory == ReadingCategory.Visit &&
                       x.TrialReadingCriterionId == taskinfo.TrialReadingCriterionId &&
                       x.ArmEnum == taskinfo.ArmEnum &&
                       x.IsAnalysisCreate == inDto.IsAnalysisCreate &&
                       x.SubjectId == taskinfo.SubjectId && x.ReadingTaskState == ReadingTaskState.HaveSigned && x.VisitTaskNum <= taskinfo.VisitTaskNum && x.TaskState == TaskState.Effect && x.ArmEnum == taskinfo.ArmEnum
                       ) || x.Id == inDto.VisitTaskId).OrderByDescending(x => x.VisitTaskNum).Select(x => new SiteVisitForTumor()
                       {
                           VisitTaskId = x.Id,
                           VisitTaskNum = x.VisitTaskNum,
                           SubjectVisitId = x.SourceSubjectVisitId,
                       }).ToListAsync();

                var visitIds = siteVisitForTumorList.Select(x => x.SubjectVisitId).ToList();
                // Dicom 用NM  非dicom 用骨扫描 (BoneScan)
                List<VisitStudyTime> visitStudies = await _dicomStudyRepository.Where(x => visitIds.Contains(x.SubjectVisitId) && x.ModalityForEdit == "BoneScan").Select(x => new VisitStudyTime()
                {
                    SubjectVisitId = x.SubjectVisitId,
                    StudyTime = x.StudyTime

                }).ToListAsync();

                visitStudies.AddRange(
                    await _noneDicomStudyRepository.Where(x => visitIds.Contains(x.SubjectVisitId) && x.Modality == "BoneScan").Select(x => new VisitStudyTime()
                    {
                        SubjectVisitId = x.SubjectVisitId,
                        StudyTime = x.ImageDate

                    }).ToListAsync()
                );

                visitStudies = visitStudies.Where(x => x.StudyTime != null).ToList();

                foreach (var item in siteVisitForTumorList)
                {
                    item.StudyTime = visitStudies.Where(x => x.SubjectVisitId == item.SubjectVisitId).Max(x => x.StudyTime);
                }

            }

            return siteVisitForTumorList;


        }


        public async Task<GetReportVerifyOutDto> GetReportVerify(GetReportVerifyInDto inDto)
        {
            return new GetReportVerifyOutDto()
            {

            };
        }

        public async Task VerifyVisitTaskQuestions(VerifyVisitTaskQuestionsInDto inDto)
        {

            if (await _readingTaskQuestionAnswerRepository.AnyAsync(x => x.ReadingQuestionTrial.QuestionType == QuestionType.ImageQualityAssessment && x.VisitTaskId == inDto.VisitTaskId && x.Answer == ImageQualityEvaluation.Abnormal.GetEnumInt()))
            {

                return;
            }

            var tableAnswerList = await _readingTableQuestionAnswerRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId && (x.Answer == string.Empty || x.Answer == null)
       && x.ReadingTableQuestionTrial.QuestionMark == QuestionMark.State
       )
           .Select(x => new
           {
               x.ReadingQuestionTrial.OrderMark,
               x.RowIndex,
               QuestionMark = x.ReadingTableQuestionTrial.QuestionMark,
               Answer = x.Answer,

           }).ToListAsync();


            string errorMassage = string.Empty;

            var rowAnswerList = await _readingTableAnswerRowInfoRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId && x.ReadingQuestionTrial.LesionType != LesionType.BaselineLesions && (x.MeasureData == string.Empty || x.MeasureData == null))
                .Select(x => new
                {
                    x.ReadingQuestionTrial.OrderMark,
                    x.RowIndex,
                    x.Id,
                }).ToListAsync();


            var unableEvaluateRowIds = await _readingTableQuestionAnswerRepository.Where(x => x.VisitTaskId == inDto.VisitTaskId && x.Answer == EvaluationOfState.UnableEvaluate.GetEnumInt()
             && x.ReadingTableQuestionTrial.QuestionMark == QuestionMark.State
            )
             .Select(x => x.RowId).Distinct().ToListAsync();


            List<string> measureDataList = rowAnswerList.Where(x => !unableEvaluateRowIds.Contains(x.Id)).Select(x => x.OrderMark + x.RowIndex.GetLesionMark()).ToList();

            List<string> stateIsNullList = tableAnswerList.Select(x => x.OrderMark + x.RowIndex.GetLesionMark()).ToList();


            List<string> allExists = measureDataList.Intersect(stateIsNullList).ToList();
            measureDataList = measureDataList.Except(allExists).ToList();
            stateIsNullList = stateIsNullList.Except(allExists).ToList();



            if (measureDataList.Count() > 0)
            {
                errorMassage += _localizer["ReadingCalculate_NoMarker", string.Join(',', measureDataList)] + ",";
            }


            if (tableAnswerList.Count > 0)
            {
                errorMassage += _localizer["ReadingCalculate_StatusIsEmpty", string.Join(',', stateIsNullList)] + ",";
            }

            if (allExists.Count > 0)
            {
                errorMassage += _localizer["ReadingCalculate_NoMarkerEmpty", string.Join(',', stateIsNullList)] + ",";
            }


            if (errorMassage != string.Empty)
            {
                errorMassage = _localizer["ReadingCalculate_questionable"] + errorMassage;
                throw new BusinessValidationFailedException(errorMassage);
            }
        }
    }
}