//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.Domain.Share;
//using IRaCIS.Core.Application.Service.Reading.Dto;
//using Panda.DynamicWebApi.Attributes;

//namespace IRaCIS.Core.Application.Service
//{


//    [ApiExplorerSettings(GroupName = "Reading")]
//    public class ReadingQuestionService : BaseService
//    {

//        //private readonly IRepository<SubjectVisit> _subjectVisitRepository;
//        private readonly IRepository<ReadingQuestionCriterionSystem> _readingQuestionCriterionSystemRepository;
//        private readonly IRepository<ReadingQuestionCriterionTrial> _readingQuestionCriterionTrialRepository;
//        //private readonly IRepository<ReadingQuestionSystem> _readingQuestionSystemRepository;
//        private readonly IRepository<ReadingQuestionTrial> _readingQuestionTrialRepository;
//        //private readonly IRepository<ClinicalDataTrialSet> _clinicalDataTrialSetRepository;
//        //private readonly IRepository<ClinicalDataSystemSet> _clinicalDataSystemSetRepository;
//        //private readonly IRepository<Dictionary> _dictionaryRepository;
//        //private readonly IRepository<ReadingTableQuestionTrial> _readingTableQuestionTrialRepository;
//        //private readonly IRepository<ReadingCriterionPage> _readingCriterionPageRepository;
//        //private readonly IRepository<Trial> _trialRepository;
//        //private readonly IRepository<TumorAssessment> _tumorAssessmentRepository;
//        //private readonly IRepository<OrganInfo> _organInfoRepository;
//        //private readonly IRepository<ReadingTableQuestionSystem> _readingTableQuestionSystemRepository;
//        private readonly IRepository<ReadingTaskQuestionAnswer> _readingTaskQuestionAnswer;
//        //private readonly IRepository<PreviousPDF> _previousPDFRepository;

//        public ReadingQuestionService(
//            IRepository<ReadingQuestionCriterionSystem> readingQuestionCriterionSystemRepository,
//            IRepository<ReadingQuestionCriterionTrial> readingQuestionCriterionTrialRepository,
//            //IRepository<ReadingQuestionSystem> readingQuestionSystemRepository,
//            IRepository<ReadingQuestionTrial> readingQuestionTrialRepository,
//            //IRepository<ClinicalDataTrialSet> ClinicalDataTrialSetRepository,
//            //IRepository<ClinicalDataSystemSet> ClinicalDataSystemSetRepository,
//            //IRepository<Dictionary> dictionaryRepository,
//            //IRepository<ReadingTableQuestionTrial> readingTableQuestionTrialRepository,
//            //IRepository<ReadingCriterionPage> readingCriterionPageRepository,
//            //IRepository<Trial> trialRepository,
//            //IRepository<TumorAssessment> tumorAssessmentRepository,
//            //IRepository<OrganInfo> organInfoRepository,
//            //IRepository<ReadingTableQuestionSystem> readingTableQuestionSystemRepository,
//            IRepository<ReadingTaskQuestionAnswer> readingTaskQuestionAnswer
//            //IRepository<PreviousPDF> previousPDFRepository
//            //IRepository<SubjectVisit> subjectVisitRepository,

//          )
//        {
//            //this._subjectVisitRepository = subjectVisitRepository;
//            this._readingQuestionCriterionSystemRepository = readingQuestionCriterionSystemRepository;
//            this._readingQuestionCriterionTrialRepository = readingQuestionCriterionTrialRepository;
//            //this._readingQuestionSystemRepository = readingQuestionSystemRepository;
//            this._readingQuestionTrialRepository = readingQuestionTrialRepository;
//            //this._clinicalDataTrialSetRepository = ClinicalDataTrialSetRepository;
//            //this._clinicalDataSystemSetRepository = ClinicalDataSystemSetRepository;
//            //this._dictionaryRepository = dictionaryRepository;
//            //this._readingTableQuestionTrialRepository = readingTableQuestionTrialRepository;
//            //this._readingCriterionPageRepository = readingCriterionPageRepository;
//            //this._trialRepository = trialRepository;
//            //this._tumorAssessmentRepository = tumorAssessmentRepository;
//            //this._organInfoRepository = organInfoRepository;
//            //this._readingTableQuestionSystemRepository = readingTableQuestionSystemRepository;
//            this._readingTaskQuestionAnswer = readingTaskQuestionAnswer;
//            //this._previousPDFRepository = previousPDFRepository;
//        }


//        #region 系统标准
//        /// <summary>
//        /// 获取获取系统阅片标准下拉
//        /// </summary>
//        /// <returns></returns>
//        [HttpPost]
//        public async Task<List<GetSystemCriterionListOutDto>> GetSystemCriterionList()
//        {
//            List<GetSystemCriterionListOutDto> result = await _readingQuestionCriterionSystemRepository.Select(x => new GetSystemCriterionListOutDto()
//            {

//                CriterionId = x.Id,
//                CriterionName = x.CriterionName,

//            }).ToListAsync();

//            return result;
//        }

//        /// <summary>
//        /// 获取系统问题标准
//        /// </summary>
//        /// <returns></returns>
//        [HttpPost]
//        public async Task<PageOutput<ReadingQuestionCriterionSystemView>> GetReadingQuestionCriterionSystemList(ReadingQuestionCriterionSystemViewInDto inDto)
//        {
//            //await AddSystemQuestionCriterion();
//            var query = _readingQuestionCriterionSystemRepository.AsQueryable()
//                 .WhereIf(!inDto.CriterionName.IsNullOrEmpty(), x => x.CriterionName.Contains(inDto.CriterionName))
//                 .ProjectTo<ReadingQuestionCriterionSystemView>(_mapper.ConfigurationProvider);

//            return await query.ToPagedListAsync(inDto.PageIndex, inDto.PageSize, inDto.SortField.IsNullOrEmpty() ? nameof(ReadingQuestionCriterionSystemView.ShowOrder) : inDto.SortField,
//             inDto.Asc);
//        }

//        /// <summary>
//        /// 获取系统问题标准下拉
//        /// </summary>
//        /// <returns></returns>
//        [HttpPost]
//        public async Task<List<GetSystemCriterionSelectDto>> GetSystemCriterionSelectList()
//        {
//            var criterionList = await _readingQuestionCriterionSystemRepository.AsQueryable()
//                .OrderBy(x => x.ShowOrder)
//               .Select(x => new GetSystemCriterionSelectDto()
//               {
//                   Id = x.Id,
//                   CriterionName = x.CriterionName,

//               }).ToListAsync();
//            return criterionList;
//        }

//        /// <summary>
//        /// 新增修改系统问题标准
//        /// </summary>
//        /// <param name="indto"></param>
//        /// <returns></returns>
//        [HttpPost]
//        public async Task<IResponseOutput> AddOrUpdateReadingQuestionCriterionSystem(AddOrUpdateReadingQuestionCriterionSystemInDto indto)
//        {
//            var entity = await _readingQuestionCriterionSystemRepository.InsertOrUpdateAsync(indto, true);

//            if (indto.Id != null)
//            {
//                await _readingQuestionCriterionTrialRepository.BatchUpdateNoTrackingAsync(x => x.ReadingQuestionCriterionSystemId == indto.Id, x => new ReadingQuestionCriterionTrial()
//                {
//                    CriterionName = indto.CriterionName,
//                    CriterionType = indto.CriterionType,

//                });
//            }
//            return ResponseOutput.Ok(entity.Id.ToString());
//        }

//        /// <summary>
//        /// 删除系统问题标准
//        /// </summary>
//        /// <param name="id"></param>
//        /// <returns></returns>
//        [HttpDelete("{id:guid}")]
//        public async Task<IResponseOutput> DeleteReadingQuestionCriterionSystem(Guid id)
//        {


//            if (await _readingQuestionCriterionTrialRepository.AnyAsync(x => x.IsConfirm && x.ReadingQuestionCriterionSystemId == id))
//            {
//                throw new BusinessValidationFailedException("当前标准被引用过了，不可以删除");
//            }

//            await _readingQuestionCriterionSystemRepository.DeleteFromQueryAsync(t => t.Id == id);
//            var success = await _readingQuestionCriterionSystemRepository.SaveChangesAsync();
//            return ResponseOutput.Result(success);
//        }



//        /// <summary>
//        /// 设置系统问题标准是否完成配置
//        /// </summary>
//        /// <param name="inDto"></param>
//        /// <returns></returns>
//        public async Task<IResponseOutput> SetSystemReadingQuestionCriterionIsCompleteConfig(SetSystemReadingQuestionCriterionIsIsCompleteConfig inDto)
//        {

//            if (!inDto.IsCompleteConfig)
//            {
//                var trialCriterionIds = await _readingQuestionCriterionTrialRepository.Where(x => x.ReadingQuestionCriterionSystemId == inDto.Id).Select(x => x.Id).ToListAsync();
//                if (await _readingTaskQuestionAnswer.AnyAsync(x => trialCriterionIds.Contains(x.ReadingQuestionCriterionTrialId)))
//                {
//                    return ResponseOutput.NotOk("此标准在项目里面已被使用,操作失败");
//                }
//            }

//            var systemCriterion = await _readingQuestionCriterionSystemRepository.Where(x => x.Id == inDto.Id).AsNoTracking().FirstOrDefaultAsync();

//            var confirmTime = systemCriterion.ConfirmTime;

//            if (inDto.IsCompleteConfig)
//            {
//                confirmTime = DateTime.Now;
//            }

//            await _readingQuestionCriterionSystemRepository.UpdatePartialFromQueryAsync(inDto.Id, x => new ReadingQuestionCriterionSystem()
//            {
//                IsCompleteConfig = inDto.IsCompleteConfig,
//                ConfirmTime = confirmTime,
//            });

//            if (inDto.IsCompleteConfig)
//            {
//                //await SynchronizeSystemCriterion(inDto.Id);
//            }
//            else
//            {
//                await _readingQuestionCriterionTrialRepository.BatchUpdateNoTrackingAsync(x => x.ReadingQuestionCriterionSystemId == inDto.Id, x => new ReadingQuestionCriterionTrial()
//                {
//                    IsCompleteConfig = inDto.IsCompleteConfig
//                });
//            }
//            var result = await _readingQuestionCriterionSystemRepository.SaveChangesAsync();

//            return ResponseOutput.Ok(result);
//        }


//        #endregion

//        #region 项目标准

//        /// <summary>
//        /// 获取项目裁判信息
//        /// </summary>
//        /// <param name="inDto"></param>
//        /// <returns></returns>
//        [HttpPost]
//        public async Task<GetTrialJudgyInfoOutDto> GetTrialJudgyInfo(GetTrialJudgyInfoInDto inDto)
//        {
//            GetTrialJudgyInfoOutDto result = await _readingQuestionCriterionTrialRepository.Where(x => x.Id == inDto.TrialReadingCriterionId).Select(x => new GetTrialJudgyInfoOutDto
//            {
//                TrialId = x.TrialId,
//                IsReadingTaskViewInOrder = x.IsReadingTaskViewInOrder,
//                ArbitrationRule = x.ArbitrationRule,
//                IsArbitrationReading = x.IsArbitrationReading

//            }).FirstNotNullAsync();

//            return result;
//        }

//        /// <summary>
//        /// 新增修改项目问题标准（项目）
//        /// </summary>
//        /// <param name="indto"></param>
//        /// <returns></returns>
//        [HttpPost]
//        public async Task<IResponseOutput> AddOrUpdateReadingQuestionCriterionTrial(AddOrUpdateReadingQuestionCriterionTrialInDto indto)
//        {

//            var entity = await _readingQuestionCriterionTrialRepository.InsertOrUpdateAsync(indto, true);
//            return ResponseOutput.Ok(entity.Id.ToString());
//        }



//        /// <summary>
//        /// 设置项目标准是否完成配置
//        /// </summary>
//        /// <param name="inDto"></param>
//        /// <returns></returns>
//        public async Task<IResponseOutput> SetTrialReadingQuestionCriterionIsIsCompleteConfig(SetSystemReadingQuestionCriterionIsIsCompleteConfig inDto)
//        {
//            await _readingQuestionCriterionTrialRepository.UpdatePartialFromQueryAsync(inDto.Id, x => new ReadingQuestionCriterionTrial()
//            {
//                IsCompleteConfig = inDto.IsCompleteConfig
//            });

//            var result = await _readingQuestionCriterionTrialRepository.SaveChangesAsync();

//            return ResponseOutput.Ok(result);
//        }

//        /// <summary>
//        /// 获取项目问题标准（项目）
//        /// </summary>
//        /// <returns></returns>
//        [HttpPost]
//        public async Task<PageOutput<ReadingQuestionCriterionTrialView>> GetReadingQuestionCriterionTrialList(ReadingQuestionCriterionTrialViewInDto inDto)
//        {
//            //await AddSystemDataToTrila(inDto.TrialId);
//            var query = _readingQuestionCriterionTrialRepository.AsQueryable()
//                .Where(x => x.TrialId == inDto.TrialId)
//                .Where(x => (x.ReadingQuestionCriterionSystemId != null && x.IsEnable) || x.ReadingQuestionCriterionSystemId == null)
//                 .WhereIf(!inDto.CriterionName.IsNullOrEmpty(), x => x.CriterionName.Contains(inDto.CriterionName))

//                 .ProjectTo<ReadingQuestionCriterionTrialView>(_mapper.ConfigurationProvider);
//            return await query.ToPagedListAsync(inDto.PageIndex, inDto.PageSize, inDto.SortField.IsNullOrEmpty() ? nameof(ReadingQuestionCriterionTrialView.ShowOrder) : inDto.SortField,
//             inDto.Asc);
//        }

//        /// <summary>
//        /// 删除项目问题标准（项目）
//        /// </summary>
//        /// <param name="id"></param>
//        /// <returns></returns>
//        [HttpDelete("{id:guid}")]
//        public async Task<IResponseOutput> DeleteReadingQuestionCriterionTrial(Guid id)
//        {
//            await _readingQuestionCriterionTrialRepository.DeleteFromQueryAsync(t => t.Id == id);
//            var success = await _readingQuestionCriterionTrialRepository.SaveChangesAsync();
//            return ResponseOutput.Result(success);
//        }

//        /// <summary>
//        /// 设置项目裁判信息
//        /// </summary>
//        /// <param name="inDto"></param>
//        /// <returns></returns>
//        [HttpPost]
//        public async Task<IResponseOutput> SetTrialJudgyInfo(SetTrialJudgyInfoInDto inDto)
//        {

//            var trialCriterion = await _readingQuestionCriterionTrialRepository.Where(x => x.TrialId == inDto.TrialId && x.Id == inDto.TrialReadingCriterionId).FirstOrDefaultAsync();

//            var judgeCount = await _readingQuestionTrialRepository.Where(x => x.ReadingQuestionCriterionTrialId == trialCriterion.Id && x.IsJudgeQuestion)
//                  .WhereIf(trialCriterion.FormType == FormType.SinglePage, x => x.ReadingCriterionPageId == null)
//                 .WhereIf(trialCriterion.FormType == FormType.MultiplePage, x => x.ReadingCriterionPageId != null).CountAsync();

//            if (judgeCount == 0 && (inDto.ArbitrationRule == ArbitrationRule.Visit || inDto.ArbitrationRule == ArbitrationRule.Reading))
//            {
//                throw new BusinessValidationFailedException("无裁判问题却有仲裁对象,操作失败");
//            }
//            await _readingQuestionCriterionTrialRepository.UpdatePartialFromQueryAsync(inDto.TrialReadingCriterionId, x => new ReadingQuestionCriterionTrial()
//            {
//                ArbitrationRule = inDto.ArbitrationRule,
//                //IsArbitrationReading = inDto.IsArbitrationReading,
//            });

//            var result = await _readingQuestionCriterionTrialRepository.SaveChangesAsync();
//            return ResponseOutput.Ok(result);
//        }


//        #endregion


//        /// <summary>
//        /// 添加系统数据到项目里面
//        /// </summary>
//        /// <returns></returns>  
//        [NonDynamicMethod]
//        private async Task AddSystemDataToTrila(Guid trialId)
//        {
//            var trialUsrSystemIds = _readingQuestionCriterionTrialRepository.Where(x => x.TrialId == trialId && x.ReadingQuestionCriterionSystemId != null)
//                .Select(x => x.ReadingQuestionCriterionSystemId);
//            var trialCriterionNames = _readingQuestionCriterionTrialRepository.Where(x => x.TrialId == trialId)
//                .Select(x => x.CriterionName);
//            List<ReadingQuestionCriterionTrial> needAddCriterionList = await _readingQuestionCriterionSystemRepository.Where(x => !trialUsrSystemIds.Contains(x.Id) && x.IsEnable && !trialCriterionNames.Contains(x.CriterionName)).ProjectTo<ReadingQuestionCriterionTrial>(_mapper.ConfigurationProvider).ToListAsync();

//            List<ReadingQuestionTrial> needAddQuestionList = new List<ReadingQuestionTrial>();
//            needAddCriterionList.ForEach(x =>
//            {
//                //x.IsEnable = false;
//                x.TrialId = trialId;
//                x.ReadingQuestionCriterionSystemId = x.Id;
//                x.Id = NewId.NextGuid();
//                // 同步问题暂时注释
//                //List<ReadingQuestionTrial> readingQuestionTrialList = new List<ReadingQuestionTrial>();
//                //SetChildParentQuestion(criterion.Id, trialId, systemQuestionList, readingQuestionTrialList);
//                //needAddQuestionList.AddRange(readingQuestionTrialList);
//            });
//            await _readingQuestionCriterionTrialRepository.AddRangeAsync(needAddCriterionList);
//            await _readingQuestionTrialRepository.AddRangeAsync(needAddQuestionList);
//            await _readingQuestionTrialRepository.SaveChangesAsync();
//        }

//    }
//}