
using IRaCIS.Core.Domain.Models;
using Microsoft.AspNetCore.Mvc;
using IRaCIS.Core.Application.Interfaces;
using IRaCIS.Core.Application.ViewModel;
using IRaCIS.Core.Infra.EFCore.Common;
using MassTransit;
using IRaCIS.Core.Infrastructure;
using IRaCIS.Core.Application.Service.Reading.Dto;
using IRaCIS.Core.Domain.Share;
using Panda.DynamicWebApi.Attributes;
using IRaCIS.Core.Application.Contracts;

namespace IRaCIS.Core.Application.Service
{	
	/// <summary>
	/// 阅片医学审核
	/// </summary>	
	[ ApiExplorerSettings(GroupName = "Reading")]
	public class ReadingMedicalReviewService : BaseService, IReadingMedicalReviewService
    {

	    private readonly IRepository<ReadingMedicineTrialQuestion> _readingMedicineTrialQuestionRepository;
        private readonly IRepository<Trial> _trialRepository;
        private readonly IRepository<VisitTask> _visitTaskRepository;
        private readonly IRepository<User> _userTaskRepository;
        private readonly IVisitTaskService _visitTaskService;
        private readonly IRepository<TaskMedicalReview> _taskMedicalReviewRepository;
        private readonly IRepository<ReadingMedicalReviewDialog> _readingMedicalReviewDialogRepository;
        private readonly IRepository<ReadingMedicineQuestionAnswer> _readingMedicineQuestionAnswerRepository;
        private readonly IRepository<ReadingMedicineSystemQuestion> _readingMedicineSystemQuestionRepository;

        public ReadingMedicalReviewService(
			IRepository<ReadingMedicineTrialQuestion> readingMedicineTrialQuestionRepository,
			IRepository<Trial> trialRepository,
			IRepository<VisitTask> visitTaskRepository,
            IRepository<User> userTaskRepository,
            IVisitTaskService visitTaskService,
            IRepository<TaskMedicalReview> taskMedicalReviewRepository,
            IRepository<ReadingMedicalReviewDialog> readingMedicalReviewDialogRepository,
            IRepository<ReadingMedicineQuestionAnswer> readingMedicineQuestionAnswerRepository,
            IRepository<ReadingMedicineSystemQuestion> readingMedicineSystemQuestionRepository
			)
		{
            this._readingMedicineTrialQuestionRepository = readingMedicineTrialQuestionRepository;
            this._trialRepository = trialRepository;
            this._visitTaskRepository = visitTaskRepository;
            this._userTaskRepository = userTaskRepository;
            this._visitTaskService = visitTaskService;
            this._taskMedicalReviewRepository = taskMedicalReviewRepository;
            this._readingMedicalReviewDialogRepository = readingMedicalReviewDialogRepository;
            this._readingMedicineQuestionAnswerRepository = readingMedicineQuestionAnswerRepository;
            this._readingMedicineSystemQuestionRepository = readingMedicineSystemQuestionRepository;
        }

		/// <summary>
		/// 获取医学审核任务信息
		/// </summary>
		/// <param name="inDto"></param>
		/// <returns></returns>
        [HttpPost]
		public async Task<GetMedicalReviewReadingTaskOutDto> GetMedicalReviewReadingTask(GetMedicalReviewReadingTaskInDto inDto)
		{
			var medicalReviewInfo = await _trialRepository.Where(x => x.Id == inDto.TrialId).Select(x => new GetMedicalReviewReadingTaskOutDto()
			{
				ReadingType=x.ReadingType,
				IsReadingTaskViewInOrder=x.IsReadingTaskViewInOrder,
              
			}).FirstNotNullAsync();

            medicalReviewInfo.MedicalReviewInfo = await _taskMedicalReviewRepository.Where(x => x.Id == inDto.TaskMedicalReviewId)
                 .ProjectTo<MedicalReviewInfo>(_mapper.ConfigurationProvider).FirstNotNullAsync();

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

            medicalReviewInfo.VisitTaskId = taskInfo.Id;
            medicalReviewInfo.ArmEnum = taskInfo.ArmEnum;
            medicalReviewInfo.IsClosedDialog = medicalReviewInfo.MedicalReviewInfo.IsClosedDialog;
            medicalReviewInfo.AuditState = medicalReviewInfo.MedicalReviewInfo.AuditState;
            medicalReviewInfo.IsSendMessage = medicalReviewInfo.MedicalReviewInfo.IsSendMessage;

            #region 取任务
            if (medicalReviewInfo.IsReadingTaskViewInOrder)
            {
                medicalReviewInfo.TaskList = await _visitTaskRepository
                    .WhereIf(taskInfo.ArmEnum == Arm.JudgeArm, x => x.ArmEnum == Arm.JudgeArm)
                    .WhereIf(taskInfo.ArmEnum != Arm.JudgeArm, x => x.ArmEnum != Arm.JudgeArm)
                    .Where(x=>x.IsAnalysisCreate== taskInfo.IsAnalysisCreate)
                    .Where(x=>x.TaskState==TaskState.Effect)
                    .Where(x => x.SubjectId == taskInfo.SubjectId
                            && x.DoctorUserId == taskInfo.DoctorUserId && 
                            x.ReadingTaskState == ReadingTaskState.HaveSigned && 
                            x.ReReadingApplyState != ReReadingApplyState.Agree
                           ).OrderBy(x => x.VisitTaskNum).Select(x => new TaskInfo()
                           {
                               TaskId = x.Id,
                               IsCurrentTask = x.Id == taskInfo.Id,
                               ReadingCategory = x.ReadingCategory,
                               TaskBlindName = x.TaskBlindName,
                               ArmEnum=x.ArmEnum,
                               TaskName = x.TaskName,
                               SouceReadModuleId=x.SouceReadModuleId,
                               SourceSubjectVisitId=x.SourceSubjectVisitId,
                               JudgeVisitTaskId=x.JudgeVisitTaskId,
                               JudgeResultArm=x.JudgeResultTask.ArmEnum,
                               SubjectId=x.SubjectId,
                               JudgeQuestionAnswerInfoList = x.ArmEnum== Arm.JudgeArm? x.JudgeResultTask.ReadingTaskQuestionAnswerList.Where(y=>y.ReadingQuestionTrial.IsJudgeQuestion).Select(y=> new JudgeQuestionAnswerInfo()
                               {
                                   Answer=y.Answer,
                                   QuestionName=y.ReadingQuestionTrial.QuestionName,

                               }).ToList() : x.ReadingTaskQuestionAnswerList.Where(y => y.ReadingQuestionTrial.IsJudgeQuestion).Select(y => new JudgeQuestionAnswerInfo()
                               {
                                   Answer = y.Answer,
                                   QuestionName = y.ReadingQuestionTrial.QuestionName,

                               }).ToList()
                           }).ToListAsync();

                List<TaskInfo> otherTask = await _visitTaskRepository.Where(x => x.ArmEnum != Arm.JudgeArm && x.SubjectId == taskInfo.SubjectId
                             && x.DoctorUserId != taskInfo.DoctorUserId && x.ReadingTaskState == ReadingTaskState.HaveSigned && x.ReReadingApplyState != ReReadingApplyState.Agree)
                       .Where(x => x.IsAnalysisCreate == taskInfo.IsAnalysisCreate)
                    .OrderBy(x => x.VisitTaskNum).Select(x => new TaskInfo()
                           {
                               TaskId = x.Id,
                               IsCurrentTask = x.Id == taskInfo.Id,
                               ReadingCategory = x.ReadingCategory,
                               TaskBlindName = x.TaskBlindName,
                               ArmEnum = x.ArmEnum,
                               TaskName = x.TaskName,
                               SouceReadModuleId = x.SouceReadModuleId,
                               SourceSubjectVisitId = x.SourceSubjectVisitId,
                           }).ToListAsync();

                medicalReviewInfo.TaskList.ForEach(x =>
                {
                    x.OtherTaskId = otherTask.Where(y => y.SouceReadModuleId == x.SouceReadModuleId && y.SourceSubjectVisitId == x.SourceSubjectVisitId).Select(y => y.TaskId).FirstOrDefault();
                });
            }
            else
            {
                medicalReviewInfo.TaskList = await _visitTaskRepository.Where(x => x.Id == taskInfo.Id).Select(x => new TaskInfo()
                {
                    TaskId = x.Id,
                    IsCurrentTask = x.Id == taskInfo.Id,
                    ReadingCategory = x.ReadingCategory,
                    TaskBlindName = x.TaskBlindName,
                    ArmEnum = x.ArmEnum,
                    TaskName = x.TaskName,
                    SouceReadModuleId = x.SouceReadModuleId,
                    SourceSubjectVisitId = x.SourceSubjectVisitId,
                    SubjectId = x.SubjectId,
                    JudgeQuestionAnswerInfoList = x.ArmEnum == Arm.JudgeArm ? x.JudgeResultTask.ReadingTaskQuestionAnswerList.Where(y => y.ReadingQuestionTrial.IsJudgeQuestion).Select(y => new JudgeQuestionAnswerInfo()
                    {
                        Answer = y.Answer,
                        QuestionName = y.ReadingQuestionTrial.QuestionName,

                    }).ToList() : x.ReadingTaskQuestionAnswerList.Where(y => y.ReadingQuestionTrial.IsJudgeQuestion).Select(y => new JudgeQuestionAnswerInfo()
                    {
                        Answer = y.Answer,
                        QuestionName = y.ReadingQuestionTrial.QuestionName,

                    }).ToList()
                }).ToListAsync();



                List<TaskInfo> otherTask = await _visitTaskRepository.Where(x => x.ArmEnum != Arm.JudgeArm && x.SouceReadModuleId == taskInfo.SouceReadModuleId && x.SourceSubjectVisitId == taskInfo.SourceSubjectVisitId
                           && x.DoctorUserId != taskInfo.DoctorUserId && x.ReadingTaskState == ReadingTaskState.HaveSigned && x.ReReadingApplyState != ReReadingApplyState.Agree
                           )
                       .Where(x => x.IsAnalysisCreate == taskInfo.IsAnalysisCreate)
                    .OrderBy(x => x.VisitTaskNum).Select(x => new TaskInfo()
                           {
                            TaskId = x.Id,
                            IsCurrentTask = x.Id == taskInfo.Id,
                            ReadingCategory = x.ReadingCategory,
                            TaskBlindName = x.TaskBlindName,
                            ArmEnum = x.ArmEnum,
                            TaskName = x.TaskName,
                            SouceReadModuleId = x.SouceReadModuleId,
                            SourceSubjectVisitId = x.SourceSubjectVisitId,
                        }).ToListAsync();

                medicalReviewInfo.TaskList.ForEach(x =>
                {
                    x.OtherTaskId = otherTask.Where(y => y.SouceReadModuleId == x.SouceReadModuleId && y.SourceSubjectVisitId == x.SourceSubjectVisitId).Select(y => y.TaskId).FirstOrDefault();
                });
            }
            #endregion
            medicalReviewInfo.QuestionAnswerList = await this.GetMedicalQuestionAnswer(inDto);


          
            var result = await _readingMedicineQuestionAnswerRepository.SaveChangesAsync();
            return medicalReviewInfo;

        }

        #region 问题
        private async Task<List<ReadingMedicineQuestion>> GetMedicalQuestionAnswer(GetMedicalReviewReadingTaskInDto inDto)
        {
            var medicalReview = await _taskMedicalReviewRepository.Where(x => x.Id == inDto.TaskMedicalReviewId).FirstNotNullAsync();
            var taskInfo = await _visitTaskRepository.Where(x => x.Id == medicalReview.VisitTaskId).FirstNotNullAsync();

            var questionQuery = from data in _readingMedicineTrialQuestionRepository.Where(x => x.TrialId == inDto.TrialId && x.IsConfirm && x.IsEnable&&x.ReadingCategory==taskInfo.ReadingCategory)
                                join questionAnswer in _readingMedicineQuestionAnswerRepository.Where(x => x.TaskMedicalReviewId == inDto.TaskMedicalReviewId) on data.Id equals questionAnswer.ReadingMedicineQuestionId into questionAnswerTemp
                                from leftquestionAnswer in questionAnswerTemp.DefaultIfEmpty()
                                select new ReadingMedicineQuestion()
                                {
                                    Id = data.Id,
                                    Type = data.Type,
                                    ParentTriggerValue = data.ParentTriggerValue,
                                    IsEnable = data.IsEnable,
                                    IsConfirm = data.IsConfirm,
                                    QuestionName = data.QuestionName,
                                    IsRequired = data.IsRequired,
                                    ShowOrder = data.ShowOrder,
                                    ParentId = data.ParentId,
                                    TypeValue = data.TypeValue,
                                    Answer = leftquestionAnswer.Answer
                                };

            var questionList = await questionQuery.OrderBy(x=>x.ShowOrder).ToListAsync();

            List<ReadingMedicineQuestion> medicineQuestionList = questionList.Where(x => x.ParentId == null).ToList();
            medicineQuestionList.ForEach(x =>
            {
                FindChildQuestion(x, questionList);
            });

            return medicineQuestionList;
        }


        private void FindChildQuestion(ReadingMedicineQuestion medicineQuestionList, List<ReadingMedicineQuestion> questionlists)
        {
            medicineQuestionList.Childrens = questionlists.Where(x => x.ParentId == medicineQuestionList.Id).ToList();
            if (medicineQuestionList.Childrens != null && medicineQuestionList.Childrens.Count != 0)
            {
                medicineQuestionList.Childrens.ForEach(x =>
                {
                    this.FindChildQuestion(x, questionlists);
                });
            }
        }
        #endregion



        /// <summary>
        /// 保存医学审核问题 答案
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public async Task<IResponseOutput> SaveMedicineQuestion(SaveMedicineQuestionInDto inDto)
        {
            var medicalReviewInfo = await _taskMedicalReviewRepository.Where(x => x.Id == inDto.TaskMedicalReviewId).FirstNotNullAsync();
            if (medicalReviewInfo.IsInvalid)
            {
                throw new BusinessValidationFailedException("该医学审核无效,操作失败");
            }
            await _readingMedicineQuestionAnswerRepository.BatchDeleteNoTrackingAsync(x => x.TaskMedicalReviewId == inDto.TaskMedicalReviewId);

            List<ReadingMedicineQuestionAnswer> questionAnswerList = inDto.QuestionAnswerList.Select(x => new ReadingMedicineQuestionAnswer()
            {
                Answer = x.Answer,
                ReadingMedicineQuestionId = x.Id,
                TaskMedicalReviewId = inDto.TaskMedicalReviewId,
                VisitTaskId = inDto.VisitTaskId,

            }).ToList();

            await _readingMedicineQuestionAnswerRepository.AddRangeAsync(questionAnswerList);

            await _taskMedicalReviewRepository.UpdatePartialFromQueryAsync(inDto.TaskMedicalReviewId, x => new TaskMedicalReview()
            {

                SaveQuestionTime = DateTime.Now,
                AuditState = MedicalReviewAuditState.Auditing,

            });



          

            var result = await _readingMedicineQuestionAnswerRepository.SaveChangesAsync();

           return  ResponseOutput.Result(result);

        }

        /// <summary>
        /// 保存医学审核 结论
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<IResponseOutput> SaveMedicalReviewInfo(SaveMedicalReviewInfoInDto inDto)
        {
            var medicalReviewInfo = await _taskMedicalReviewRepository.Where(x => x.Id == inDto.TaskMedicalReviewId).FirstNotNullAsync();
            if (medicalReviewInfo.IsInvalid)
            {
                throw new BusinessValidationFailedException("该医学审核无效,操作失败");
            }
            if ((await _taskMedicalReviewRepository.Where(x => x.Id == inDto.TaskMedicalReviewId).Select(x => x.SaveQuestionTime).FirstOrDefaultAsync()) == null)
            {
                return ResponseOutput.NotOk("请先保存医学审核问题");
            }
            await _taskMedicalReviewRepository.UpdatePartialFromQueryAsync(inDto.TaskMedicalReviewId, x => new TaskMedicalReview()
            {
                IsHaveQuestion = inDto.IsHaveQuestion,
                Questioning = inDto.Questioning,
                IsSendMessage = inDto.IsSendDialog && inDto.IsHaveQuestion,
                AuditAdviceEnum = inDto.AuditAdviceEnum,
                SaveConclusionTime=DateTime.Now,

            });

            var medicalReview = await _taskMedicalReviewRepository.Where(x => x.Id == inDto.TaskMedicalReviewId).FirstNotNullAsync();
            if (inDto.IsSendDialog&& !medicalReview.IsSendMessage && inDto.IsHaveQuestion)
            {
              
                await _readingMedicalReviewDialogRepository.AddAsync(new ReadingMedicalReviewDialog()
                {
                    AuditAdviceEnum = inDto.AuditAdviceEnum,
                    TaskMedicalReviewId = inDto.TaskMedicalReviewId,
                    UserTypeShortName = _userInfo.UserTypeShortName,
                    IsHaveQuestion=inDto.IsHaveQuestion,
                    Questioning=inDto.Questioning,
                    VisitTaskId= medicalReview.VisitTaskId,
                    FileName = medicalReview.FileName,
                    UserTypeEnumInt = _userInfo.UserTypeEnumInt,
                    ImagePath= medicalReview.ImagePath,
                });
            }

            var result = await _taskMedicalReviewRepository.SaveChangesAsync();
            return ResponseOutput.Result(result);
        }


        /// <summary>
        /// 关闭医学审核对话
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public async Task<IResponseOutput> ClosedMedicalReviewDialog(ClosedMedicalReviewDialogInDto inDto)
        {
            await _taskMedicalReviewRepository.UpdatePartialFromQueryAsync(inDto.TaskMedicalReviewId, x => new TaskMedicalReview()
            {
                IsClosedDialog = inDto.IsClosedDialog,
                MedicalDialogCloseEnum=inDto.MedicalDialogCloseEnum,
                DialogCloseReason=inDto.DialogCloseReason,
            });


            ReadingMedicalReviewDialog dialog = new ReadingMedicalReviewDialog()
            {
                TaskMedicalReviewId = inDto.TaskMedicalReviewId,
                UserTypeShortName = _userInfo.UserTypeShortName,
                Content = inDto.MedicalDialogCloseEnum.GetDescription()+ (inDto.DialogCloseReason.IsNullOrEmpty()? inDto.DialogCloseReason:","+ inDto.DialogCloseReason),
                UserTypeEnumInt = _userInfo.UserTypeEnumInt,
            };

            await _readingMedicalReviewDialogRepository.AddAsync(dialog);
            var result = await _taskMedicalReviewRepository.SaveChangesAsync();
            return ResponseOutput.Result(result);
        }

        /// <summary>
        /// 发送对话消息
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public  async Task<IResponseOutput> SendMedicalReviewDialog(SendMedicalReviewDialogInDto inDto)
        {
            var medicalReviewInfo = await _taskMedicalReviewRepository.Where(x => x.Id == inDto.TaskMedicalReviewId).FirstNotNullAsync();
            if (medicalReviewInfo.IsInvalid)
            {
                throw new BusinessValidationFailedException("该医学审核无效,操作失败");
            }

            var visitTaskId = await _taskMedicalReviewRepository.Where(x => x.Id == inDto.TaskMedicalReviewId).Select(x => x.VisitTaskId).FirstOrDefaultAsync();
            ReadingMedicalReviewDialog dialog = new ReadingMedicalReviewDialog()
            {
                TaskMedicalReviewId = inDto.TaskMedicalReviewId,
                UserTypeShortName = _userInfo.UserTypeShortName,
                Content = inDto.Content,
                UserTypeEnumInt = _userInfo.UserTypeEnumInt,
                VisitTaskId = visitTaskId,
                AuditAdviceEnum=inDto.AuditAdviceEnum,
              
                IsHaveQuestion=inDto.IsHaveQuestion,
                Questioning=inDto.Questioning,
            };

            await _readingMedicalReviewDialogRepository.AddAsync(dialog);

            var result=await _readingMedicalReviewDialogRepository.SaveChangesAsync();
            return ResponseOutput.Result(result);
        }

        /// <summary>
        /// IR发送消息
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task<IResponseOutput> IRSendMedicalReviewDialog(IRSendMedicalReviewDialogInDto inDto)
        {
            var medicalReviewInfo = await _taskMedicalReviewRepository.Where(x => x.Id == inDto.TaskMedicalReviewId).FirstNotNullAsync();
            if (medicalReviewInfo.IsInvalid)
            {
                throw new BusinessValidationFailedException("该医学审核无效,操作失败");
            }
            var visitTaskId = await _taskMedicalReviewRepository.Where(x => x.Id == inDto.TaskMedicalReviewId).Select(x => x.VisitTaskId).FirstOrDefaultAsync();
            if (inDto.IsApplyHeavyReading??false)
            {
                await _visitTaskService.ApplyReReading(new ApplyReReadingCommand()
                {
                    IsCopyOrigenalForms = inDto.IsCopyOrigenalForms??false,
                    IsCopyFollowForms=inDto.IsCopyFollowForms ?? false,
                    RequestReReadingReason = inDto.RequestReReadingReason,
                    RequestReReadingType = RequestReReadingType.DocotorApply,
                    TrialId = inDto.TrialId,
                    TaskIdList = new List<Guid>()
                 {
                     visitTaskId
                
                 }
                });
                await _taskMedicalReviewRepository.BatchUpdateNoTrackingAsync(x => !x.IsClosedDialog && x.Id == inDto.TaskMedicalReviewId, x => new TaskMedicalReview()
                {
                    IsClosedDialog = true,
                    MedicalDialogCloseEnum = MedicalDialogClose.IRApplyReReading,
                });
            }

            await _taskMedicalReviewRepository.BatchUpdateNoTrackingAsync(x =>  x.Id == inDto.TaskMedicalReviewId, x => new TaskMedicalReview()
            {
                DoctorUserIdeaEnum = inDto.DoctorUserIdeaEnum,
            });
            ReadingMedicalReviewDialog dialog = new ReadingMedicalReviewDialog()
            {
                TaskMedicalReviewId = inDto.TaskMedicalReviewId,
                UserTypeShortName = _userInfo.UserTypeShortName,
                Content = inDto.Content,
                ImagePath=inDto.ImagePath,
                UserTypeEnumInt = _userInfo.UserTypeEnumInt,
                VisitTaskId = visitTaskId,
                FileName=inDto.FileName,
                DisagreeReason = inDto.DisagreeReason,
                DoctorUserIdeaEnum = inDto.DoctorUserIdeaEnum,
                IsApplyHeavyReading = inDto.IsApplyHeavyReading,
            };

            await _readingMedicalReviewDialogRepository.AddAsync(dialog);
            var result = await _readingMedicalReviewDialogRepository.SaveChangesAsync();
            return ResponseOutput.Result(result);
        }


        /// <summary>
        /// 获取医学审核对话
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<(List<GetMedicalReviewDialogOutDto>,object)> GetMedicalReviewDialog(GetMedicalReviewDialogInDto inDto)
        {
            var taskMedicalReview = await _taskMedicalReviewRepository.Where(x => x.Id == inDto.TaskMedicalReviewId).FirstNotNullAsync();
            List<GetMedicalReviewDialogOutDto> result = await _readingMedicalReviewDialogRepository.Where(x => x.TaskMedicalReviewId == inDto.TaskMedicalReviewId)
                .ProjectTo<GetMedicalReviewDialogOutDto>(_mapper.ConfigurationProvider)
                .OrderBy(x => x.CreateTime).ToListAsync();
            result.ForEach(x => {
                x.IsCurrentUser = x.CreateUserId == _userInfo.Id;
            });
            return (result,new  {

            IsIRReply= result.Any(x=>x.UserTypeEnumInt== (int)UserTypeEnum.IndependentReviewer),
            taskMedicalReview.IsClosedDialog,
            taskMedicalReview.IsHaveQuestion,
            });
        }

        /// <summary>
        /// 完成医学审核
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [NonDynamicMethod]
        public async Task<IResponseOutput> FinishMedicalReview(FinishMedicalReviewInDto inDto)
        {
            var medicalReviewInfo = await _taskMedicalReviewRepository.Where(x => x.Id == inDto.TaskMedicalReviewId).FirstNotNullAsync();
            if (medicalReviewInfo.IsInvalid)
            {
                throw new BusinessValidationFailedException("该医学审核无效,操作失败");
            }

            var taskmedicalReview = await _taskMedicalReviewRepository.Where(x => x.Id == inDto.TaskMedicalReviewId).Select(x => new
            {
                x.SaveConclusionTime,
                x.SaveQuestionTime,
                x.IsClosedDialog,
                x.IsHaveQuestion

            }).FirstNotNullAsync();

            if (taskmedicalReview.SaveQuestionTime == null || taskmedicalReview.SaveConclusionTime==null)
            {
                throw new BusinessValidationFailedException("请先保存问题和结论");

            }

            if (taskmedicalReview.IsHaveQuestion&&!taskmedicalReview.IsClosedDialog)
            {
                throw new BusinessValidationFailedException("对话未关闭");

            }

            await _taskMedicalReviewRepository.UpdatePartialFromQueryAsync(inDto.TaskMedicalReviewId, x => new TaskMedicalReview()
            {
                AuditState = MedicalReviewAuditState.HaveSigned,
                AuditSignTime=DateTime.Now,
            });

            var result = await _taskMedicalReviewRepository.SaveChangesAsync();
            return ResponseOutput.Result(result);
        }

        /// <summary>
        /// IR回复确认医学审核
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IResponseOutput> IRConfirmMedicalReview(IRConfirmMedicalReviewInDto inDto)
        {
            var medicalReviewInfo = await _taskMedicalReviewRepository.Where(x => x.Id == inDto.TaskMedicalReviewId).FirstNotNullAsync();
            if (medicalReviewInfo.IsInvalid)
            {
                throw new BusinessValidationFailedException("该医学审核无效,操作失败");
            }

            await _taskMedicalReviewRepository.UpdatePartialFromQueryAsync(inDto.TaskMedicalReviewId, x => new TaskMedicalReview()
            {
                DoctorUserIdeaEnum = inDto.DoctorUserIdeaEnum,
                DisagreeReason = inDto.DisagreeReason,
                IsApplyHeavyReading=inDto.IsApplyHeavyReading,
            });

            var visitTaskId = await _taskMedicalReviewRepository.Where(x => x.Id == inDto.TaskMedicalReviewId).Select(x => x.VisitTaskId).FirstOrDefaultAsync();
            await _readingMedicalReviewDialogRepository.AddAsync(new ReadingMedicalReviewDialog()
            {
                
                TaskMedicalReviewId = inDto.TaskMedicalReviewId,
                UserTypeShortName = _userInfo.UserTypeShortName,
                DoctorUserIdeaEnum = inDto.DoctorUserIdeaEnum,
                DisagreeReason = inDto.DisagreeReason,
                IsApplyHeavyReading = inDto.IsApplyHeavyReading,
                VisitTaskId = visitTaskId,
                UserTypeEnumInt = _userInfo.UserTypeEnumInt,
            });

            var result = await _taskMedicalReviewRepository.SaveChangesAsync();
            return ResponseOutput.Result(result);
        }


        /// <summary>
        /// 获取IR医学审核信息
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<PageOutput<GetIRMedicalFeedbackListOutDto>> GetIRMedicalFeedbackList(GetIRMedicalFeedbackListInDto inDto)
        {
            var taskMedicalReviewquery = _taskMedicalReviewRepository.Where(x => x.TrialId == inDto.TrialId).Include(x => x.VisitTask)
                .Where(x => x.VisitTask.DoctorUserId == _userInfo.Id)
                .Where(x => x.IsHaveQuestion)
                .WhereIf(!inDto.TaskBlindName.IsNullOrEmpty(), x => x.VisitTask.TaskBlindName == inDto.TaskBlindName)
                 .WhereIf(inDto.IsUrgent != null, x => x.VisitTask.IsUrgent == inDto.IsUrgent!)
                 .WhereIf(inDto.AuditState != null, x => x.AuditState == inDto.AuditState!)
                 .WhereIf(inDto.ReadingCategory != null, x => x.VisitTask.ReadingCategory == inDto.ReadingCategory!)
                 .WhereIf(inDto.AuditAdviceEnum != null, x => x.AuditAdviceEnum == inDto.AuditAdviceEnum!)
                 .WhereIf(inDto.DoctorUserIdeaEnum != null, x => x.DoctorUserIdeaEnum == inDto.DoctorUserIdeaEnum!)
                 .WhereIf(inDto.IsClosedDialog != null, x => x.IsClosedDialog == inDto.IsClosedDialog!)
                 .WhereIf(inDto.IsHaveQuestion != null, x => x.IsHaveQuestion == inDto.IsHaveQuestion!)
                 .WhereIf(inDto.MedicalDialogCloseEnum != null, x => x.MedicalDialogCloseEnum == inDto.MedicalDialogCloseEnum!)
                 .WhereIf(inDto.IsInvalid != null, x => x.IsInvalid == inDto.IsInvalid!)
                .Select(x => new GetIRMedicalFeedbackListOutDto
                {
                    TaskState=x.VisitTask.TaskState,
                    Id = x.Id,
                    VisitTaskId=x.VisitTaskId,
                    IsUrgent = x.VisitTask.IsUrgent,
                    AuditState = x.AuditState,
                    SubjectCode = x.VisitTask.BlindSubjectCode == string.Empty ? x.VisitTask.Subject.Code : x.VisitTask.BlindSubjectCode,
                    TaskBlindName = x.VisitTask.TaskBlindName,
                    ReadingCategory = x.VisitTask.ReadingCategory,
                    FirstReplyTime = x.ReadingMedicalReviewDialogList.Min(x => x.CreateTime),
                    LastReplyTime = x.ReadingMedicalReviewDialogList.Max(x => x.CreateTime),
                    AuditAdviceEnum = x.AuditAdviceEnum,
                    DoctorUserIdeaEnum = x.DoctorUserIdeaEnum,
                    SaveConclusionTime=x.SaveConclusionTime,
                    IsClosedDialog=x.IsClosedDialog,
                    IsHaveQuestion=x.IsHaveQuestion,
                    MedicalDialogCloseEnum=x.MedicalDialogCloseEnum,
                    IsInvalid=x.IsInvalid,

                }).WhereIf(!inDto.SubjectCode.IsNullOrEmpty(), x => x.SubjectCode == inDto.SubjectCode);

            var result=await taskMedicalReviewquery.ToPagedListAsync(inDto.PageIndex, inDto.PageSize, inDto.SortField.IsNullOrEmpty() ? nameof(GetIRMedicalFeedbackListOutDto.AuditState) : inDto.SortField,
               inDto.Asc);

            return result;
        }
    }
} 
