using DocumentFormat.OpenXml.Office.SpreadSheetML.Y2023.MsForms;
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 Newtonsoft.Json;

namespace IRaCIS.Core.Application.Service.ReadingCalculate
{

    [ApiExplorerSettings(GroupName = "Reading")]
    public class MRECISTHCCCalculateService(IRepository<ReadingTableQuestionAnswer> _readingTableQuestionAnswerRepository,
        IRepository<VisitTask> _visitTaskRepository,
        IRepository<ReadingQuestionCriterionTrial> _readingQuestionCriterionTrialRepository,
        IRepository<ReadingTableQuestionTrial> _readingTableQuestionTrialRepository,
        IRepository<ReadingTableAnswerRowInfo> _readingTableAnswerRowInfoRepository,
        IRepository<ReadingQuestionTrial> _readingQuestionTrialRepository,
        IRepository<ReadingGlobalTaskInfo> _readingGlobalTaskInfoRepository,
        IRepository<OrganInfo> _organInfoRepository,
        IRepository<SubjectVisit> _subjectVisitRepository,
        IRepository<TumorAssessment_RECIST1Point1> _tumorAssessmentRepository,
        IGeneralCalculateService _generalCalculateService,
        IRepository<ReadingTaskQuestionAnswer> _readingTaskQuestionAnswerRepository, IMapper _mapper, IUserInfo _userInfo, IStringLocalizer _localizer) : BaseService, ICriterionCalculateService
    {

        /// <summary>
        /// 阅片导入
        /// </summary>
        /// <returns></returns>
        public async Task ReadingImport()
        {
        }

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

        #region 临时对象 单个请求的生命周期 避免重复查询数据库

        private List<VisitTaskAnswerInfo> visitTaskAnswerList;

        /// <summary>
        /// 获取Sod的值
        /// </summary>
        private decimal? sODData;

        private string nAString = "NA";
        #endregion

        #region 删除病灶获取起始病灶序号
        /// <summary>
        /// 删除病灶获取起始病灶序号（RECIST1Point1 固定是1）
        /// </summary>
        /// <returns></returns>
        public async Task<int> GetDeleteLesionStatrIndex(DeleteReadingRowAnswerInDto inDto)
        {
            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);

            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).ToListAsync();
            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();
            result.LesionCountList = tableAnsweRowInfos.GroupBy(x => x.LesionType).Select(x => new LesionDto
            {
                LesionType = x.Key!.Value,
                Count = x.ToList().Count()
            }).ToList();
            var answers = await _readingTaskQuestionAnswerRepository.Where(x => visitTaskIds.Contains(x.VisitTaskId)).ToListAsync();
            var tableAnswers = await _readingTableQuestionAnswerRepository.Where(x => visitTaskIds.Contains(x.VisitTaskId)).ToListAsync();
            var globalanswerList = await _readingGlobalTaskInfoRepository.Where(x => visitTaskIds.Contains(x.TaskId) && x.GlobalVisitTask.TaskState == TaskState.Effect && x.Answer != string.Empty).Select(x => new Globalanswer()
            {
                TaskId = x.TaskId,
                VisitTaskNum = x.GlobalVisitTask.VisitTaskNum,
                QuestionId = x.QuestionId,
                Answer = x.Answer
            }).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,
            };

            // 第一级

            List<ReadingReportDto> questions = await _generalCalculateService.GetReadingReportQuestion
     (
      questionList,
      taskInfoList,
     globalanswerList,
      answers,
      tableAnsweRowInfos,
       tableQuestionList,
       alltableAnsweRowInfos,
       tableAnswers,
      organInfos,
       needChangeType
     );



            result.TaskQuestions = questions;



            return result;

        }
        #endregion

        /// <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>
        /// 获取报告验证的信息(这里每个标准可能不一样 返回用object)
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<GetReportVerifyOutDto> GetReportVerify(GetReportVerifyInDto inDto)
        {
            return new GetReportVerifyOutDto()
            {
                TumorEvaluate = await this.GetReportTumor(inDto.VisitTaskId),
                IsExistDisease = await this.GetReportIsExistDisease(inDto.VisitTaskId),

            };
        }


        /// <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>()
            {
				//靶病灶径线之和（SOD）
				new ReadingCalculateData (){QuestionType=QuestionType.SOD,GetDecimalNullFun=GetSODData},

				//非淋巴结靶病灶长径之和
				new ReadingCalculateData (){QuestionType=QuestionType.SumOfDiameter,GetDecimalNullFun=GetSumOfDiameter},

				//与基线SOD相比变化量（mm）
			    new ReadingCalculateData (){QuestionType=QuestionType.SODChange,GetDecimalNullFun=GetSODChange},

				//与基线访视相比SOD变化百分比
			    new ReadingCalculateData (){QuestionType=QuestionType.SODPercent,GetDecimalNullFun=GetSODPercent},

				//与整个访视期间SOD最低点相比增加的值（mm）  //其他任务需要改
			    new ReadingCalculateData (){QuestionType=QuestionType.LowestIncrease,GetDecimalNullFun=GetLowestIncrease,/*ChangeAllTaskFun=ChangeAllLowestIncrease*/},
		
			    //与整个访视期间SOD最低点相比增加的百分比   //其他任务需要改
			    new ReadingCalculateData (){QuestionType=QuestionType.LowPercent,GetDecimalNullFun=GetLowPercent,/*ChangeAllTaskFun=ChangeAllLowPercent*/},

				//整个访视期间SOD最低点访视名称            //其他任务需要改
			    new ReadingCalculateData (){QuestionType=QuestionType.LowVisit,GetStringFun=GetLowVisit,/*ChangeAllTaskFun=ChangeAllLowVisitName*/},

		    	//是否存在非淋巴结靶病灶
			    new ReadingCalculateData (){QuestionType=QuestionType.IsLymphTarget,GetStringFun=GetIsLymphTarget},

			    //是否存在淋巴结靶病灶且该病灶比上一访视短径增加5MM以上
			    new ReadingCalculateData (){QuestionType=QuestionType.IsAddFive,GetStringFun=GetIsAddFive},

			    //被评估为NE的单个靶病灶
			    new ReadingCalculateData (){QuestionType=QuestionType.NETarget,GetStringFun=GetNETarget},

				//靶病灶评估
			    new ReadingCalculateData (){QuestionType=QuestionType.TargetLesion,GetStringFun=GetTargetLesionEvaluate},

				//非靶病灶评估
			    new ReadingCalculateData (){QuestionType=QuestionType.NoTargetLesion,GetStringFun=GetNoTargetLesionEvaluate},

				//是否存在新病灶
			    new ReadingCalculateData (){QuestionType=QuestionType.NewLesions,GetStringFun=GetNewLesionEvaluate},

			    //整体肿瘤评估
			    new ReadingCalculateData (){QuestionType=QuestionType.Tumor,GetStringFun=GetTumor},

				 //是否存在疾病
			    new ReadingCalculateData (){QuestionType=QuestionType.ExistDisease,GetStringFun=GetIsExistDisease},

            };

            // 没有靶病灶只计算最后几个
            if (inDto.QuestionInfo.Where(x => x.LesionType == LesionType.TargetLesion).Sum(x => x.TableRowInfoList.Count()) == 0)
            {

                List<QuestionType> questionTypes = new List<QuestionType>()
                {
                    QuestionType.TargetLesion,
                    QuestionType.NoTargetLesion,
                    QuestionType.NewLesions,
                    QuestionType.Tumor,
                    QuestionType.ExistDisease,
                };

                // 没有靶病灶就删除其他几个答案的值
                var isNeedDeleteTypes = calculateList.Where(x => !questionTypes.Contains(x.QuestionType)).Select(x => x.QuestionType).ToList();


                var isNeedDeleteIds = inDto.QuestionInfo.Where(x => x.QuestionType != null && isNeedDeleteTypes.Contains(x.QuestionType.Value)).Select(x => x.QuestionId).ToList();

                await _readingTaskQuestionAnswerRepository.BatchUpdateNoTrackingAsync(x => x.VisitTaskId == inDto.VisitTaskId && isNeedDeleteIds.Contains(x.ReadingQuestionTrialId), x => new ReadingTaskQuestionAnswer
                {
                    Answer = string.Empty
                });



                calculateList = calculateList.Where(x => questionTypes.Contains(x.QuestionType)).ToList();





            }

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

            var typeNAList = new List<QuestionType>
            {
                QuestionType.SODChange,
                QuestionType.SODPercent,
                QuestionType.LowestIncrease,
                QuestionType.LowPercent,
            };

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

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

                        #region 计算答案
                        if (calculate.GetDecimalFun != null)
                        {
                            item.Answer = (await calculate.GetDecimalFun(inDto)).ToString();

                        }
                        else if (calculate.GetDecimalNullFun != null)
                        {
                            var value = await calculate.GetDecimalNullFun(inDto);
                            if (value == null)
                            {
                                if (typeNAList.Contains(item.QuestionType ?? QuestionType.SOD))
                                {
                                    item.Answer = nameof(YesOrNoOrNa.NA);

                                }
                                else
                                {
                                    item.Answer = this.nAString;

                                }

                            }
                            else

                            {
                                item.Answer = value == null ? string.Empty : value.Value.ToString();
                            }
                        }
                        else if (calculate.GetStringFun != null)
                        {
                            item.Answer = await calculate.GetStringFun(inDto);
                        }
                        #endregion
                        // 修改修约小数位数

                        List<ValueOfType?> valueOfTypes = new List<ValueOfType?>() {

                               ValueOfType.Decimals,
                               ValueOfType.Percentage
                            };

                        if (inDto.DigitPlaces != -1)
                        {
                            try
                            {

                                if (valueOfTypes.Contains(item.ValueType))
                                {
                                    item.Answer = decimal.Round(decimal.Parse(item.Answer ?? "0"), 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


        }


        /// <summary>
        /// 获取报告整体整体评估
        /// </summary>
        /// <param name="visitTaskId"></param>
        /// <returns></returns>
        public async Task<string> GetReportTumor(Guid visitTaskId)
        {
            return await GetTumor(await _generalCalculateService.GetReadingCalculateDto(visitTaskId));
        }

        /// <summary>
        /// 获取报告是否存在疾病
        /// </summary>
        /// <param name="visitTaskId"></param>
        /// <returns></returns>
        public async Task<string> GetReportIsExistDisease(Guid visitTaskId)
        {
            return await GetIsExistDisease(await _generalCalculateService.GetReadingCalculateDto(visitTaskId));
        }

        /// <summary>
        /// 验证访视提交
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        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,
                                            x.ReadingTableQuestionTrial.QuestionMark,
                                            x.Answer,
                                        }).ToListAsync();

            // 错误信息
            string errorMassage = string.Empty;
            var rowAnswerList = await _readingTableAnswerRowInfoRepository.Where(x =>
               x.SplitOrMergeType != SplitOrMergeType.Merge && x.SplitOrMergeType != SplitOrMergeType.Merged &&
            x.VisitTaskId == inDto.VisitTaskId && (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 == TargetState.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 (stateIsNullList.Count > 0)
            {
                // 状态为空
                errorMassage += _localizer["ReadingCalculate_StatusIsEmpty", string.Join(',', stateIsNullList)] + ",";
            }

            if (allExists.Count > 0)
            {
                // 未做标记且状态为空
                errorMassage += _localizer["ReadingCalculate_NoMarkerEmpty", string.Join(',', allExists)] + ",";
            }


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



        #region 将上一次的访视病灶添加到这一次

        /// <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.DoctorUserId == taskinfo.DoctorUserId &&
                     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 =>
                    {
                        switch (x.SplitOrMergeType)
                        {
                            case SplitOrMergeType.Merge:
                            case SplitOrMergeType.Merged:
                                x.SplitOrMergeType = SplitOrMergeType.Merged;
                                break;
                            case SplitOrMergeType.MergeMain:
                            case SplitOrMergeType.MergeMained:
                                x.SplitOrMergeType = SplitOrMergeType.MergeMained;
                                break;
                            default:
                                x.SplitOrMergeType = null;
                                break;
                        }
                        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).FirstOrDefault()?.Id;
                        x.MergeRowId = tableRowAnswers.Where(y => y.OriginalId == x.MergeRowId).FirstOrDefault()?.Id;

                    });

                    List<QuestionMark?> notNeedCopyMarks = new List<QuestionMark?>()
                    {
                         QuestionMark.MajorAxis,
                         QuestionMark.ShortAxis,
                         QuestionMark.State,

                    };

                    var mergedRowIds = tableRowAnswers.Where(x => x.SplitOrMergeType == SplitOrMergeType.Merged).Select(x => x.Id).ToHashSet();
                    var tableAnswers = copyTableAnswers
                        .Select(x =>
                        {
                            var rowId = tableRowAnswers.Where(y => y.OriginalId == x.RowId).Select(y => y.Id).FirstOrDefault();
                            var answer = notNeedCopyMarks.Contains(x.QuestionMark) ? string.Empty : x.Answer;
                            if (mergedRowIds.Contains(rowId) && (x.QuestionMark == QuestionMark.State || x.QuestionMark == QuestionMark.ShortAxis || x.QuestionMark == QuestionMark.MajorAxis))
                            {
                                answer = x.Answer;
                            }

                            return new ReadingTableQuestionAnswer
                            {
                                Id = NewId.NextGuid(),
                                Answer = answer,
                                QuestionId = x.QuestionId,
                                RowIndex = x.RowIndex,
                                RowId = rowId,
                                TableQuestionId = x.TableQuestionId,
                                TrialId = x.TrialId,
                                VisitTaskId = visitTaskId,
                            };
                        })
                        .ToList();




                    var addList = _mapper.Map<List<ReadingTableAnswerRowInfo>>(tableRowAnswers);
                    await _generalCalculateService.CopyHistoryAnswer(taskinfo, addList, tableAnswers);
                    await _readingTableAnswerRowInfoRepository.AddRangeAsync(addList);
                    await _readingTableQuestionAnswerRepository.AddRangeAsync(tableAnswers);
                    await _readingTableQuestionAnswerRepository.SaveChangesAsync();

                }
            }
            else if(!(await _readingTableQuestionAnswerRepository.AnyAsync(x => x.VisitTaskId == visitTaskId)))
            {
                // 基线任务
                // 如果是基线 要把res1.1的病灶复制过来
                var recistTask = await _visitTaskRepository.Where(x =>
                x.TrialId == taskinfo.TrialId &&
                x.TaskState == TaskState.Effect &&
                x.ReadingTaskState == ReadingTaskState.HaveSigned &&
                x.TrialReadingCriterion.CriterionType == CriterionType.RECIST1Point1 &&
                x.SubjectId == taskinfo.SubjectId &&
                x.SourceSubjectVisitId == taskinfo.SourceSubjectVisitId &&
                x.DoctorUserId==taskinfo.DoctorUserId).FirstOrDefaultAsync();
                if (recistTask != null)
                {
                    _userInfo.AuditIdentification = "HCC";


                    var trialReadingCriterion=await _readingQuestionCriterionTrialRepository.Where(x => x.Id == taskinfo.TrialReadingCriterionId).FirstOrDefaultAsync();

                    var tableRowAnswers = await _readingTableAnswerRowInfoRepository.Where(x => x.VisitTaskId == recistTask.Id).ProjectTo<CopyTableAnswerRowInfo>(_mapper.ConfigurationProvider).ToListAsync();

                    var tableQuestionList = await _readingTableQuestionTrialRepository.Where(x => x.TrialCriterionId == taskinfo.TrialReadingCriterionId).ToListAsync();
                    foreach (var rowInfo in tableRowAnswers)
                    {
                        var question = await _readingQuestionTrialRepository.Where(x => x.ReadingQuestionCriterionTrialId == taskinfo.TrialReadingCriterionId && x.LesionType == rowInfo.LesionType).FirstOrDefaultAsync();

                        var organ = await _organInfoRepository.Where(x => x.Id == rowInfo.OrganInfoId).FirstOrDefaultAsync();
                        if (organ != null)
                        {
                            var newOrgan = await _organInfoRepository.Where(x => x.SystemCriterionId == trialReadingCriterion.ReadingQuestionCriterionSystemId &&
                          x.Classification == organ.Classification &&
                          x.Part == organ.Part &&
                          x.TULOC == organ.TULOC &&
                          x.TULAT == organ.TULAT &&
                          x.IsLymphNodes == organ.IsLymphNodes
                        ).FirstOrDefaultAsync();

                            if (newOrgan != null)
                            {
                                rowInfo.OrganInfoId = newOrgan.Id;
                            }
                        }
                        if(rowInfo.MeasureData!=null)
                        {
                            rowInfo.MeasureData = rowInfo.MeasureData.Replace(recistTask.Id.ToString(), taskinfo.Id.ToString());
                        }
                       
                        rowInfo.VisitTaskId = visitTaskId;
                        rowInfo.IsCurrentTaskAdd = true;
                        rowInfo.Id = NewId.NextGuid();
                        rowInfo.FristAddTaskId = visitTaskId;
                        rowInfo.QuestionId = question == null ? default(Guid) : question.Id;
                        rowInfo.RowMark = question?.OrderMark + rowInfo.RowIndex.GetLesionMark();
                    }
                 


                    var recistTableAnswers = await _readingTableQuestionAnswerRepository.Where(x => x.VisitTaskId == recistTask.Id).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 portalOrgan = await _organInfoRepository.Where(x => x.SystemCriterionId == trialReadingCriterion.ReadingQuestionCriterionSystemId &&
                     
                          x.Part == "肝门淋巴结" &&
                      
                          x.IsLymphNodes == IsLymph.Yes
                        ).FirstOrDefaultAsync();

                        foreach (var item in recistTableAnswers)
                        {
                            var rowinfo = tableRowAnswers.Where(y => y.OriginalId == item.RowId).FirstOrDefault();
                            if (rowinfo != null)
                            {
                                item.QuestionId = rowinfo.QuestionId;


                                if (portalOrgan != null && rowinfo.OrganInfoId == portalOrgan.Id)
                                {
                                    var IslymphNode = recistTableAnswers.Where(x => x.RowId == item.RowId && x.QuestionMark == QuestionMark.IsLymph).Select(x => x.Answer).FirstIsNullReturnEmpty().EqEnum(YesOrNoOrNa.Yes);
                                    var minorAxis = recistTableAnswers.Where(x => x.RowId == item.RowId && x.QuestionMark == QuestionMark.ShortAxis).Select(x => x.Answer).FirstIsNullReturnEmpty().IsNullOrEmptyReturn0();

                                    var iSbetween15and20 = minorAxis >= 15 && minorAxis < 20;
                                    if (item.QuestionMark == QuestionMark.State && IslymphNode && iSbetween15and20 && rowinfo.LesionType == LesionType.TargetLesion)
                                    {
                                        item.Answer = string.Empty;
                                    }
                                }
                               
                            }
                          

                            item.TableQuestionId = tableQuestionList.Where(x => x.ReadingQuestionId == item.QuestionId && x.QuestionMark == item.QuestionMark).Select(x => x.Id).FirstOrDefault();
                        }

                    recistTableAnswers = recistTableAnswers.Where(x => x.TableQuestionId != default(Guid)).ToList();

                        List<QuestionMark?> notNeedCopyMarks = new List<QuestionMark?>()
                        {

                        };
                     
                        var tableAnswers = recistTableAnswers.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();

                    // 添加 典型肝内病灶 默认值
                    tableRowAnswers.ForEach(x =>
                    {
                        var tableQuestion = tableQuestionList.Where(y => y.ReadingQuestionId == x.QuestionId && y.QuestionMark == QuestionMark.TypicalIntrahepaticLesion).FirstOrDefault();
                        if (tableQuestion != null)
                        {
                            tableAnswers.Add(new ReadingTableQuestionAnswer()
                            {
                                Id = NewId.NextGuid(),
                                Answer = ((int)(object)ReadingYesOrNo.No).ToString(),
                                QuestionId = x.QuestionId,
                                RowIndex = x.RowIndex,
                                RowId = x.Id,
                                TableQuestionId = tableQuestion.Id,
                                TrialId = x.TrialId,
                                VisitTaskId = visitTaskId,
                            });
                        }
                    });



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

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

                    addList.ForEach(x =>
                    {
                        x.MergeRow = null;
                        x.SplitRow = null;

                    });
                    await _readingTableQuestionAnswerRepository.SaveChangesAsync();
                }



            }

            return new AddTaskLesionAnswerFromLastTaskOutDto()
            {

                IsBaseLine = taskinfo.SourceSubjectVisitId == baseLineVisitId,
            };

        }
        #endregion

        #region 获取SOD

        /// <summary>
        /// 获取SOD
        /// </summary>
        /// <remarks>
        /// 靶病灶径线之和（SOD）
        /// 非淋巴结的长径 和淋巴结的短径
        /// </remarks>
        /// <returns></returns>
        public async Task<decimal?> GetSODData(ReadingCalculateDto inDto)
        {
            if (sODData != null)
            {
                return sODData.Value;
            }

            var tableQuestion = inDto.QuestionInfo.Where(x => x.LesionType == LesionType.TargetLesion).SelectMany(x => x.TableRowInfoList).ToList();

            if (tableQuestion.Count() == 0)
            {
                return null;
            }

            decimal result = 0;

            foreach (var item in tableQuestion)
            {
                if (item.TableQuestionList.Any(x => x.QuestionMark == QuestionMark.IsLymph && x.Answer.EqEnum(YesOrNoOrNa.Yes)))
                {
                    // 淋巴结的短径
                    result += (item.TableQuestionList.Where(x => x.QuestionMark == QuestionMark.ShortAxis).Select(x => x.Answer).FirstOrDefault()).IsNullOrEmptyReturn0();
                }

                if (item.TableQuestionList.Any(x => x.QuestionMark == QuestionMark.IsLymph && x.Answer.EqEnum(YesOrNoOrNa.No)))
                {
                    // 非淋巴结的长径
                    result += item.TableQuestionList.Where(x => x.QuestionMark == QuestionMark.MajorAxis).Select(x => x.Answer).FirstOrDefault().IsNullOrEmptyReturn0();
                }
            }

            sODData = result;

            return sODData.Value;



        }
        #endregion

        #region 非淋巴结靶病灶长径之和
        /// <summary>
        /// 非淋巴结靶病灶长径之和
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<decimal?> GetSumOfDiameter(ReadingCalculateDto inDto)
        {
            var tableQuestion = inDto.QuestionInfo.Where(x => x.LesionType == LesionType.TargetLesion).SelectMany(x => x.TableRowInfoList).ToList();

            if (tableQuestion.Count() == 0)
            {
                return null;
            }

            decimal result = 0;

            foreach (var item in tableQuestion)
            {
                if (item.TableQuestionList.Any(x => x.QuestionMark == QuestionMark.IsLymph && x.Answer.EqEnum(YesOrNoOrNa.No)))
                {
                    // 非淋巴结的长径
                    result += item.TableQuestionList.Where(x => x.QuestionMark == QuestionMark.MajorAxis).Select(x => x.Answer).FirstOrDefault().IsNullOrEmptyReturn0();
                }
            }


            return result;
        }
        #endregion

        #region  与基线SOD相比变化量（mm）
        /// <summary>
        /// 与基线SOD相比变化量（mm）
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<decimal?> GetSODChange(ReadingCalculateDto inDto)
        {

            var value = await GetSODData(inDto);

            if (value == null || inDto.IsBaseLine)
            {
                return null;
            }
            return value.NullChange0() - await GetBaseLineSOD(inDto);
        }
        #endregion

        #region 与基线访视相比SOD变化百分比
        /// <summary>
        /// 与基线访视相比SOD变化百分比
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<decimal?> GetSODPercent(ReadingCalculateDto inDto)
        {
            var thisSOD = await GetSODData(inDto);

            if (thisSOD == null || inDto.IsBaseLine)
            {
                return null;
            }

            var baseLineSOD = await GetBaseLineSOD(inDto);

            if (baseLineSOD == 0)
            {
                return 100;
            }
            else
            {
                return (thisSOD.NullChange0() - baseLineSOD) * 100 / baseLineSOD;
            }
        }
        #endregion

        #region 与整个访视期间SOD最低点相比增加的值（mm）
        /// <summary>
        /// 与整个访视期间SOD最低点相比增加的值（mm）
        /// </summary>
        /// <param name="inDto"></param>
        /// <remarks>
        /// 要更新之前的
        /// </remarks>
        /// <returns></returns>
        public async Task<decimal?> GetLowestIncrease(ReadingCalculateDto inDto)
        {
            var value = await GetSODData(inDto);
            if (value == null || inDto.IsBaseLine)
            {
                return null;
            }
            var decimalAnswerList = await GetLowSODVisit(inDto);
            var minSOD = decimalAnswerList.OrderBy(x => x.SOD).Select(x => x.SOD).FirstOrDefault();
            return value.NullChange0() - minSOD;
        }
        #endregion

        #region 与整个访视期间SOD最低点相比增加的百分比
        /// <summary>
        /// 与整个访视期间SOD最低点相比增加的百分比
        /// </summary>
        /// <param name="inDto"></param>
        /// <remarks>
        /// 要更新之前的
        /// </remarks>
        /// <returns></returns>
        public async Task<decimal?> GetLowPercent(ReadingCalculateDto inDto)
        {
            var thisSOD = await GetSODData(inDto);
            if (thisSOD == null || inDto.IsBaseLine)
            {
                return null;
            }
            var decimalAnswerList = await GetLowSODVisit(inDto);
            var minSOD = decimalAnswerList.OrderBy(x => x.SOD).Select(x => x.SOD).FirstOrDefault();

            if (minSOD == 0)
            {
                return 100;
            }
            else
            {
                return (thisSOD.NullChange0() - minSOD) * 100 / minSOD;
            }


        }
        #endregion

        #region 整个访视期间SOD最低点访视名称
        /// <summary>
        /// 整个访视期间SOD最低点访视名称
        /// </summary>
        /// <param name="inDto"></param>
        /// <remarks>
        /// 要更新之前的
        /// </remarks>
        /// <returns></returns>
        public async Task<string> GetLowVisit(ReadingCalculateDto inDto)
        {
            if (inDto.IsBaseLine)
            {
                return nameof(YesOrNoOrNa.NA);
            }
            var targetCount = inDto.QuestionInfo.Where(x => x.LesionType == LesionType.TargetLesion).SelectMany(x => x.TableRowInfoList).Count();
            if (targetCount == 0)
            {
                return nameof(YesOrNoOrNa.NA);
            }

            var decimalAnswerList = await GetLowSODVisit(inDto);
            return decimalAnswerList.OrderBy(x => x.SOD).Select(x => x.BlindName).FirstOrDefault() ?? string.Empty;
        }
        #endregion

        #region 是否存在非淋巴结靶病灶
        /// <summary>
        /// 是否存在非淋巴结靶病灶
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<string> GetIsLymphTarget(ReadingCalculateDto inDto)
        {
            var result = IsLymph.No.GetEnumInt();
            var tableQuestion = inDto.QuestionInfo.Where(x => x.LesionType == LesionType.TargetLesion).SelectMany(x => x.TableRowInfoList).ToList();

            foreach (var item in tableQuestion)
            {
                if (item.TableQuestionList.Any(x => x.QuestionMark == QuestionMark.IsLymph && x.Answer.EqEnum(IsLymph.No)))
                {
                    result = IsLymph.Yes.GetEnumInt();
                }
            }



            return result;
        }
        #endregion

        #region 是否存在淋巴结靶病灶且该病灶比上一访视短径增加5MM以上
        /// <summary>
        ///  是否存在淋巴结靶病灶且该病灶比上一访视短径增加5MM以上
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<string> GetIsAddFive(ReadingCalculateDto inDto)
        {
            if (inDto.IsBaseLine)
            {
                return YesOrNoOrNa.NA.GetEnumInt();
            }
            var addFiveList = await GetIsAddFiveRowIndexs(inDto);
            var isExists = addFiveList.Count() > 0 ? true : false;

            return isExists ? YesOrNoOrNa.Yes.GetEnumInt() : YesOrNoOrNa.No.GetEnumInt();

        }

        /// <summary>
        /// 获取存在淋巴结靶病灶且该病灶比上一访视短径增加5MM以上的病灶
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<List<decimal>> GetIsAddFiveRowIndexs(ReadingCalculateDto inDto)
        {
            List<decimal> result = new List<decimal>();
            var LastVisitTaskId = await this.GetLastVisitTaskId(inDto);
            var questionIds = inDto.QuestionInfo.Where(x => x.LesionType == LesionType.TargetLesion).Select(x => x.QuestionId).ToList();
            var lastQuestionAsnwer = await _readingTableQuestionAnswerRepository.Where(x => x.VisitTaskId == LastVisitTaskId && questionIds.Contains(x.QuestionId)).Include(x => x.ReadingQuestionTrial).Include(x => x.ReadingTableQuestionTrial).ToListAsync();
            var rowIndexs = lastQuestionAsnwer.Where(x => x.ReadingTableQuestionTrial.QuestionMark == QuestionMark.IsLymph && x.Answer.EqEnum(YesOrNoOrNa.Yes)).Select(x => x.RowIndex).Distinct().OrderBy(x => x).ToList();
            var thisQuestionAsnwer = inDto.QuestionInfo.Where(x => x.LesionType == LesionType.TargetLesion).SelectMany(x => x.TableRowInfoList).ToList();
            foreach (var item in rowIndexs)
            {
                var lastValue = lastQuestionAsnwer.Where(x => x.RowIndex == item && x.ReadingTableQuestionTrial.QuestionMark == QuestionMark.ShortAxis).Select(x => x.Answer).FirstOrDefault().IsNullOrEmptyReturn0();

                var thisRowData = thisQuestionAsnwer.Where(x => x.RowIndex == item).SelectMany(x => x.TableQuestionList).ToList();
                var thisValue = thisRowData.Where(x => x.QuestionMark == QuestionMark.ShortAxis).Select(x => x.Answer).FirstOrDefault().IsNullOrEmptyReturn0();

                if (thisValue - lastValue >= 5)
                {
                    result.Add(item);
                }
            }

            return result;
        }
        #endregion

        #region 被评估为NE的单个靶病灶
        /// <summary>
        /// 被评估为NE的单个靶病灶
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<string> GetNETarget(ReadingCalculateDto inDto)
        {
            if (inDto.IsBaseLine)
            {
                return ExistOrNA.NA.GetEnumInt();
            }

            var result = inDto.QuestionInfo.Where(x => x.LesionType == LesionType.TargetLesion).SelectMany(x => x.TableRowInfoList).ToList().Any(x => x.TableQuestionList.Any(y =>
           y.QuestionMark == QuestionMark.State && y.Answer.EqEnum(TargetState.UnableEvaluate)));

            return result ? ExistOrNA.Exist.GetEnumInt() : ExistOrNA.NotExist.GetEnumInt();
        }
        #endregion

        #region 整体肿瘤评估

        /// <summary>
        /// 整体肿瘤评估
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<string> GetTumor(ReadingCalculateDto inDto)
        {

            if (inDto.IsBaseLine)
            {
                return OverallAssessment.NA.GetEnumInt();
            }

            var targetLesion = inDto.QuestionInfo.Where(x => x.QuestionType == QuestionType.TargetLesion).Select(x => x.Answer).FirstOrDefault();
            var noTargetLesion = inDto.QuestionInfo.Where(x => x.QuestionType == QuestionType.NoTargetLesion).Select(x => x.Answer).FirstOrDefault();
            var newLesions = inDto.QuestionInfo.Where(x => x.QuestionType == QuestionType.NewLesions).Select(x => x.Answer).FirstOrDefault();
            return CalculationGetImgOncology(targetLesion, noTargetLesion, newLesions); 
        }

        /// <summary>
        /// 测试肿瘤学评估
        /// </summary>
        /// <returns></returns>
        public async Task<List<TestOncologyDto>> TestOncology()
        {
            var dataList = await _tumorAssessmentRepository.AsQueryable().ToListAsync();

            List<TestOncologyDto> result = new List<TestOncologyDto>();

            foreach (var item in dataList)
            {
                var data = CalculationGetImgOncology(item.TargetLesion.GetEnumInt(), item.NonTargetLesions.GetEnumInt(), item.NewLesion.GetEnumInt());

                if (item.OverallEfficacy.GetEnumInt() != data)
                {
                    result.Add(new TestOncologyDto()
                    {
                        Id = item.Id,
                        TargetLesion = item.TargetLesion.ToString(),
                        NewLesion = item.NewLesion.ToString(),
                        NonTargetLesions = item.NonTargetLesions.ToString(),
                        OverallEfficacy = item.OverallEfficacy.ToString(),
                    });
                }
            }
            return result;

        }


        /// <summary>
        /// 计算整体肿瘤评估 【测试】
        /// </summary>
        /// <param name="targetLesion">靶病灶</param>
        /// <param name="noTargetLesion"> 非靶病灶</param>
        /// <param name="newLesions">新病灶</param>
        /// <remarks>
        ///   靶病灶	              非靶病灶	              存在新病灶	        整体肿瘤评估
        /// 1. CR                     CR                      否                    CR
        /// 2. CR                     ND                      否                    CR
        /// 3. ND                     CR                      否                    CR
        /// 4. CR                     NN/NE                   否/疑似/NE            PR
        /// 5. CR                     CR/ND                   疑似/NE               PR
        /// 6. PR                     CR/ND/NN/NE             否/疑似/NE            PR
        /// 7. ND                     CR                      疑似/NE               PR
        /// 8. SD                     CR/ND/NN/NE             否/疑似/NE            SD
        /// 9. ND                     NN                      否/疑似/NE            NN
        /// 10.NE                     CR/ND/NN/NE             否/疑似/NE            NE
        /// 11.ND                     NE                      否/疑似/NE            NE
        /// 12.ND                     ND                      NE                    NE
        /// 13.ND                     ND                      否/疑似               ND
        /// 14.PD                     CR/NN/PD/ND/NE          是/否/疑似/NE         PD
        /// 15.CR/PR/SD/PD/ND/NE      PD                      是/否/疑似/NE         PD
        /// 16.CR/PR/SD/PD/ND/NE      CR/NN/PD/ND/NE          是                    PD
        /// </remarks>
        /// <returns></returns>
        public string CalculationGetImgOncology(string? targetLesion, string? noTargetLesion, string? newLesions)
        {
            List<CalculationDto> data = new List<CalculationDto>() {

                //1. CR                    CR               否                CR
                new CalculationDto(){
                Column1=ReadingCommon.EnumToString(new List<TargetAssessment>() { TargetAssessment.CR }),
                Column2=ReadingCommon.EnumToString(new List<NoTargetAssessment>() { NoTargetAssessment.CR }),
                Column3=ReadingCommon.EnumToString(new List<NewLesionAssessment>() { NewLesionAssessment.No}),
                Column4=ReadingCommon.EnumToString(new List<OverallAssessment>() { OverallAssessment.CR }),
                },
               
                // 2. CR                    ND               否                CR
                new CalculationDto(){
                Column1=ReadingCommon.EnumToString(new List<TargetAssessment>() { TargetAssessment.CR }),
                Column2=ReadingCommon.EnumToString(new List<NoTargetAssessment>() { NoTargetAssessment.ND }),
                Column3=ReadingCommon.EnumToString(new List<NewLesionAssessment>() { NewLesionAssessment.No}),
                Column4=ReadingCommon.EnumToString(new List<OverallAssessment>() { OverallAssessment.CR }),
                },

                // 3. ND                    CR               否                CR
                new CalculationDto(){
                Column1=ReadingCommon.EnumToString(new List<TargetAssessment>() { TargetAssessment.ND }),
                Column2=ReadingCommon.EnumToString(new List<NoTargetAssessment>() { NoTargetAssessment.CR }),
                Column3=ReadingCommon.EnumToString(new List<NewLesionAssessment>() { NewLesionAssessment.No}),
                Column4=ReadingCommon.EnumToString(new List<OverallAssessment>() { OverallAssessment.CR }),
                },

                 // 4. CR                    NN/NE            否/疑似/NE        PR
                new CalculationDto(){
                Column1=ReadingCommon.EnumToString(new List<TargetAssessment>() { TargetAssessment.CR }),
                Column2=ReadingCommon.EnumToString(new List<NoTargetAssessment>() { NoTargetAssessment.NN, NoTargetAssessment.NE }),
                Column3=ReadingCommon.EnumToString(new List<NewLesionAssessment>() { NewLesionAssessment.No,NewLesionAssessment.Suspected, NewLesionAssessment.NE}),
                Column4=ReadingCommon.EnumToString(new List<OverallAssessment>() { OverallAssessment.PR }),
                },

                // 5. CR                     CR/ND            疑似/NE           PR
                new CalculationDto(){
                Column1=ReadingCommon.EnumToString(new List<TargetAssessment>() { TargetAssessment.CR }),
                Column2=ReadingCommon.EnumToString(new List<NoTargetAssessment>() { NoTargetAssessment.CR, NoTargetAssessment.ND }),
                Column3=ReadingCommon.EnumToString(new List<NewLesionAssessment>() { NewLesionAssessment.Suspected, NewLesionAssessment.NE}),
                Column4=ReadingCommon.EnumToString(new List<OverallAssessment>() { OverallAssessment.PR }),
                },

                  // 6. PR                     CR/ND/NN/NE      否/疑似/NE        PR
                new CalculationDto(){
                Column1=ReadingCommon.EnumToString(new List<TargetAssessment>() { TargetAssessment.PR }),
                Column2=ReadingCommon.EnumToString(new List<NoTargetAssessment>() { NoTargetAssessment.CR, NoTargetAssessment.ND, NoTargetAssessment.NN, NoTargetAssessment.NE }),
                Column3=ReadingCommon.EnumToString(new List<NewLesionAssessment>() { NewLesionAssessment.No,NewLesionAssessment.Suspected, NewLesionAssessment.NE}),
                Column4=ReadingCommon.EnumToString(new List<OverallAssessment>() { OverallAssessment.PR }),
                },

                  //7. ND                     CR               疑似/NE           PR
                new CalculationDto(){
                Column1=ReadingCommon.EnumToString(new List<TargetAssessment>() { TargetAssessment.ND }),
                Column2=ReadingCommon.EnumToString(new List<NoTargetAssessment>() { NoTargetAssessment.CR }),
                Column3=ReadingCommon.EnumToString(new List<NewLesionAssessment>() { NewLesionAssessment.No,NewLesionAssessment.Suspected, NewLesionAssessment.NE}),
                Column4=ReadingCommon.EnumToString(new List<OverallAssessment>() { OverallAssessment.PR }),
                },

                  // 8. SD                     CR/ND/NN/NE      否/疑似/NE        SD
                new CalculationDto(){
                Column1=ReadingCommon.EnumToString(new List<TargetAssessment>() { TargetAssessment.SD }),
                Column2=ReadingCommon.EnumToString(new List<NoTargetAssessment>() { NoTargetAssessment.CR, NoTargetAssessment.ND, NoTargetAssessment.NN , NoTargetAssessment.NE }),
                Column3=ReadingCommon.EnumToString(new List<NewLesionAssessment>() { NewLesionAssessment.No,NewLesionAssessment.Suspected, NewLesionAssessment.NE}),
                Column4=ReadingCommon.EnumToString(new List<OverallAssessment>() { OverallAssessment.SD }),
                },

                  // 9. ND                     NN               否/疑似/NE        NN
                new CalculationDto(){
                Column1=ReadingCommon.EnumToString(new List<TargetAssessment>() { TargetAssessment.ND }),
                Column2=ReadingCommon.EnumToString(new List<NoTargetAssessment>() { NoTargetAssessment.NN}),
                Column3=ReadingCommon.EnumToString(new List<NewLesionAssessment>() { NewLesionAssessment.No,NewLesionAssessment.Suspected, NewLesionAssessment.NE}),
                Column4=ReadingCommon.EnumToString(new List<OverallAssessment>() { OverallAssessment.NN }),
                },

                    // 10.NE                     CR/ND/NN/NE      否/疑似/NE        NE
                new CalculationDto(){
                Column1=ReadingCommon.EnumToString(new List<TargetAssessment>() { TargetAssessment.NE }),
                Column2=ReadingCommon.EnumToString(new List<NoTargetAssessment>() { NoTargetAssessment.CR, NoTargetAssessment.ND, NoTargetAssessment.NN, NoTargetAssessment.NE, }),
                Column3=ReadingCommon.EnumToString(new List<NewLesionAssessment>() { NewLesionAssessment.No,NewLesionAssessment.Suspected, NewLesionAssessment.NE}),
                Column4=ReadingCommon.EnumToString(new List<OverallAssessment>() { OverallAssessment.NE }),
                },

                    // 11.ND                     NE               否/疑似/NE        NE
                new CalculationDto(){
                Column1=ReadingCommon.EnumToString(new List<TargetAssessment>() { TargetAssessment.ND }),
                Column2=ReadingCommon.EnumToString(new List<NoTargetAssessment>() { NoTargetAssessment.NE }),
                Column3=ReadingCommon.EnumToString(new List<NewLesionAssessment>() { NewLesionAssessment.No,NewLesionAssessment.Suspected, NewLesionAssessment.NE}),
                Column4=ReadingCommon.EnumToString(new List<OverallAssessment>() { OverallAssessment.NE }),
                },

                    // 12.ND                     ND               NE                NE
                 new CalculationDto(){
                Column1=ReadingCommon.EnumToString(new List<TargetAssessment>() { TargetAssessment.ND }),
                Column2=ReadingCommon.EnumToString(new List<NoTargetAssessment>() { NoTargetAssessment.ND }),
                Column3=ReadingCommon.EnumToString(new List<NewLesionAssessment>() { NewLesionAssessment.NE}),
                Column4=ReadingCommon.EnumToString(new List<OverallAssessment>() { OverallAssessment.NE }),
                },

                    // 13.ND                     ND               否/疑似           ND
                new CalculationDto(){
                Column1=ReadingCommon.EnumToString(new List<TargetAssessment>() { TargetAssessment.ND }),
                Column2=ReadingCommon.EnumToString(new List<NoTargetAssessment>() { NoTargetAssessment.ND }),
                Column3=ReadingCommon.EnumToString(new List<NewLesionAssessment>() { NewLesionAssessment.No,NewLesionAssessment.Suspected}),
                Column4=ReadingCommon.EnumToString(new List<OverallAssessment>() { OverallAssessment.ND }),
                },

                    // 14.PD                     CR/NN/PD/ND/NE   是/否/疑似/NE     PD
                new CalculationDto(){
                Column1=ReadingCommon.EnumToString(new List<TargetAssessment>() { TargetAssessment.PD }),
                Column2=ReadingCommon.EnumToString(new List<NoTargetAssessment>() { NoTargetAssessment.CR, NoTargetAssessment.NN,NoTargetAssessment.PD, NoTargetAssessment.ND,NoTargetAssessment.NE }),
                Column3=ReadingCommon.EnumToString(new List<NewLesionAssessment>() {NewLesionAssessment.Yes, NewLesionAssessment.No,NewLesionAssessment.Suspected, NewLesionAssessment.NE}),
                Column4=ReadingCommon.EnumToString(new List<OverallAssessment>() { OverallAssessment.PD }),
                },

                    // 15.CR/PR/SD/PD/ND/NE      PD               是/否/疑似/NE     PD
                new CalculationDto(){
                Column1=ReadingCommon.EnumToString(new List<TargetAssessment>() { TargetAssessment.CR, TargetAssessment.PR, TargetAssessment.SD, TargetAssessment.PD, TargetAssessment.ND, TargetAssessment.NE }),
                Column2=ReadingCommon.EnumToString(new List<NoTargetAssessment>() { NoTargetAssessment.PD }),
                Column3=ReadingCommon.EnumToString(new List<NewLesionAssessment>() { NewLesionAssessment.Yes, NewLesionAssessment.No,NewLesionAssessment.Suspected, NewLesionAssessment.NE}),
                Column4=ReadingCommon.EnumToString(new List<OverallAssessment>() { OverallAssessment.PD }),
                },

                    // 16.CR/PR/SD/PD/ND/NE      CR/NN/PD/ND/NE   是                PD
                  new CalculationDto(){
                Column1=ReadingCommon.EnumToString(new List<TargetAssessment>() { TargetAssessment.CR, TargetAssessment.PR, TargetAssessment.SD, TargetAssessment.PD, TargetAssessment.ND, TargetAssessment.NE }),
                Column2=ReadingCommon.EnumToString(new List<NoTargetAssessment>() { NoTargetAssessment.CR,NoTargetAssessment.NN,NoTargetAssessment.PD,NoTargetAssessment.ND,NoTargetAssessment.NE }),
                Column3=ReadingCommon.EnumToString(new List<NewLesionAssessment>() { NewLesionAssessment.Yes}),
                Column4=ReadingCommon.EnumToString(new List<OverallAssessment>() { OverallAssessment.PD }),
                },
            };

            var resultdata = data.Where(x =>
              (x.NotEq.Contains(1) ? !x.Column1.Contains(targetLesion) : x.Column1.Contains(targetLesion) || x.Column1.Count() == 0) &&
              (x.NotEq.Contains(2) ? !x.Column2.Contains(noTargetLesion) : x.Column2.Contains(noTargetLesion) || x.Column2.Count() == 0) &&
              (x.NotEq.Contains(3) ? !x.Column3.Contains(newLesions) : x.Column3.Contains(newLesions) || x.Column3.Count() == 0))
              .Select(x => x.Column4.FirstOrDefault())
              .FirstOrDefault();
            return resultdata ?? string.Empty;
        }
        #endregion

        #region 是否存在疾病
        /// <summary>
        /// 是否存在疾病
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<string> GetIsExistDisease(ReadingCalculateDto inDto)
        {
            if (!inDto.IsBaseLine)
            {
                return string.Empty;
            }

            var lesionCount = inDto.QuestionInfo.SelectMany(x => x.TableRowInfoList).Count();

            return lesionCount > 0 ? ExistDisease.Yes.GetEnumInt() : ExistDisease.No.GetEnumInt();
        }
        #endregion


        #region 修改其他标准

        #region 修改与整个访视期间SOD最低点相比增加的值（mm）

        /// <summary>
        /// 修改与整个访视期间SOD最低点相比增加的值（mm）
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task ChangeAllLowestIncrease(ChangeAllTaskDto inDto)
        {
            var visitTaskList = await GetVisitTaskAnswerList(inDto.calculateDto);

            var lowSod = (await GetLowSODVisit(inDto.calculateDto)).Select(x => x.SOD).OrderBy(x => x).FirstOrDefault();

            foreach (var item in visitTaskList.Where(x => x.VisitTaskId != inDto.calculateDto.BaseLineTaskId))
            {
                await _readingTaskQuestionAnswerRepository.BatchUpdateNoTrackingAsync(x => x.VisitTaskId == item.VisitTaskId && x.ReadingQuestionTrialId == inDto.QuestionId, x => new ReadingTaskQuestionAnswer()
                {
                    Answer = (item.SOD - lowSod).ToString()
                });
            }
        }

        #endregion


        #region 修改整个访视期间SOD最低点相比增加的百分比

        /// <summary>
        /// 修改整个访视期间SOD最低点相比增加的百分比
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        //public async Task ChangeAllLowPercent(ChangeAllTaskDto inDto)
        //{
        //    var visitTaskList = await GetVisitTaskAnswerList(inDto.calculateDto);

        //    var lowSod = (await GetLowSODVisit(inDto.calculateDto)).Select(x => x.SOD).OrderBy(x => x).FirstOrDefault();

        //    foreach (var item in visitTaskList.Where(x => x.VisitTaskId != inDto.calculateDto.BaseLineTaskId))
        //    {
        //        decimal percent = 0;
        //        if (lowSod == 0)
        //        {
        //            percent = 100;
        //        }
        //        else
        //        {
        //            percent = decimal.Round((item.SOD - lowSod) * 100 / lowSod, 2);
        //        }

        //        await _readingTaskQuestionAnswerRepository.BatchUpdateNoTrackingAsync(x => x.VisitTaskId == item.VisitTaskId && x.ReadingQuestionTrialId == inDto.QuestionId, x => new ReadingTaskQuestionAnswer()
        //        {
        //            Answer = percent.ToString()
        //        });
        //    }
        //}

        #endregion

        #region 修改最低方式点名称
        /// <summary>
        /// 修改最低方式点名称
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task ChangeAllLowVisitName(ChangeAllTaskDto inDto)
        {
            // 找到所有访视任务的Id

            var visitTaskIds = await _visitTaskRepository.Where(x => x.IsAnalysisCreate == inDto.IsAnalysisCreate &&
            x.ReadingCategory == ReadingCategory.Visit &&
              x.TrialReadingCriterionId == inDto.calculateDto.TrialReadingCriterionId &&
              x.TaskState == TaskState.Effect && x.ReadingTaskState == ReadingTaskState.HaveSigned && x.ArmEnum == inDto.calculateDto.ArmEnum).Select(x => x.Id).ToListAsync();

            var answer = (await GetLowSODVisit(inDto.calculateDto)).OrderBy(x => x.SOD).Select(x => x.BlindName).FirstOrDefault();
            visitTaskIds = visitTaskIds.Where(x => x != inDto.calculateDto.BaseLineTaskId).ToList();
            await this.ChangeAllVisitTaskAnswer(visitTaskIds, inDto.QuestionId, answer);

        }
        #endregion


        #endregion

        #region 通用方法

        #region 修改所有访视任务的答案
        /// <summary>
        /// 修改所有访视任务的答案
        /// </summary>
        /// <param name="visitTaskGuids"></param>
        /// <param name="questionId"></param>
        /// <param name="answer"></param>
        /// <returns></returns>
        private async Task ChangeAllVisitTaskAnswer(List<Guid> visitTaskGuids, Guid questionId, string answer)
        {
            await _readingTaskQuestionAnswerRepository.BatchUpdateNoTrackingAsync(x => visitTaskGuids.Contains(x.VisitTaskId) && x.ReadingQuestionTrialId == questionId, x => new ReadingTaskQuestionAnswer()
            {
                Answer = answer
            });
        }
        #endregion


        #region 获取基线SOD
        /// <summary>
        /// 获取基线SOD
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        private async Task<decimal> GetBaseLineSOD(ReadingCalculateDto inDto)
        {
            if (await _visitTaskRepository.AnyAsync(x => x.Id == inDto.VisitTaskId && x.SourceSubjectVisit.IsBaseLine && x.IsAnalysisCreate == inDto.IsAnalysisCreate && x.ArmEnum == inDto.ArmEnum))
            {
                return 0;
            }

            // 先找到基线的任务
            var baseLineTaskId = await _visitTaskRepository.Where(x => x.SubjectId == inDto.SubjectId && x.ReadingCategory == ReadingCategory.Visit
                                                                  && x.TrialReadingCriterionId == inDto.TrialReadingCriterionId &&

                                                                  x.SourceSubjectVisit.IsBaseLine && x.TaskState == TaskState.Effect &&
                                                                  x.IsAnalysisCreate == inDto.IsAnalysisCreate
                                                                  && x.DoctorUserId == inDto.DoctorUserId
                                                                  && x.IsSelfAnalysis == inDto.IsSelfAnalysis && x.ArmEnum == inDto.ArmEnum)
                                                                   .Select(x => x.Id).FirstOrDefaultAsync();


            var baseLineSOD = (await _readingTaskQuestionAnswerRepository.Where(x => x.VisitTaskId == baseLineTaskId && x.ReadingQuestionTrial.QuestionType == QuestionType.SOD).Select(x => x.Answer).FirstOrDefaultAsync()).IsNullOrEmptyReturn0();
            return baseLineSOD;
        }
        #endregion


        /// <summary>
        /// 获取最低方式
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<List<VisitTaskAnswerInfo>> GetLowSODVisit(ReadingCalculateDto inDto)
        {
            var taskAnswerList = await GetVisitTaskAnswerList(inDto);

            taskAnswerList = taskAnswerList.Where(x => x.VisitTaskId != inDto.VisitTaskId).ToList();

            var taskIds = taskAnswerList.Select(x => x.VisitTaskId).ToList();

            // 排除无法评估
            var unableEvaluateTaskIds = await _readingTableQuestionAnswerRepository.Where(x => taskIds.Contains(x.VisitTaskId) &&
            x.ReadingTableQuestionTrial.QuestionMark == QuestionMark.State
            && x.ReadingQuestionTrial.LesionType == LesionType.TargetLesion
            && x.Answer == TargetState.UnableEvaluate.GetEnumInt()
            )
             .Select(x => x.VisitTaskId).Distinct().ToListAsync();

            taskAnswerList = taskAnswerList.Where(x => !unableEvaluateTaskIds.Contains(x.VisitTaskId)).ToList();
            return taskAnswerList.OrderBy(x => x.SOD).ToList();
        }

        #region 获取访视任务信息
        /// <summary>
        /// 获取访视任务信息
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<List<VisitTaskAnswerInfo>> GetVisitTaskAnswerList(ReadingCalculateDto inDto)
        {
            if (visitTaskAnswerList == null)
            {
                // 查询的时候要把自己排除 因为查询出来的可能不是计算出的最新的
                visitTaskAnswerList = await _readingTaskQuestionAnswerRepository.Where(x => x.VisitTaskId != inDto.VisitTaskId && x.VisitTask.ReadingCategory == ReadingCategory.Visit
                && x.VisitTask.IsAnalysisCreate == inDto.IsAnalysisCreate
                && x.VisitTask.IsSelfAnalysis == inDto.IsSelfAnalysis
                && x.VisitTask.VisitTaskNum < inDto.VisitTaskNum
                && x.ReadingQuestionCriterionTrialId == inDto.TrialReadingCriterionId
                && x.SubjectId == inDto.SubjectId && x.VisitTask.ReadingTaskState == ReadingTaskState.HaveSigned && x.VisitTask.ArmEnum == inDto.ArmEnum && x.VisitTask.TaskState == TaskState.Effect && x.ReadingQuestionTrial.QuestionType == QuestionType.SOD)
                .Select(x => new VisitTaskAnswerInfo
                {
                    VisitTaskId = x.VisitTaskId,
                    QuestionId = x.ReadingQuestionTrialId,
                    VisitName = x.VisitTask.SourceSubjectVisit.VisitName,
                    BlindName = x.VisitTask.TaskBlindName,

                    SOD = x.Answer.IsNullOrEmptyReturn0(),
                }).ToListAsync();

                // 这里是需要加上自己的 基线不用管
                if (visitTaskAnswerList.Count > 0)
                {
                    visitTaskAnswerList.Add(new VisitTaskAnswerInfo()
                    {
                        VisitTaskId = inDto.VisitTaskId,
                        BlindName = inDto.TaskBlindName,
                        QuestionId = visitTaskAnswerList[0].QuestionId,
                        VisitName = inDto.VisitName,
                        SOD = (await GetSODData(inDto)).ToString().IsNullOrEmptyReturn0(),
                    });
                }


            }

            return visitTaskAnswerList;
        }
        #endregion

        /// <summary>
        /// 获取上一个访视任务Id
        /// </summary>
        /// <returns></returns>
        private async Task<Guid> GetLastVisitTaskId(ReadingCalculateDto inDto)
        {
            // 拿到这一个访视
            var thisNum = await _subjectVisitRepository.Where(x => x.Id == inDto.SubjectVisitId).Select(x => x.VisitNum).FirstOrDefaultAsync();

            // 先找到上一个访视
            var lastVisitId = await _subjectVisitRepository.Where(x => x.SubjectId == inDto.SubjectId && !x.IsLostVisit && x.VisitNum < thisNum).OrderByDescending(x => x.VisitNum).Select(x => x.Id).FirstOrDefaultAsync();

            // 找到访视任务Id

            var LastVisitTaskId = await _visitTaskRepository.Where(x => x.ReadingCategory == ReadingCategory.Visit &&
            x.TrialReadingCriterionId == inDto.TrialReadingCriterionId &&
            x.TaskState == TaskState.Effect &&
            x.IsAnalysisCreate == inDto.IsAnalysisCreate
            && x.SourceSubjectVisitId == lastVisitId && x.ArmEnum == inDto.ArmEnum).Select(x => x.Id).FirstOrDefaultAsync();

            return LastVisitTaskId;
        }
        #endregion

        #region 计算阅片问题  外层问题

        #region 获取靶病灶评估
        /// <summary>
        /// 获取靶病灶评估
        /// </summary>
        /// <param name="inDto"></param>
        /// <remarks>
        /// 靶病灶疗效评估算法-20230306确认版本：
        ///if（基线没有靶病灶） 
        ///{
        ///	靶病灶疗效为 ND
        ///}else
        ///{
        ///	初始化靶病灶疗效为 SD
        ///
        ///	if (与基线期SOD相比减小≥30 %）
        ///	{
        ///		靶病灶疗效为 PR
        ///
        ///    }
        ///
        ///if (非淋巴结靶病灶长径之和 == 0 并且所有淋巴结靶病灶的短径 < 10且淋巴结非靶病灶全部消失)
        ///	{
        ///    靶病灶疗效为 CR
        ///
        ///    }
        ///
        ///if （有被评估为NE的单个靶病灶）
        ///	{
        ///    靶病灶疗效为 NE
        ///
        ///    }
        ///
        ///if (最低点SOD > 0)
        ///{
        ///    if（比整体访视期间最低点SOD增加≥20 % 且与整个访视期间最低点相比增加的值≥5 mm）
        ///		{
        ///        靶病灶疗效为 PD
        ///
        ///        }
        ///}
        ///else
        ///{
        ///    //进入该分支最低点SOD=0
        ///    if (当前访视SOD > 0 且与整个访视期间最低点相比增加的值≥5 mm)
        ///		{
        ///        靶病灶疗效为PD
        ///
        ///        }
        ///}
        ///
        ///if（上次访视点评估是CR）
        ///	{
        ///    if (当前访视点淋巴结病灶,至少一个淋巴结靶病灶短径≥10 mm 并且该淋巴结靶病灶短径绝对增加值≥5 mm)
        ///		{
        ///        靶病灶疗效为 PD
        ///
        ///        }
        ///    if (当前访视点非淋巴结病灶至少一个非淋巴结靶病灶的长径＞0 mm。)
        ///		{
        ///        靶病灶疗效为 PD
        ///
        ///        }
        ///}
        ///}
        /// </remarks>
        /// <returns></returns>
        public async Task<string> GetTargetLesionEvaluate(ReadingCalculateDto inDto)
        {
            var tableQuestion = inDto.QuestionInfo.Where(x => x.LesionType == LesionType.TargetLesion).SelectMany(x => x.TableRowInfoList).ToList();
            if (inDto.IsBaseLine)
            {
                return TargetAssessment.NA.GetEnumInt();
            }

            TargetLesionCalculateDto resultData = new TargetLesionCalculateDto()
            {


                // 是否存在靶病灶
                ExistsTargetLesion = tableQuestion.Count() > 0,

                // 最低SOD
                LowSod = (await GetLowSODVisit(inDto)).Select(x => x.SOD).FirstOrDefault(),

                // 当前Sod
                PresentSod = (await GetSODData(inDto)) ?? 0,

                //非淋巴结靶病灶长径之和  decimal
                SumOfDiameter = inDto.QuestionInfo.Where(x => x.QuestionType == QuestionType.SumOfDiameter).Sum(x => x.Answer.IsNullOrEmptyReturn0()),

                //所有淋巴结靶病灶的短径小于10mm bool
                DiameterLessThan10 = true,

                // SOD变化百分比
                SODPercent = inDto.QuestionInfo.Where(x => x.QuestionType == QuestionType.SODPercent).Sum(x => x.Answer.IsNullOrEmptyReturn0()),

                // SOD 百分比与基线期SOD相比减小≥30% bool
                SODPercentBigger30 = inDto.QuestionInfo.Where(x => x.QuestionType == QuestionType.SODPercent).Sum(x => x.Answer.IsNullOrEmptyReturn0()) <= -30,

                // SOD 百分比 与基线期SOD相比减小＜30% bool
                SODPercentLess30 = 0 > inDto.QuestionInfo.Where(x => x.QuestionType == QuestionType.SODPercent).Sum(x => x.Answer.IsNullOrEmptyReturn0()) &&

                   inDto.QuestionInfo.Where(x => x.QuestionType == QuestionType.SODPercent).Sum(x => x.Answer.IsNullOrEmptyReturn0()) > -30,

                // SOD 百分比 整体访视期间SOD最低点SOD相比增加＜20%
                LowSODPercentLess20 = inDto.QuestionInfo.Where(x => x.QuestionType == QuestionType.LowPercent).Sum(x => x.Answer.IsNullOrEmptyReturn0()) < 20,

                // SOD 百分比  比整体访视期间SOD最低点SOD增加≥20%
                LowSODPercentBigger20 = inDto.QuestionInfo.Where(x => x.QuestionType == QuestionType.LowPercent).Sum(x => x.Answer.IsNullOrEmptyReturn0()) >= 20,

                // SOD 变化值 比整体访视期间SOD最低点SOD绝对增加值＜5 mm
                LowSODChangeLess5 = inDto.QuestionInfo.Where(x => x.QuestionType == QuestionType.LowestIncrease).Sum(x => x.Answer.IsNullOrEmptyReturn0()) < 5,

                // 比整体访视期间SOD最低点SOD绝对增加值≥5 mm
                LowSODChangeBigger5 = inDto.QuestionInfo.Where(x => x.QuestionType == QuestionType.LowestIncrease).Sum(x => x.Answer.IsNullOrEmptyReturn0()) >= 5,

                //  被评估为NE的单个靶病灶   是否存在状态为不可评估的靶病灶
                ExixtsNETargetLesion = tableQuestion.SelectMany(x => x.TableQuestionList).Any(x => x.QuestionMark == QuestionMark.State && x.Answer.EqEnum(TargetState.UnableEvaluate)),

                //// 上次访视点整体肿瘤评估
                LastTargetLesionEvaluate = string.Empty,

                // 当前访视点非淋巴结病灶至少一个非淋巴结靶病灶的长径＞0 mm
                CurrentMajoreBigger0 = false,

                // 当前访视点淋巴结病灶, 至少一个淋巴结靶病灶短径≥10 mm 
                CurrenShortBigger10 = false,

                // 靶病灶短径增加值有5mm的Index
                AddFiveIndexs = await GetIsAddFiveRowIndexs(inDto),

                // 短径有10mm的Index 
                ShortBigger10Indexs = new List<decimal>(),

                //淋巴结非靶病灶状态全部为消失
                NonTargetStateIsLoss = true,

                // 该淋巴结靶病灶短径绝对增加值≥5 mm
                IsAddFive = inDto.QuestionInfo.Where(x => x.QuestionType == QuestionType.IsAddFive && x.Answer.EqEnum(YesOrNoOrNa.Yes)).Count() > 0,
            };

            var nonTargetTableQuestion = inDto.QuestionInfo.Where(x => x.LesionType == LesionType.NonTargetLesions).SelectMany(x => x.TableRowInfoList).ToList();

            foreach (var item in nonTargetTableQuestion)
            {
                if (item.TableQuestionList.Any(x => x.QuestionMark == QuestionMark.IsLymph && x.Answer.EqEnum(YesOrNoOrNa.Yes)))
                {
                    // 淋巴结非靶病灶状态全部为消失
                    resultData.NonTargetStateIsLoss = resultData.NonTargetStateIsLoss && item.TableQuestionList.Where(x => x.QuestionMark == QuestionMark.State).Select(x => x.Answer).FirstOrDefault() == NoTargetState.Loss.GetEnumInt();
                }
            }


            foreach (var item in tableQuestion)
            {
                if (item.TableQuestionList.Any(x => x.QuestionMark == QuestionMark.IsLymph && x.Answer.EqEnum(YesOrNoOrNa.Yes)))
                {
                    // 淋巴结的短径
                    resultData.DiameterLessThan10 = resultData.DiameterLessThan10 && (item.TableQuestionList.Where(x => x.QuestionMark == QuestionMark.ShortAxis).Select(x => x.Answer).FirstOrDefault()).IsNullOrEmptyReturn0() < 10;

                    var shortIsBigger10 = (item.TableQuestionList.Where(x => x.QuestionMark == QuestionMark.ShortAxis).Select(x => x.Answer).FirstOrDefault()).IsNullOrEmptyReturn0() >= 10;
                    resultData.CurrenShortBigger10 = resultData.CurrenShortBigger10 || shortIsBigger10;

                    if (shortIsBigger10)
                    {
                        resultData.ShortBigger10Indexs.Add(item.RowIndex);
                    }


                }

                if (item.TableQuestionList.Any(x => x.QuestionMark == QuestionMark.IsLymph && !x.Answer.EqEnum(YesOrNoOrNa.Yes)))
                {
                    // 当前访视点非淋巴结病灶至少一个非淋巴结靶病灶的长径
                    resultData.CurrentMajoreBigger0 = resultData.CurrentMajoreBigger0 || (item.TableQuestionList.Where(x => x.QuestionMark == QuestionMark.MajorAxis).Select(x => x.Answer).FirstOrDefault()).IsNullOrEmptyReturn0() > 0;
                }
            }


            var lastVisitTaskId = await GetLastVisitTaskId(inDto);
            var questionId = inDto.QuestionInfo.Where(x => x.QuestionType == QuestionType.Tumor).Select(x => x.QuestionId).FirstOrDefault();
            resultData.LastTargetLesionEvaluate = (await _readingTaskQuestionAnswerRepository.Where(x => x.VisitTaskId == lastVisitTaskId && x.ReadingQuestionTrialId == questionId)
                .Select(x => x.Answer).FirstOrDefaultAsync()) ?? string.Empty;

            TargetAssessment result = TargetAssessment.SD;
            //if（基线没有靶病灶） 
            if (!resultData.ExistsTargetLesion)
            {
                //	靶病灶疗效为 ND
                result = TargetAssessment.ND;
            }
            else
            {
                //初始化靶病灶疗效为 SD
                result = TargetAssessment.SD;

                //if (与基线期SOD相比减小≥30 %）
                if (resultData.SODPercentBigger30)
                {
                    //靶病灶疗效为 PR
                    result = TargetAssessment.PR;
                }
                //if (非淋巴结靶病灶长径之和 == 0 并且所有淋巴结靶病灶的短径 < 10且淋巴结非靶病灶全部消失)
                if (resultData.SumOfDiameter == 0 && resultData.DiameterLessThan10 && resultData.NonTargetStateIsLoss)
                {
                    //靶病灶疗效为 CR
                    result = TargetAssessment.CR;
                }
                //  if （有被评估为NE的单个靶病灶）
                if (resultData.ExixtsNETargetLesion)
                {
                    //  靶病灶疗效为 NE
                    result = TargetAssessment.NE;
                }
                //if (最低点SOD > 0)
                if (resultData.LowSod > 0)
                {
                    // if（比整体访视期间最低点SOD增加≥20 % 且与整个访视期间最低点相比增加的值≥5 mm）
                    if (resultData.LowSODPercentBigger20 && resultData.LowSODChangeBigger5)
                    {
                        // 靶病灶疗效为 PD
                        result = TargetAssessment.PD;
                    }
                }
                else
                {
                    //进入该分支最低点SOD=0
                    // if (当前访视SOD > 0 且与整个访视期间最低点相比增加的值≥5 mm)
                    if (resultData.PresentSod > 0 && resultData.LowSODChangeBigger5)
                    {
                        // 靶病灶疗效为PD
                        result = TargetAssessment.PD;
                    }
                }
                //if（上次访视点评估是CR）
                if (resultData.LastTargetLesionEvaluate.EqEnum(TargetAssessment.CR))
                {
                    //if (当前访视点淋巴结病灶,至少一个淋巴结靶病灶短径≥10 mm 并且该淋巴结靶病灶短径绝对增加值≥5 mm)
                    // 换句话说  就是 短径≥10 的病灶  和  短径增加值≥5的病灶   的交集数量大于0
                    if (resultData.ShortBigger10Indexs.Intersect(resultData.AddFiveIndexs).ToList().Count() > 0)
                    {
                        //靶病灶疗效为 PD
                        result = TargetAssessment.PD;
                    }
                    //if (当前访视点非淋巴结病灶至少一个非淋巴结靶病灶的长径＞0 mm。)
                    if (resultData.CurrentMajoreBigger0)
                    {
                        //靶病灶疗效为 PD
                        result = TargetAssessment.PD;
                    }
                }



                #region 之前的逻辑 备注
                //if (resultData.LastTargetLesionEvaluate.EqEnum(TargetAssessment.CR))
                //{
                //    if (resultData.ExixtsNETargetLesion)
                //    {
                //        result = TargetAssessment.NE;
                //    }
                //    if (resultData.CurrenShortBigger10 && resultData.IsAddFive)
                //    {
                //        result = TargetAssessment.PD;
                //    }
                //    if (resultData.CurrentMajoreBigger0)
                //    {
                //        result = TargetAssessment.PD;
                //    }
                //}

                //else
                //{
                //    if (resultData.LowSod != 0 && resultData.LowPercentBigger20 && resultData.LowChangeBigger5)
                //    {
                //        result = TargetAssessment.PD;
                //    }
                //    else
                //    {
                //        if (resultData.ExixtsNETargetLesion)
                //        {
                //            result = TargetAssessment.NE;
                //        }
                //        else
                //        {
                //            if (resultData.SODPercentBigger30)
                //            {
                //                if (resultData.LowPercentLess20 || resultData.LowChangeLess5)
                //                {
                //                    result = TargetAssessment.PR;
                //                }

                //                if (resultData.SumOfDiameter == 0 && resultData.DiameterLessThan10 && resultData.NonTargetStateIsLoss)
                //                {
                //                    result = TargetAssessment.CR;
                //                }
                //            }
                //        }
                //    }


                //}
                #endregion


            }

            return result.GetEnumInt();
        }
        #endregion

        #region 获取非靶病灶评估

        /// <summary>
        /// 获取非靶病灶评估
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<string> GetNoTargetLesionEvaluate(ReadingCalculateDto inDto)
        {

            NoTargetAssessment result = NoTargetAssessment.NN;

            if (inDto.IsBaseLine)
            {
                return NoTargetAssessment.NA.GetEnumInt();
            }

            var tableRows = inDto.QuestionInfo.Where(x => x.LesionType == LesionType.NonTargetLesions).SelectMany(x => x.TableRowInfoList).ToList();

            var tableQuestions = tableRows.SelectMany(x => x.TableQuestionList).ToList();

            //任意单个病灶 / 病灶组评估为“显著增大”
            if (tableQuestions.Any(x => x.QuestionMark == QuestionMark.State && x.Answer.EqEnum(NoTargetState.Increase)))
            {
                result = NoTargetAssessment.PD;
            }
            // 任意单个病灶/病灶组评估为“无法评估”并且没有“显著增大”
            else if (tableQuestions.Any(x => x.QuestionMark == QuestionMark.State && x.Answer.EqEnum(NoTargetState.UnableEvaluate)) &&
                !tableQuestions.Any(x => x.QuestionMark == QuestionMark.State && x.Answer.EqEnum(NoTargetState.Increase))
                )
            {
                result = NoTargetAssessment.NE;
            }
            // 所有单个病灶/病灶组评估为”存在”或者有些评估为“消失”有些评估为“存在”,且没有“显著增大”和“无法评估”的病灶
            else if (tableQuestions.Any(x => x.QuestionMark == QuestionMark.State && x.Answer.EqEnum(NoTargetState.Exist))
                && !tableQuestions.Any(x => x.QuestionMark == QuestionMark.State && (x.Answer.EqEnum(NoTargetState.Increase) || x.Answer.EqEnum(NoTargetState.UnableEvaluate)))

                )
            {
                result = NoTargetAssessment.NN;
            }
            //所有单个病灶/病灶组状态评估状态为“消失”
            else if (tableQuestions.Count(x => x.QuestionMark == QuestionMark.State && x.Answer.EqEnum(NoTargetState.Loss)) == tableQuestions.Count(x => x.QuestionMark == QuestionMark.State) && tableQuestions.Count(x => x.QuestionMark == QuestionMark.State) > 0)
            {
                result = NoTargetAssessment.CR;
            }

            // 基线时没有非靶病灶
            else if (tableQuestions.Count() == 0)
            {
                result = NoTargetAssessment.ND;
            }
            else
            {
                return string.Empty;
            }

            return result.GetEnumInt();

        }

        #endregion

        #region 获取新病灶评估
        /// <summary>
        ///  获取新病灶评估
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<string> GetNewLesionEvaluate(ReadingCalculateDto inDto)
        {

            NewLesionAssessment result = NewLesionAssessment.No;
            if (inDto.IsBaseLine)
            {
                return NewLesionAssessment.NA.GetEnumInt();
            }

            var tableRows = inDto.QuestionInfo.Where(x => x.LesionType == LesionType.NewLesions).SelectMany(x => x.TableRowInfoList).ToList();

            var tableQuestions = tableRows.SelectMany(x => x.TableQuestionList).ToList();



            // 当前访视存在至少一个明确新病灶
            if (tableQuestions.Any(x => x.QuestionMark == QuestionMark.State && x.Answer.EqEnum(NewLesionState.Exist)))
            {
                result = NewLesionAssessment.Yes;
            }
            //只要有任何一个新病灶状态为“无法评估”
            else if (tableQuestions.Any(x => x.QuestionMark == QuestionMark.State && x.Answer.EqEnum(NewLesionState.UnableEvaluate)))
            {
                result = NewLesionAssessment.NE;
            }
            //当前访视不存在明确新病灶且存在至少一个疑似新病灶
            else if (!tableQuestions.Any(x => x.QuestionMark == QuestionMark.State && x.Answer.EqEnum(NewLesionState.Exist)) &&
                tableQuestions.Any(x => x.QuestionMark == QuestionMark.State && x.Answer.EqEnum(NewLesionState.Suspected))
                )
            {
                result = NewLesionAssessment.Suspected;
            }


            else
            {
                result = NewLesionAssessment.No;
            }
            return result.GetEnumInt();

        }
        #endregion

        #endregion

    }

}
