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

namespace IRaCIS.Core.Application.Service
{
    /// <summary>
    /// 阅片问题.标准
    /// </summary>
    [ApiExplorerSettings(GroupName = "Reading")]
    public class ReadingQuestionService(IRepository<SubjectVisit> _subjectVisitRepository,
        IRepository<ReadingQuestionCriterionSystem> _readingQuestionCriterionSystemRepository,
        IRepository<ReadingQuestionCriterionTrial> _readingQuestionCriterionTrialRepository,
        IRepository<ReadingQuestionSystem> _readingQuestionSystemRepository,
        IRepository<ReadingQuestionTrial> _readingQuestionTrialRepository,
        IRepository<ClinicalDataTrialSet> _clinicalDataTrialSetRepository,
        IRepository<ClinicalDataSystemSet> _clinicalDataSystemSetRepository,
        IRepository<Dictionary> _dictionaryRepository,
        IReadingImageTaskService _iReadingImageTaskService,
        IRepository<ReadingSystemCriterionDictionary> _readingCriterionDictionaryRepository,
        IRepository<ReadingTableQuestionTrial> _readingTableQuestionTrialRepository,
        IRepository<ReadingCriterionPage> _readingCriterionPageRepository,
        IRepository<Trial> _trialRepository,
        IRepository<TumorAssessment_RECIST1Point1> _tumorAssessmentRepository,
        IRepository<OrganInfo> _organInfoRepository,
        IRepository<ReadingTableQuestionSystem> _readingTableQuestionSystemRepository,
        IRepository<ReadingTaskQuestionAnswer> _readingTaskQuestionAnswer,
        IRepository<PreviousPDF> _previousPDFRepository, IMapper _mapper, IUserInfo _userInfo, IStringLocalizer _localizer) : BaseService, IReadingQuestionService

    {


        #region 获取计算问题

        ///// <summary>
        ///// 获取自定义问题预览
        ///// </summary>
        ///// <returns></returns>
        //[HttpPost]
        //public async Task<(List<DicomReadingQuestionAnswer>,bool)> GetCustomQuestionPreview(GetCustomQuestionPreviewInDto inDto)
        //{
        //   return (await _iReadingImageTaskService.GetReadingQuestion(inDto.TrialReadingCriterionId, null),true);
        //}

        /// <summary>
        /// 设置项目问题导出
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<bool> SetTrialQuestionExportResult(SetTrialQuestionExportResultInDto inDto)
        {
            List<ExportResult> needAdd = new List<ExportResult>()
            {
            };
            if (inDto.ExportType == ExportType.Basic)
            {
                needAdd = new List<ExportResult>()
                {
                    ExportResult.DetailedTableOfAdjudicationResults,
                    ExportResult.DetailedTableOfIntraReaderAnalysisResults,
                    ExportResult.DetailedTableOfInterReaderAnalysisResults
                };
            }
            foreach (var item in inDto.QuestionList) 
             {
                item.ExportResult= item.ExportResult.Except(needAdd).ToList();
                if (item.ExportResult.Contains(ExportResult.TableOfAssessmentResults))
                {
                    item.ExportResult.AddRange(needAdd);
                }
                var ExportResultStr=JsonConvert.SerializeObject(item.ExportResult);
                await _readingQuestionTrialRepository.UpdatePartialFromQueryAsync(x => x.Id == item.QuestionId, x => new ReadingQuestionTrial()
                {
                    ExportResultStr = ExportResultStr,
                    CDISCCode = item.CDISCCode,
                });

            }

            foreach (var item in inDto.TableQuestionList)
            {
                item.ExportResult = item.ExportResult.Except(needAdd).ToList();
                if (item.ExportResult.Contains(ExportResult.TableOfAssessmentResults))
                {
                    item.ExportResult.AddRange(needAdd);
                }

                var ExportResultStr = JsonConvert.SerializeObject(item.ExportResult);


                await _readingTableQuestionTrialRepository.UpdatePartialFromQueryAsync(x => x.Id == item.TableQuestionId, x => new ReadingTableQuestionTrial()
                {
                    ExportResultStr = ExportResultStr,
                    CDISCCode = item.CDISCCode,
                });
            }

            return   await _readingTableQuestionTrialRepository.SaveChangesAsync();
        }

        /// <summary>
        /// 获取项目的导出信息
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<GetTrialQuestionExportResultOutDto> GetTrialQuestionExportResult(GetTrialQuestionExportResultInDto inDto)
        {
            var questionList = await _readingQuestionTrialRepository.Where(x => x.Type != ReadingQestionType.Group && x.ReadingQuestionCriterionTrialId == inDto.TrialReadingCriterionId)
                .OrderBy(x => x.ShowOrder).Select(x => new TrialQuestionExport()
                {
                    QuestionId = x.Id,
                    QuestionName = _userInfo.IsEn_Us ? x.QuestionEnName : x.QuestionName,
                    ExportResult = x.ExportResult,
                    ShowOrder = x.ShowOrder,
                    CDISCCode = x.CDISCCode,
                }).ToListAsync();

            var questionid = questionList.Select(x => x.QuestionId).ToList();

            var tableQuestionList = await _readingTableQuestionTrialRepository.Where(x => questionid.Contains(x.ReadingQuestionId))
               .OrderBy(x => x.ShowOrder).Select(x => new TrialQuestionExport()
               {
                   QuestionId = x.ReadingQuestionId,
                   TableQuestionId = x.Id,
                   QuestionName = _userInfo.IsEn_Us ? x.QuestionEnName : x.QuestionName,
                   ExportResult = x.ExportResult,
                   ShowOrder = x.ShowOrder,
                   CDISCCode = x.CDISCCode,
               }).ToListAsync();

            questionList.ForEach(x =>
            {
                x.Children = tableQuestionList.Where(y => y.QuestionId == x.QuestionId).OrderBy(y => y.ShowOrder).ToList();
            });

            List<string> dicCode = new List<string>() { "1","2"};

            if (inDto.ExportType == ExportType.CDISC)
            {
                dicCode = new List<string>() { "8" };
            }
            var dicList = await _dictionaryRepository.Where(x => x.Parent.Code == "ExportResult")
                .Where(x=> dicCode.Contains(x.Code))
                .OrderBy(x => x.ShowOrder)
                .Select(x => new TrialQuestionExportDic()
                {

                    Code = int.Parse(x.Code),
                    Value = _userInfo.IsEn_Us ? x.Value : x.ValueCN,
                    ValueCN = _userInfo.IsEn_Us ? x.Value : x.ValueCN,
                }).ToListAsync();

            return new GetTrialQuestionExportResultOutDto()
            {
                DicList = dicList,
                QuestionList = questionList
            };
        }



        /// <summary>
        /// 获取自定义表格问题预览
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public async Task<(GetReadingTableQuestionOutDto, bool)> GetCustomTableQuestionPreview(GetCustomQuestionPreviewInDto inDto)
        {
            List<ReadingTableQuestionAnswerInfo> tableAnswers = new List<ReadingTableQuestionAnswerInfo>();
            List<TableAnsweRowInfo> tableAnsweRowInfos = new List<TableAnsweRowInfo>();
            return (await _iReadingImageTaskService.GetReadingTableQuestion(

                new GetReadingTableQuestionOrAnswerInDto()
                {
                    TrialReadingCriterionId = inDto.TrialReadingCriterionId,
                    TableAnswers = tableAnswers,
                    TableAnsweRowInfos = tableAnsweRowInfos,
                    IsGetallQuestion = true,
                    IsGetPreview = true
                }

               ), true);
        }



        public async Task<Object> Test()
        {
            return await _readingQuestionTrialRepository.Select(x => x.QuestionName.LanguageName(x.QuestionEnName, _userInfo.IsEn_Us)).FirstAsync();
        }

        /// <summary>
        /// 获取问题
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<(List<GetCalculateQuestionsOutDto>,bool)> GetCalculateQuestions(GetCalculateQuestionsInDto inDto)
        {
            var result = await _readingQuestionTrialRepository

         .Where(x => x.ReadingQuestionCriterionTrialId == inDto.TrialCriterionId)
         .WhereIf(!inDto.Type.IsNullOrEmpty(), x => x.Type == inDto.Type)
         .WhereIf(inDto.TypeList.Count()>0, x => inDto.TypeList.Contains(x.Type))
         .OrderBy(x => x.ShowOrder)
         .ProjectTo<GetCalculateQuestionsOutDto>(_mapper.ConfigurationProvider).ToListAsync();


            var tablequestion=await _readingTableQuestionTrialRepository.Where(x=>x.TrialCriterionId==inDto.TrialCriterionId).ToListAsync();

            result.ForEach(x =>
            {
                x.TableQuestions = tablequestion.Where(y => y.ReadingQuestionId == x.Id).ToList();
            });

            return (result,true);
        }

        /// <summary>
        /// 获取系统计算问题
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<GetSystemCalculateQuestionsOutDto>> GetSystemCalculateQuestions(GetSystemCalculateQuestionsInDto inDto)
        {
            var result = await _readingQuestionSystemRepository

         .Where(x => x.ReadingQuestionCriterionSystemId == inDto.SystemCriterionId)
         .WhereIf(!inDto.Type.IsNullOrEmpty(), x => x.Type == inDto.Type)
         .WhereIf(inDto.TypeList.Count() > 0, x => inDto.TypeList.Contains(x.Type))
         .OrderBy(x => x.ShowOrder)
        .ProjectTo<GetSystemCalculateQuestionsOutDto>(_mapper.ConfigurationProvider).ToListAsync() ;


            var tablequestion = await _readingTableQuestionSystemRepository.Where(x => x.SystemCriterionId == inDto.SystemCriterionId).ToListAsync();

            result.ForEach(x =>
            {

                x.TableQuestions = tablequestion.Where(y => y.ReadingQuestionId == x.Id).ToList();
            });

            return result;
        }


        /// <summary>
        /// 获取表格问题
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<GetCalculateTableQuestionsOutDto>> GetCalculateTableQuestions(GetCalculateTableQuestionsInDto inDto)
        {

            var result = await _readingTableQuestionTrialRepository

         .Where(x => x.ReadingQuestionId == inDto.QuestionId)
         .WhereIf(!inDto.Type.IsNullOrEmpty(), x => x.Type == inDto.Type)
         .WhereIf(inDto.TypeList.Count() > 0, x => inDto.TypeList.Contains(x.Type))


         .OrderBy(x => x.ShowOrder)
          .ProjectTo<GetCalculateTableQuestionsOutDto>(_mapper.ConfigurationProvider, new
          {
              isEn_Us = _userInfo.IsEn_Us,
          }).ToListAsync();

            return result;
        }

        /// <summary>
        /// 获取系统表格问题
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<GetCalculateTableQuestionsOutDto>> GetSystemCalculateTableQuestions(GetCalculateTableQuestionsInDto inDto)
        {

            var result = await _readingTableQuestionSystemRepository

         .Where(x => x.ReadingQuestionId == inDto.QuestionId)
         .WhereIf(!inDto.Type.IsNullOrEmpty(), x => x.Type == inDto.Type)
         .WhereIf(inDto.TypeList.Count() > 0, x => inDto.TypeList.Contains(x.Type))
         .OrderBy(x => x.ShowOrder)
          .ProjectTo<GetCalculateTableQuestionsOutDto>(_mapper.ConfigurationProvider, new
          {
              isEn_Us = _userInfo.IsEn_Us,
          }).ToListAsync();

            return result;
        }


        #endregion


        #region 系统标准问题

        /// <summary>
        /// 获取系统问题分组
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<GetTrialGroupNameOutDto>> GetSystemGroupNameList(GetTrialGroupNameListInDto inDto)
        {
            var result = await _readingQuestionSystemRepository.Where(x => x.ReadingQuestionCriterionSystemId == inDto.CriterionId && x.Type == ReadingQestionType.Group).OrderBy(t => t.ShowOrder)
                  .Select(x => new GetTrialGroupNameOutDto()
                  {
                      GroupId = x.Id,
                      GroupName = x.GroupName,

                  }).ToListAsync();
            return result;

        }

        /// <summary>
        /// 获取系统问题
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public async Task<PageOutput<ReadingQuestionSystemView>> GetReadingQuestionSystemList(ReadingQuestionSystemViewInDto inDto)
        {
            var query = _readingQuestionSystemRepository.AsQueryable()
                .Where(x => x.ReadingQuestionCriterionSystemId == inDto.ReadingQuestionCriterionSystemId)
                 .WhereIf(!inDto.QuestionName.IsNullOrEmpty(), x => x.QuestionName.Contains(inDto.QuestionName))
                  .WhereIf(!inDto.Type.IsNullOrEmpty(), x => x.Type.Contains(inDto.Type))
                 .ProjectTo<ReadingQuestionSystemView>(_mapper.ConfigurationProvider);
            return await query.ToPagedListAsync(inDto, nameof(ReadingQuestionSystemView.ShowOrder));
        }

        /// <summary>
        /// 获取系统标准的其他问题
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<CriterionOtherQuestionOutDto>> GetSystemCriterionOtherQuestion(GetSystemCriterionOtherQuestionInDto inDto)
        {
            var types = new List<string>()
            {
                "select","radio"
            };
            var questionList = await _readingQuestionSystemRepository.Where(x => x.ReadingQuestionCriterionSystemId == inDto.ReadingQuestionCriterionSystemId)
                .Where(x => types.Contains(x.Type))
                .WhereIf(inDto.Id != null, x => x.Id != inDto.Id && x.ParentId != inDto.Id)
                .Select(x => new CriterionOtherQuestionOutDto()
                {
                    QuestionId = x.Id,
                    DictionaryCode = x.DictionaryCode,
                    QuestionGenre = x.QuestionGenre,
                    QuestionName = x.QuestionName.LanguageName(x.QuestionEnName, _userInfo.IsEn_Us),
                    TypeValue = x.TypeValue,
                    GroupName = x.GroupName,
                    GroupId = x.GroupId,
                }).ToListAsync();

            return questionList;
        }

        /// <summary>
        /// 新增修改系统问题
        /// </summary>
        /// <param name="indto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IResponseOutput> AddOrUpdateReadingQuestionSystem(AddOrUpdateReadingQuestionSystemInDto indto)
        {
            indto.ParentTriggerValue = string.Join(',', indto.ParentTriggerValueList);
            indto.RelevanceValue = string.Join(',', indto.RelevanceValueList);

            indto.ExportResultStr = JsonConvert.SerializeObject(indto.ExportResult);
            indto.HighlightAnswer = JsonConvert.SerializeObject(indto.HighlightAnswerList);
            if (indto.Id != null)
            {
                var trialIdList = await _readingQuestionTrialRepository.Where(x => x.ReadingQuestionSystemId == indto.Id && x.IsJudgeQuestion && x.JudgeType != JudgeTypeEnum.None)
                    .Select(x => x.TrialId).ToListAsync();

                //if (trialIdList.Count>0)
                //{
                //    var trialNames = await _trialRepository.Where(x => trialIdList.Contains(x.Id)).Select(x => x.ExperimentName).ToListAsync();
                //    throw new BusinessValidationFailedException("当前问题在项目"+ string.Join(',', trialNames)  + "设置了裁判标准了,修改失败");
                //}
            }

            if (await _readingQuestionSystemRepository.AnyAsync(x => x.Id != indto.Id && x.ShowOrder == indto.ShowOrder && x.ReadingQuestionCriterionSystemId == indto.ReadingQuestionCriterionSystemId))
            {
                //---问题编号重复
                throw new BusinessValidationFailedException(_localizer["ReadingQuestion_IdDup"]);
            }
            var entity = await _readingQuestionSystemRepository.InsertOrUpdateAsync(indto, true);
            return ResponseOutput.Ok(entity.Id.ToString());
        }


        /// <summary>
        /// 删除系统问题
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpDelete("{id:guid}")]
        public async Task<IResponseOutput> DeleteReadingQuestionSystem(Guid id)
        {
            if (await _readingQuestionSystemRepository.AnyAsync(x => x.ParentId == id))
            {
                //---此问题存在子问题,请先删除子问题
                return ResponseOutput.NotOk(_localizer["ReadingQuestion_ChildrenExist"]);
            }

            if (await _readingQuestionSystemRepository.AnyAsync(x => x.GroupId == id))
            {
                //---此分组已被引用,请先删除被引用的问题
                return ResponseOutput.NotOk(_localizer["ReadingQuestion_GroupReferenced"]);
            }
            await _readingQuestionSystemRepository.DeleteFromQueryAsync(t => t.Id == id);
            var success = await _readingQuestionSystemRepository.SaveChangesAsync();
            return ResponseOutput.Result(success);
        }


        #endregion

        #region 系统标准表格问题

        /// <summary>
        /// 获取系统的表格问题
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<ReadingTableQuestionSystemView>> GetReadingTableQuestionSystemList(ReadingTableQuestionSystemQuery inDto)
        {
            var readingTableQuestionSystemQueryable = _readingTableQuestionSystemRepository
            .WhereIf(inDto.TableQuestionType != null, x => x.TableQuestionType == inDto.TableQuestionType!)
            .Where(x => x.ReadingQuestionId == inDto.ReadingQuestionId).ProjectTo<ReadingTableQuestionSystemView>(_mapper.ConfigurationProvider);

            var result = await readingTableQuestionSystemQueryable.OrderBy(x => x.ShowOrder).ToListAsync();
            return result;
        }

        /// <summary>
        /// 获取系统表格其他问题
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<CriterionOtherQuestionOutDto>> GetReadingTableOtherQuestionSystem(GetReadingTableOtherQuestionSystemInDto inDto)
        {
            var types = new List<string>()
            {
                "select","radio","class",
            };
            var questionList = await _readingTableQuestionSystemRepository.Where(x => x.ReadingQuestionId == inDto.ReadingQuestionId)
                   .Where(x => types.Contains(x.Type))
                .WhereIf(inDto.Id != null, x => x.Id != inDto.Id && x.ParentId != inDto.Id)

                .Select(x => new CriterionOtherQuestionOutDto()
                {
                    DictionaryCode = x.DictionaryCode,
                    QuestionGenre = x.TableQuestionType,
                    QuestionId = x.Id,
                    QuestionName = x.QuestionName,
                    TypeValue = x.TypeValue,
                }).ToListAsync();

            return questionList;
        }


        /// <summary>
        /// 新增修改系统表格问题
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public async Task<IResponseOutput> AddOrUpdateReadingTableQuestionSystem(ReadingTableQuestionSystemAddOrEdit indto)
        {
            indto.ParentTriggerValue = string.Join(',', indto.ParentTriggerValueList);
            indto.RelevanceValue = string.Join(',', indto.RelevanceValueList);
            indto.ExportResultStr = JsonConvert.SerializeObject(indto.ExportResult);
            var entity = await _readingTableQuestionSystemRepository.InsertOrUpdateAsync(indto, true);

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

        }

        /// <summary>
        /// 删除系统表格问题
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        [HttpDelete("{Id:guid}")]
        public async Task<IResponseOutput> DeleteReadingTableQuestionSystem(Guid Id)
        {
            if (await _readingTableQuestionSystemRepository.AnyAsync(x => x.ParentId == Id || x.RelevanceId == Id))
            {
                //---此问题存在子问题,请先删除子问题
                return ResponseOutput.NotOk(_localizer["ReadingQuestion_ChildrenExist"]);
            }

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

        #endregion

        #region 项目标准问题

        /// <summary>
        /// 新增修改项目问题（项目）
        /// </summary>
        /// <param name="indto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IResponseOutput> AddOrUpdateReadingQuestionTrial(AddOrUpdateReadingQuestionTrialInDto indto)
        {
            if (indto.Id != null)
            {
                if (await _readingQuestionTrialRepository.AnyAsync(x => x.Id == indto.Id && x.IsJudgeQuestion && x.JudgeType != JudgeTypeEnum.None))
                {
                    //---当前问题已经设置了裁判标准了,修改失败
                    throw new BusinessValidationFailedException(_localizer["ReadingQuestion_JudgmentSet"]);
                }
            }

            if (indto.ParentId == indto.RelevanceId && indto.ParentId != null && indto.ParentTriggerValue != indto.RelevanceValue)
            {
                //---显示依赖父问题和必填依赖的问题为同一个,但答案互斥,操作失败
                throw new BusinessValidationFailedException(_localizer["ReadingQuestion_ExcludeWithDependency"]);
            }


            if (await _readingQuestionTrialRepository.AnyAsync(x => x.Id != indto.Id && x.ShowOrder == indto.ShowOrder && x.TrialId == indto.TrialId && x.ReadingQuestionCriterionTrialId == indto.ReadingQuestionCriterionTrialId && x.ReadingCriterionPageId == indto.ReadingCriterionPageId))
            {
                //---问题编号重复
                throw new BusinessValidationFailedException(_localizer["ReadingQuestion_IdDup"]);
            }
            indto.ParentTriggerValue = string.Join(',', indto.ParentTriggerValueList);
            indto.ExportResultStr = JsonConvert.SerializeObject(indto.ExportResult);
            indto.RelevanceValue = string.Join(',', indto.RelevanceValueList);
            indto.HighlightAnswer = JsonConvert.SerializeObject(indto.HighlightAnswerList);

            if (indto.Id != null)
            {
                var relationList = await GetQuestionCalculateRelation(new GetQuestionCalculateRelationInDto()
                {
                    IsGetAll = true,
                    TrialReadingCriterionId = indto.ReadingQuestionCriterionTrialId,
                });

                var relation = relationList.FirstOrDefault(x => x.QuestionId == indto.Id);
                List<CalculateInfo> calculateInfoList = new List<CalculateInfo>();
                try
                {
                    var result = JsonConvert.DeserializeObject<List<CalculateInfo>>(indto.CalculateQuestions);
                    calculateInfoList = result == null ? new List<CalculateInfo>() : result;
                }
                catch (Exception)
                {


                }
                if (relation != null)
                {
                    relation.CalculateQuestionList = calculateInfoList;
                }

                this.VerifyCalculateRelation(relationList, indto.Id.Value, indto.Id.Value);
            }

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

        /// <summary>
        /// 获取项目问题（项目）
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<ReadingQuestionTrialView>> GetReadingQuestionTrialList(ReadingQuestionTrialViewInDto inDto)
        {
            var query = _readingQuestionTrialRepository.AsQueryable()
                .Where(x => x.ReadingQuestionCriterionTrialId == inDto.ReadingQuestionCriterionTrialId)
                 .WhereIf(!inDto.QuestionName.IsNullOrEmpty(), x => x.QuestionName.Contains(inDto.QuestionName) || x.QuestionEnName.Contains(x.QuestionEnName))
                  .WhereIf(!inDto.Type.IsNullOrEmpty(), x => x.Type.Contains(inDto.Type))
                   .Where(x => x.ReadingCriterionPageId == inDto.ReadingCriterionPageId)
                 .ProjectTo<ReadingQuestionTrialView>(_mapper.ConfigurationProvider).OrderBy(x => x.ShowOrder);
            return await query.ToListAsync();
        }

        /// <summary>
        ///  验证计算关系
        /// </summary>
        /// <param name="relationList"></param>
        /// <param name="QuestionId"></param>
        /// <param name="originalId"></param>
        /// <param name="count"></param>
        /// <exception cref="BusinessValidationFailedException"></exception>
        private void VerifyCalculateRelation(List<CalculateRelationDto> relationList, Guid QuestionId, Guid originalId, int count = 1)
        {
            // 防止有脏数据 循环验证 最多10000次
            if (count >= 10000)
            {
                //---计算依赖循环了！
                throw new BusinessValidationFailedException(_localizer["ReadingQuestion_CircularDependency"]);
            }

            var relation = relationList.Where(x => x.CalculateQuestionList.Any(y => y.QuestionId == QuestionId || y.TableQuestionId == QuestionId)).ToList();

            if (relation.Select(x => x.QuestionId).ToList().Contains(originalId))
            {
                //---计算依赖循环了！
                throw new BusinessValidationFailedException(_localizer["ReadingQuestion_CircularDependency"]);
            }

            else
            {

                relation.ForEach(x =>
                {

                    VerifyCalculateRelation(relationList, x.QuestionId, originalId, count++);
                });
            }

        }

        /// <summary>
        /// 获取问题计算关系
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<CalculateRelationDto>> GetQuestionCalculateRelation(GetQuestionCalculateRelationInDto inDto)
        {
            if (inDto.TrialReadingCriterionId != null)
            {
                return await _readingQuestionTrialRepository.Where(x => x.ReadingQuestionCriterionTrialId == inDto.TrialReadingCriterionId)
                    .WhereIf(!inDto.IsGetAll, x => x.DataSource == DataSources.Automatic && x.Type == "number")
                       .Select(x => new CalculateRelationDto()
                       {
                           QuestionId = x.Id,
                           QuestionName = x.QuestionName,
                           CustomCalculateMark = x.CustomCalculateMark,
                           CalculateQuestionList = x.CalculateQuestionList,
                           ValueType = x.ValueType,
                           Unit = x.Unit,
                           CustomUnit = x.CustomUnit,

                       }).ToListAsync();
            }
            else
            {
                return await _readingTableQuestionTrialRepository.Where(x => x.ReadingQuestionId == inDto.ReadingQuestionId)
                    .WhereIf(!inDto.IsGetAll, x => x.DataSource == DataSources.Automatic && x.Type == "number")
                      .Select(x => new CalculateRelationDto()
                      {
                          QuestionId = x.Id,
                          QuestionName = x.QuestionName,
                          CustomCalculateMark = x.CustomCalculateMark,
                          CalculateQuestionList = x.CalculateQuestionList,
                          ValueType = x.ValueType,
                          Unit = x.Unit,
                          CustomUnit = x.CustomUnit,

                      }).ToListAsync();
            }
        }


        /// <summary>
        /// 获取项目标准的其他问题(项目)
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<CriterionOtherQuestionOutDto>> GetTrialCriterionOtherQuestion(GetTrialCriterionOtherQuestionInDto inDto)
        {
            var types = new List<string>()
            {
                "select","radio","class",
            };
            var questionList = await _readingQuestionTrialRepository.Where(x => x.ReadingQuestionCriterionTrialId == inDto.ReadingQuestionCriterionTrialId)
                 .Where(x => types.Contains(x.Type)||(x.Type=="number"&&x.TypeValue!=string.Empty))
               
                .WhereIf(inDto.Id != null, x => x.Id != inDto.Id && x.ParentId != inDto.Id)
                 .Where(x => x.ReadingCriterionPageId == inDto.ReadingCriterionPageId)

                .Select(x => new CriterionOtherQuestionOutDto()
                {
                    QuestionId = x.Id,
                    DictionaryCode = x.DictionaryCode,
                    QuestionGenre = x.QuestionGenre,
                    QuestionName = x.QuestionName.LanguageName(x.QuestionEnName, _userInfo.IsEn_Us),
                    TypeValue = x.TypeValue,
                    GroupName = x.GroupName,
                }).ToListAsync();

            return questionList;
        }

        /// <summary>
        /// 删除项目问题（项目）
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpDelete("{id:guid}")]
        public async Task<IResponseOutput> DeleteReadingQuestionTrial(Guid id)
        {
            if (await _readingQuestionTrialRepository.AnyAsync(x => x.ParentId == id))
            {
                //---此问题存在子问题,请先删除子问题
                return ResponseOutput.NotOk(_localizer["ReadingQuestion_ChildrenExist"]);
            }

            if (await _readingQuestionTrialRepository.AnyAsync(x => x.GroupId == id))
            {
                //---此分组已被引用,请先删除被引用的问题
                return ResponseOutput.NotOk(_localizer["ReadingQuestion_GroupReferenced"]);
            }
            await _readingQuestionTrialRepository.DeleteFromQueryAsync(t => t.Id == id);
            var success = await _readingQuestionTrialRepository.SaveChangesAsync();
            return ResponseOutput.Result(success);
        }

        /// <summary>
        /// 获取项目问题分组
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<GetTrialGroupNameOutDto>> GetTrialGroupNameList(GetTrialGroupNameListInDto inDto)
        {
            var result = await _readingQuestionTrialRepository.Where(x => x.ReadingQuestionCriterionTrialId == inDto.CriterionId && x.Type == ReadingQestionType.Group)
                .Where(x => x.ReadingCriterionPageId == inDto.ReadingCriterionPageId).OrderBy(t => t.ShowOrder)
                  .Select(x => new GetTrialGroupNameOutDto
                  {
                      GroupId = x.Id,
                      GroupName = x.GroupName,
                  }).ToListAsync();

            return result;

        }

        #endregion

        #region 项目标准表格问题


        /// <summary>
        /// 获取项目的表格问题
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<(List<ReadingTableQuestionTrialView>, bool)> GetReadingTableQuestionTrialList(ReadingTableQuestionSystemQuery inDto)
        {

            var readingTableQuestionSystemQueryable = _readingTableQuestionTrialRepository
            .WhereIf(inDto.TableQuestionType != null, x => x.TableQuestionType == inDto.TableQuestionType)
            .Where(x => x.ReadingQuestionId == inDto.ReadingQuestionId).ProjectTo<ReadingTableQuestionTrialView>(_mapper.ConfigurationProvider);

            var result = await readingTableQuestionSystemQueryable.OrderBy(x => x.ShowOrder).ToListAsync();
            return (result, true);
        }

        /// <summary>
        /// 获取项目表格其他问题
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<CriterionOtherQuestionOutDto>> GetReadingTableOtherQuestionTrial(GetReadingTableOtherQuestionSystemInDto inDto)
        {

            var types = new List<string>()
            {
                "select","radio","class"
            };
            var questionList = await _readingTableQuestionTrialRepository.Where(x => x.ReadingQuestionId == inDto.ReadingQuestionId)
                   .Where(x => types.Contains(x.Type) || (x.Type == "number" && x.TypeValue != string.Empty))
                .WhereIf(inDto.Id != null, x => x.Id != inDto.Id && x.ParentId != inDto.Id)

                .Select(x => new CriterionOtherQuestionOutDto()
                {
                    QuestionId = x.Id,
                    QuestionGenre = x.TableQuestionType,
                    DictionaryCode = x.DictionaryCode,
                    QuestionName = x.QuestionName.LanguageName(x.QuestionEnName, _userInfo.IsEn_Us),
                    TypeValue = x.TypeValue,
                }).ToListAsync();

            return questionList;
        }




        /// <summary>
        /// 新增修改想想项目表格问题
        /// </summary>
        /// <param name="indto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IResponseOutput> AddOrUpdateReadingTableQuestionTrial(ReadingTableQuestionTrialAddOrEdit indto)
        {

            var list = await _readingTableQuestionTrialRepository.Where(x => x.Id != indto.Id && x.ShowOrder == indto.ShowOrder && x.ReadingQuestionId == indto.ReadingQuestionId).ToListAsync();
            if (await _readingTableQuestionTrialRepository.AnyAsync(x => x.Id != indto.Id && x.ShowOrder == indto.ShowOrder && x.ReadingQuestionId == indto.ReadingQuestionId))
            {
                //---问题编号重复
                throw new BusinessValidationFailedException(_localizer["ReadingQuestion_IdDup"]);
            }

            indto.ParentTriggerValue = string.Join(',', indto.ParentTriggerValueList);
            indto.RelevanceValue = string.Join(',', indto.RelevanceValueList);

            indto.ExportResultStr = JsonConvert.SerializeObject(indto.ExportResult);
            if (indto.Id != null)
            {
                var relationList = await GetQuestionCalculateRelation(new GetQuestionCalculateRelationInDto()
                {
                    IsGetAll = true,
                    ReadingQuestionId = indto.ReadingQuestionId,
                });

                var relation = relationList.FirstOrDefault(x => x.QuestionId == indto.Id);
                List<CalculateInfo> calculateInfoList = new List<CalculateInfo>();
                try
                {
                    var result = JsonConvert.DeserializeObject<List<CalculateInfo>>(indto.CalculateQuestions);
                    calculateInfoList = result == null ? new List<CalculateInfo>() : result;
                }
                catch (Exception)
                {


                }
                if (relation != null)
                {
                    relation.CalculateQuestionList = calculateInfoList;
                }

                this.VerifyCalculateRelation(relationList, indto.Id.Value, indto.Id.Value);
            }


            var entity = await _readingTableQuestionTrialRepository.InsertOrUpdateAsync(indto, true);

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

        }





        /// <summary>
        /// 删除项目表格问题
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        [HttpDelete("{Id:guid}")]
        public async Task<IResponseOutput> DeleteReadingTableQuestionTrial(Guid Id)
        {
            if (await _readingTableQuestionTrialRepository.AnyAsync(x => x.ParentId == Id || x.RelevanceId == Id))
            {
                //---此问题存在子问题,请先删除子问题
                return ResponseOutput.NotOk(_localizer["ReadingQuestion_ChildrenExist"]);
            }

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


        #endregion






        /// <summary>
        /// 复制一个系统标准到另一系统标准
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        /// 
        [HttpPost]
        public async Task<IResponseOutput> CopySystemCriterionData(CopySystemCriterionDataInDto inDto)
        {
            if (inDto.IsCopyQuestion)
            {
                var newSystemQuestionList = await _readingQuestionSystemRepository.Where(x => x.ReadingQuestionCriterionSystemId == inDto.SourceSystemCriterionId)
            .ProjectTo<ReadingQuestionSystemData>(_mapper.ConfigurationProvider).ToListAsync();
                newSystemQuestionList.ForEach(x =>
                {
                    x.Id = NewId.NextGuid();
                    x.ReadingQuestionCriterionSystemId = inDto.NewSystemCriterionId;
                });
                var copyNewQuestionList = newSystemQuestionList.Clone();
                var needAddDatas = new List<ReadingQuestionSystemData>();
                foreach (var x in newSystemQuestionList)
                {
                    var question = x.Clone();
                    if (question.ParentId != null)
                    {
                        question.ParentId = copyNewQuestionList.Where(y => x.ParentId == y.OriginalId).Select(y => y.Id).FirstOrDefault();
                    }
                    if (question.RelevanceId != null)
                    {
                        question.RelevanceId = copyNewQuestionList.Where(y => x.RelevanceId == y.OriginalId).Select(y => y.Id).FirstOrDefault();
                    }
                    needAddDatas.Add(question);
                };

                await _readingQuestionSystemRepository.BatchDeleteNoTrackingAsync(x => x.ReadingQuestionCriterionSystemId == inDto.NewSystemCriterionId);
                await _readingQuestionSystemRepository.AddRangeAsync(needAddDatas);

                #region 表格问题
                var newSystemTableQuestionList = await _readingTableQuestionSystemRepository.Where(x => x.SystemCriterionId == inDto.SourceSystemCriterionId)
               .ProjectTo<ReadingTableQuestionSystemData>(_mapper.ConfigurationProvider).ToListAsync();
                var copeNewSystemTableQuestionList = newSystemTableQuestionList.Clone();
                var needAddTableDatas = new List<ReadingTableQuestionSystemData>();
                foreach (var x in newSystemTableQuestionList)
                {
                    var tableQuestion = x.Clone();
                    tableQuestion.SystemCriterionId = inDto.NewSystemCriterionId;
                    tableQuestion.Id = NewId.NextGuid();
                    if (tableQuestion.ParentId != null)
                    {
                        tableQuestion.ParentId = copeNewSystemTableQuestionList.Where(y => x.ParentId == y.OriginalId).Select(y => y.Id).FirstOrDefault();
                    }
                    if (tableQuestion.RelevanceId != null)
                    {
                        tableQuestion.RelevanceId = copeNewSystemTableQuestionList.Where(y => x.RelevanceId == y.OriginalId).Select(y => y.Id).FirstOrDefault();
                    }
                    if (tableQuestion.DependParentId != null)
                    {
                        tableQuestion.DependParentId = copeNewSystemTableQuestionList.Where(y => x.DependParentId == y.OriginalId).Select(y => y.Id).FirstOrDefault();
                    }
                    needAddTableDatas.Add(tableQuestion);
                }
                await _readingTableQuestionSystemRepository.BatchDeleteNoTrackingAsync(x => x.SystemCriterionId == inDto.NewSystemCriterionId);
                await _readingTableQuestionSystemRepository.AddRangeAsync(needAddTableDatas);
                #endregion

            }
            else
            {
                var organData = await _organInfoRepository.Where(x => x.SystemCriterionId == inDto.SourceSystemCriterionId).ToListAsync();

                organData.ForEach(x =>
                {
                    x.Id = NewId.NextGuid();
                    x.SystemCriterionId = inDto.NewSystemCriterionId;
                });
                await _organInfoRepository.BatchDeleteNoTrackingAsync(x => x.SystemCriterionId == inDto.NewSystemCriterionId);
                await _organInfoRepository.AddRangeAsync(organData);

            }




            await _readingTableQuestionSystemRepository.SaveChangesAsync();
            return ResponseOutput.Ok();
        }

        /// <summary>
        /// 同步系统标准
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task SynchronizeSystemCriterionQuestion(SynchronizeSystemCriterionInDto inDto)
        {
            // 先找到项目系统问题Id和项目问题Id的对应关系
            var questionRelation = _readingQuestionSystemRepository.Where(x => x.ReadingQuestionCriterionSystemId == inDto.FromSystemCriterionId).ToDictionary(
                x => x.Id,
                x => NewId.NextGuid()
                );


            var newQuestionList = await _readingQuestionSystemRepository.Where(x => x.ReadingQuestionCriterionSystemId == inDto.FromSystemCriterionId).ProjectTo<AddOrUpdateReadingQuestionSystemInDto>(_mapper.ConfigurationProvider).ToListAsync();
            var copyNewQuestionList = newQuestionList.Clone();

            var needAddDatas = new List<ReadingQuestionSystem>();

            foreach (var x in newQuestionList)
            {
                var question = x.Clone();
                question.ReadingQuestionCriterionSystemId = inDto.ToSystemCriterionId;
                question.Id = questionRelation[question.Id!.Value];
                if (question.ParentId != null)
                {
                    question.ParentId = questionRelation[question.ParentId ?? default(Guid)];
                }
                if (question.GroupId != null)
                {
                    question.GroupId = questionRelation[question.GroupId ?? default(Guid)];
                }
                if (question.RelevanceId != null)
                {
                    question.RelevanceId = questionRelation[question.RelevanceId ?? default(Guid)];
                }
                needAddDatas.Add(_mapper.Map<ReadingQuestionSystem>(question));
            };

            await _readingQuestionSystemRepository.BatchDeleteNoTrackingAsync(x => x.ReadingQuestionCriterionSystemId == inDto.ToSystemCriterionId);
            await _readingQuestionSystemRepository.AddRangeAsync(needAddDatas);


            var tableQuestionRelation = _readingTableQuestionSystemRepository.Where(x => x.SystemCriterionId == inDto.FromSystemCriterionId).ToDictionary(
                    x => x.Id,
                    x => NewId.NextGuid()
                    );


            var newtableQuestion = await _readingTableQuestionSystemRepository.Where(x => x.SystemCriterionId == inDto.FromSystemCriterionId).ToListAsync();


            var copyNewTableQuestionList = newtableQuestion.Clone();

            var needAddTableDatas = new List<ReadingTableQuestionSystem>();
            foreach (var x in newtableQuestion)
            {
                var tableQuestion = x.Clone();


                tableQuestion.SystemCriterionId = inDto.ToSystemCriterionId;
                tableQuestion.Id = tableQuestionRelation[tableQuestion.Id];
                tableQuestion.ReadingQuestionId = questionRelation[tableQuestion.ReadingQuestionId];
                if (tableQuestion.ParentId != null)
                {
                    tableQuestion.ParentId = tableQuestionRelation[tableQuestion.ParentId.Value];
                }
                if (tableQuestion.RelevanceId != null)
                {
                    tableQuestion.RelevanceId = tableQuestionRelation[tableQuestion.RelevanceId.Value]; ;
                }

                if (tableQuestion.DependParentId != null)
                {
                    tableQuestion.DependParentId = tableQuestionRelation[tableQuestion.DependParentId.Value]; ;
                }

                needAddTableDatas.Add(tableQuestion);
            }


            await _readingTableQuestionSystemRepository.BatchDeleteNoTrackingAsync(x => x.SystemCriterionId == inDto.ToSystemCriterionId);
            await _readingTableQuestionSystemRepository.AddRangeAsync(needAddTableDatas);
            await _readingTableQuestionSystemRepository.SaveChangesAsync();

        }

        /// <summary>
        /// 同步标准到项目新（2022-08-10）
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task SynchronizeCriterion(SynchronizeCriterionInDto inDto)
        {
            var trialCriterion = await _readingQuestionCriterionTrialRepository.Where(x => x.Id == inDto.TrialReadingCriterionId).AsNoTracking().FirstOrDefaultAsync();

            if (trialCriterion != null)
            {
                if (trialCriterion.ReadingQuestionCriterionSystemId != null)
                {
                    // 先找到项目系统问题Id和项目问题Id的对应关系
                    var questionRelation = _readingQuestionTrialRepository.Where(x => x.ReadingQuestionCriterionTrialId == trialCriterion.Id).ToDictionary(
                        x => x.ReadingQuestionSystemId ?? default(Guid),
                        x => x.Id
                        );

                    // 将系统里面的问题转为项目问题
                    var newTrialQuestionList = await _readingQuestionSystemRepository.Where(x => x.ReadingQuestionCriterionSystemId == trialCriterion.ReadingQuestionCriterionSystemId)
                      .ProjectTo<ReadingQuestionTrial>(_mapper.ConfigurationProvider).ToListAsync();
                    newTrialQuestionList.ForEach(x =>
                    {
                        if (questionRelation.ContainsKey(x.Id))
                        {
                            x.Id = questionRelation[x.Id];
                        }
                        else
                        {
                            var newid = NewId.NextGuid();
                            questionRelation.Add(x.Id, newid);
                            x.Id = newid;
                        }

                        x.ReadingQuestionCriterionTrialId = trialCriterion.Id;
                        x.TrialId = trialCriterion.TrialId;
                    });
                    var copyNewQuestionList = newTrialQuestionList.Clone();
                    // var trialQuestionList = await _readingQuestionTrialRepository.Where(x => x.ReadingQuestionCriterionTrialId == trialCriterion.Id).ToListAsync();
                    var needAddDatas = new List<ReadingQuestionTrial>();

                    foreach (var x in newTrialQuestionList)
                    {
                        var question = x.Clone();
                        if (question.ParentId != null)
                        {
                            question.ParentId = questionRelation[question.ParentId ?? default(Guid)];
                        }
                        if (question.GroupId != null)
                        {
                            question.GroupId = questionRelation[question.GroupId ?? default(Guid)];
                        }
                        if (question.RelevanceId != null)
                        {
                            question.RelevanceId = questionRelation[question.RelevanceId ?? default(Guid)];
                        }




                        needAddDatas.Add(question);
                    };

                    await _readingQuestionTrialRepository.BatchDeleteNoTrackingAsync(x => x.ReadingQuestionCriterionTrialId == trialCriterion.Id && !x.IsAdditional);
                    await _readingQuestionTrialRepository.AddRangeAsync(needAddDatas);
                    var systemCriterion = await _readingQuestionCriterionSystemRepository.Where(x => x.Id == trialCriterion.ReadingQuestionCriterionSystemId).FirstNotNullAsync();
                    await _readingQuestionCriterionTrialRepository.BatchUpdateNoTrackingAsync(x => x.Id == trialCriterion.Id, x => new ReadingQuestionCriterionTrial()
                    {
                        SynchronizeTime = DateTime.Now,
                        IsMustGlobalReading = systemCriterion.IsMustGlobalReading,
                        IseCRFShowInDicomReading = systemCriterion.IseCRFShowInDicomReading,
                        IsGlobalReading = systemCriterion.IsMustGlobalReading ? true : trialCriterion.IsGlobalReading,
                        IsReadingPeriod = systemCriterion.IsMustGlobalReading ? true : trialCriterion.IsReadingPeriod,
                    });


                    #region 表格问题

                    // 先找到项目系统问题Id和项目问题Id的对应关系

                    var questionIds = needAddDatas.Select(x => x.Id).ToList();


                    var tableQuestionRelation = _readingTableQuestionTrialRepository.Where(x => x.TrialCriterionId == trialCriterion.Id && x.SystemTableQuestionId != null).ToDictionary(
                        x => x.SystemTableQuestionId ?? default(Guid),
                        x => x.Id
                        );


                    var newTrialTableQuestionList = await _readingTableQuestionSystemRepository.Where(x => x.SystemCriterionId == trialCriterion.ReadingQuestionCriterionSystemId)
                   .ProjectTo<ReadingTrialTableQuestionData>(_mapper.ConfigurationProvider).ToListAsync();


                    newTrialTableQuestionList.ForEach(x =>
                    {
                        if (tableQuestionRelation.ContainsKey(x.Id))
                        {
                            x.Id = tableQuestionRelation[x.Id];
                        }
                        else
                        {
                            var newid = NewId.NextGuid();
                            tableQuestionRelation.Add(x.Id, newid);
                            x.Id = newid;
                        }
                    });

                    var copyNewTrialTableQuestionList = newTrialTableQuestionList.Clone();

                    var needAddTableDatas = new List<ReadingTrialTableQuestionData>();
                    foreach (var x in newTrialTableQuestionList)
                    {
                        var tableQuestion = x.Clone();
                        tableQuestion.TrialId = trialCriterion.TrialId;
                        tableQuestion.TrialCriterionId = trialCriterion.Id;

                        tableQuestion.ReadingQuestionId = copyNewQuestionList.Where(y => y.ReadingQuestionSystemId == x.ReadingQuestionId).Select(y => y.Id).FirstOrDefault();
                        if (tableQuestion.ParentId != null)
                        {
                            tableQuestion.ParentId = copyNewTrialTableQuestionList.Where(y => x.ParentId == y.OriginalId).Select(y => y.Id).FirstOrDefault();
                        }
                        if (tableQuestion.RelevanceId != null)
                        {
                            tableQuestion.RelevanceId = copyNewTrialTableQuestionList.Where(y => x.RelevanceId == y.OriginalId).Select(y => y.Id).FirstOrDefault();
                        }

                        if (tableQuestion.DependParentId != null)
                        {
                            tableQuestion.DependParentId = copyNewTrialTableQuestionList.Where(y => x.DependParentId == y.OriginalId).Select(y => y.Id).FirstOrDefault();
                        }

                        needAddTableDatas.Add(tableQuestion);
                    }


                    await _readingTableQuestionTrialRepository.BatchDeleteNoTrackingAsync(x => x.TrialCriterionId == trialCriterion.Id);
                    await _readingTableQuestionTrialRepository.AddRangeAsync(_mapper.Map<List<ReadingTableQuestionTrial>>(needAddTableDatas));
                    #endregion

                }
            }

        }


        ///// <summary>
        ///// 更改项目标准（老）
        ///// </summary>
        ///// <param name="systemCriterionId"></param>
        ///// <returns></returns>
        //private async Task UpdateTrialCriterion(Guid systemCriterionId)
        //{
        //    await _readingQuestionCriterionTrialRepository.BatchUpdateNoTrackingAsync(x => x.ReadingQuestionCriterionSystemId == systemCriterionId, x => new ReadingQuestionCriterionTrial()
        //    {
        //        IsCompleteConfig = true,
        //    });
        //    var systemCriterionQuestionList = await _readingQuestionSystemRepository.Where(x => x.ReadingQuestionCriterionSystemId == systemCriterionId).ToListAsync();
        //    var trialCriterionList = await _readingQuestionCriterionTrialRepository.Where(x => x.ReadingQuestionCriterionSystemId == systemCriterionId).Select(x => new
        //    {
        //        x.Id,
        //        x.TrialId,
        //    }).ToListAsync();
        //    var trialCriterionIdList = trialCriterionList.Select(x => x.Id).ToList();
        //    List<ReadingQuestionTrial> needAddQuestionList = new List<ReadingQuestionTrial>();
        //    foreach (var item in trialCriterionList)
        //    {
        //        await _readingQuestionTrialRepository.BatchDeleteNoTrackingAsync(x => trialCriterionIdList.Contains(x.ReadingQuestionCriterionTrialId));
        //        List<ReadingQuestionTrial> trialQuestionList = new List<ReadingQuestionTrial>();
        //        SetChildParentQuestion(item.Id, item.TrialId, systemCriterionQuestionList, trialQuestionList);
        //        needAddQuestionList.AddRange(trialQuestionList);
        //    }
        //    await _readingQuestionTrialRepository.AddRangeAsync(needAddQuestionList);
        //}


        ///// <summary>
        ///// 更改项目标准（新）
        ///// </summary>
        ///// <param name="systemCriterionId"></param>
        ///// <returns></returns>
        //private async Task SynchronizeSystemCriterion(Guid systemCriterionId)
        //{
        //    var systemCriterion = await _readingQuestionCriterionSystemRepository.FirstOrDefaultAsync(x => x.Id == systemCriterionId);

        //    var trialCriterionList = await _readingQuestionCriterionTrialRepository.Where(x => x.ReadingQuestionCriterionSystemId == systemCriterionId).Select(x => new
        //    {
        //        x.Id,
        //        x.TrialId,
        //    }).ToListAsync();

        //    var trialCriterionIds = trialCriterionList.Select(x => x.Id).ToList();
        //    var systemQuestionList = await _readingQuestionSystemRepository.Where(x => x.ReadingQuestionCriterionSystemId == systemCriterionId).ToListAsync();
        //    var trialQuestions = await _readingQuestionTrialRepository.Where(x => trialCriterionIds.Contains(x.ReadingQuestionCriterionTrialId)).Select(x => new TrialQuestion
        //    {
        //        AnswerCombination = x.AnswerCombination,
        //        AnswerGroup = x.AnswerGroup,
        //        Id = x.Id,
        //        JudgeType = x.JudgeType,
        //        ReadingCriterionPageId = x.ReadingCriterionPageId,
        //        RelevanceId = x.RelevanceId,
        //        RelevanceValue = x.RelevanceValue,
        //        ImageCount = x.ImageCount,
        //        ParentId = x.ParentId,
        //        ReadingQuestionCriterionTrialId = x.ReadingQuestionCriterionTrialId,
        //        ReadingQuestionSystemId = x.ReadingQuestionSystemId,
        //        SystemParentId = x.SystemParentId
        //    }).ToListAsync();

        //    List<ReadingQuestionTrial> trialQuestionList = new List<ReadingQuestionTrial>();
        //    foreach (var item in trialCriterionList)
        //    {

        //        var thisTrialQuestions = trialQuestions.Where(x => x.ReadingQuestionCriterionTrialId == item.Id).ToList();

        //        var query = systemQuestionList.GroupJoin(thisTrialQuestions, a => a.Id, b => b.ReadingQuestionSystemId, (a, b) => new
        //        {
        //            a,
        //            trialQuestion = b
        //        }).SelectMany(a => a.trialQuestion, (m, n) => new ReadingQuestionTrial
        //        {
        //            Id = n.Id,

        //        });
        //        var needAddQuestionList = systemQuestionList.GroupJoin(thisTrialQuestions, a => a.Id, b => b.ReadingQuestionSystemId, (x, y) => new { system = x, trial = y })
        //          .SelectMany(
        //          a => a.trial.DefaultIfEmpty(),
        //          (c, d) => new ReadingQuestionTrial
        //          {
        //              Id = (c.trial.FirstOrDefault()?.Id) ?? NewId.NextGuid(),
        //              ShowOrder = c.system.ShowOrder,
        //              SystemParentId = c.system.ParentId,
        //              ReadingQuestionSystemId = c.system.Id,
        //              AnswerCombination = (c.trial.FirstOrDefault()?.AnswerCombination) ?? string.Empty,
        //              AnswerGroup = (c.trial.FirstOrDefault()?.AnswerGroup) ?? string.Empty,
        //              GroupName = c.system.GroupName,
        //              IsEnable = c.system.IsEnable,

        //              ShowQuestion = c.system.ShowQuestion,
        //              IsJudgeQuestion = c.system.IsJudgeQuestion,
        //              IsRequired = c.system.IsRequired,
        //              JudgeType = (c.trial.FirstOrDefault()?.JudgeType) ?? JudgeTypeEnum.None,
        //              ParentId = c.trial.FirstOrDefault()?.ParentId,
        //              ParentTriggerValue = c.system.ParentTriggerValue,
        //              QuestionName = c.system.QuestionName,
        //              ReadingCriterionPageId = c.trial.FirstOrDefault()?.ReadingCriterionPageId,
        //              RelevanceId = c.trial.FirstOrDefault()?.RelevanceId,
        //              ImageCount = c.trial.FirstOrDefault()?.ImageCount ?? 0,
        //              RelevanceValue = c.trial.FirstOrDefault()?.RelevanceValue,
        //              ReadingQuestionCriterionTrialId = item.Id,
        //              Remark = c.system.Remark,
        //              TrialId = item.TrialId,
        //              Type = c.system.Type,

        //              TypeValue = c.system.TypeValue,
        //          }).ToList();
        //        var copydata = needAddQuestionList.Clone();
        //        needAddQuestionList.ForEach(x =>
        //        {
        //            if (x.SystemParentId == null)
        //            {
        //                x.ParentId = null;
        //            }
        //            else
        //            {
        //                x.ParentId = copydata.FirstOrDefault(y => y.ReadingQuestionSystemId == x.SystemParentId).Id;
        //            }
        //        });

        //        trialQuestionList.AddRange(needAddQuestionList);
        //    }
        //    await _readingQuestionTrialRepository.BatchDeleteNoTrackingAsync(x => trialCriterionIds.Contains(x.ReadingQuestionCriterionTrialId));
        //    await _readingQuestionCriterionTrialRepository.BatchUpdateNoTrackingAsync(x => trialCriterionIds.Contains(x.Id), x => new ReadingQuestionCriterionTrial()
        //    {
        //        IsEnable = systemCriterion.IsEnable,
        //        CriterionName = systemCriterion.CriterionName,
        //        ShowOrder = systemCriterion.ShowOrder,
        //        IsCompleteConfig = systemCriterion.IsCompleteConfig,

        //    });

        //    await _readingQuestionTrialRepository.AddRangeAsync(trialQuestionList);


        //    //
        //    await _readingQuestionTrialRepository.SaveChangesAsync();
        //}


        /// <summary>
        /// 验证是否要同步标准
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<NeedSynchronize> VerifyeCriterionNeedSynchronize(VerifyeCriterionNeedSynchronizeInDto inDto)
        {
            var trialCriterion = await _readingQuestionCriterionTrialRepository.Where(x => x.Id == inDto.TrialReadingCriterionId).FirstOrDefaultAsync();
            if (trialCriterion == null)
            {
                return NeedSynchronize.NotNeed;
            }
            if (trialCriterion.ReadingQuestionCriterionSystemId != null)
            {
                var systemCriterion = await _readingQuestionCriterionSystemRepository.Where(x => x.Id == trialCriterion.ReadingQuestionCriterionSystemId).FirstNotNullAsync();
                if (systemCriterion.ConfirmTime > trialCriterion.SynchronizeTime)
                {

                    var systemQuestionList = await _readingQuestionSystemRepository.Where(x => x.IsJudgeQuestion && x.ReadingQuestionCriterionSystemId == trialCriterion.ReadingQuestionCriterionSystemId).ToListAsync();
                    var trialQuestionList = await _readingQuestionTrialRepository.Where(x => x.IsJudgeQuestion && x.ReadingQuestionCriterionTrialId == trialCriterion.Id).ToListAsync();
                    if (systemQuestionList.Count != trialQuestionList.Count)
                    {
                        return NeedSynchronize.JudgeNotEqual;
                    }


                    foreach (var item in trialQuestionList)
                    {
                        var systemQuestion = systemQuestionList.Where(x => x.Id == (item.ReadingQuestionSystemId ?? default(Guid))).FirstOrDefault();
                        if (systemQuestion == null)
                        {
                            return NeedSynchronize.JudgeNotEqual;
                        }


                        if (systemQuestion.TypeValue != item.TypeValue)
                        {
                            return NeedSynchronize.JudgeNotEqual;
                        }
                    }


                    return NeedSynchronize.Need;

                }
                else
                {
                    return NeedSynchronize.NotNeed;
                }

            }
            else
            {
                return NeedSynchronize.NotNeed;
            }
        }


        /// <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();
        }

        ///// <summary>
        ///// 设置父子关系
        ///// </summary>
        ///// <param name="ReadingQuestionCriterionTrialId">项目标准ID</param>
        ///// <param name="trialId">项目Id</param>
        ///// <param name="systemQuesitonList">系统问题</param>
        ///// <param name="needQuestionList">需要添加list</param>
        //private void SetChildParentQuestion(Guid ReadingQuestionCriterionTrialId, Guid trialId, List<ReadingQuestionSystem> systemQuesitonList, List<ReadingQuestionTrial> needQuestionList)
        //{
        //    var parentIdIsNullList = systemQuesitonList.Where(x => x.ParentId == null).ToList();
        //    parentIdIsNullList.ForEach(x =>
        //    {
        //        var quesiton = x.Clone();
        //        var oldId = quesiton.Id;
        //        var newId = NewId.NextGuid();
        //        needQuestionList.Add(new ReadingQuestionTrial()
        //        {
        //            Id = newId,
        //            ShowOrder = quesiton.ShowOrder,
        //            IsEnable = quesiton.IsEnable,
        //            IsRequired = quesiton.IsRequired,
        //            ParentTriggerValue = quesiton.ParentTriggerValue,
        //            QuestionName = quesiton.QuestionName,
        //            ReadingQuestionCriterionTrialId = ReadingQuestionCriterionTrialId,
        //            ReadingQuestionSystemId = quesiton.Id,
        //            SystemParentId = quesiton.ParentId,
        //            TrialId = trialId,
        //            AnswerGroup = string.Empty,
        //            Type = quesiton.Type,
        //            GroupName = quesiton.GroupName,
        //            IsJudgeQuestion = quesiton.IsJudgeQuestion,
        //            Remark = quesiton.Remark,
        //            TypeValue = quesiton.TypeValue,
        //        });

        //        CreateQuestionRelation(ReadingQuestionCriterionTrialId, trialId, oldId, newId, systemQuesitonList, needQuestionList);
        //    });
        //}

        ///// <summary>
        ///// 递归处理父子关系
        ///// </summary>
        ///// <param name="ReadingQuestionCriterionTrialId"></param>
        ///// <param name="trialId"></param>
        ///// <param name="oldParentId"></param>
        ///// <param name="newParentId"></param>
        ///// <param name="systemQuesitonList"></param>
        ///// <param name="needQuestionList"></param>
        //private void CreateQuestionRelation(Guid ReadingQuestionCriterionTrialId, Guid trialId, Guid oldParentId, Guid newParentId, List<ReadingQuestionSystem> systemQuesitonList, List<ReadingQuestionTrial> needQuestionList)
        //{
        //    var childList = systemQuesitonList.Where(x => x.ParentId == oldParentId).ToList();
        //    childList.ForEach(x =>
        //    {
        //        var quesiton = x.Clone();
        //        var oldId = quesiton.Id;
        //        var newId = NewId.NextGuid();
        //        needQuestionList.Add(new ReadingQuestionTrial()
        //        {
        //            Id = newId,
        //            ShowOrder = quesiton.ShowOrder,
        //            IsEnable = quesiton.IsEnable,
        //            IsRequired = quesiton.IsRequired,
        //            ParentId = newParentId,
        //            SystemParentId = quesiton.ParentId,
        //            ReadingQuestionSystemId = x.Id,
        //            AnswerGroup = string.Empty,
        //            ParentTriggerValue = quesiton.ParentTriggerValue,
        //            QuestionName = quesiton.QuestionName,
        //            ReadingQuestionCriterionTrialId = ReadingQuestionCriterionTrialId,
        //            TrialId = trialId,
        //            GroupName = quesiton.GroupName,
        //            Type = quesiton.Type,
        //            IsJudgeQuestion = quesiton.IsJudgeQuestion,
        //            Remark = quesiton.Remark,
        //            TypeValue = quesiton.TypeValue,
        //        });

        //        CreateQuestionRelation(ReadingQuestionCriterionTrialId, trialId, oldId, newId, systemQuesitonList, needQuestionList);
        //    });

        //}


        #region 废弃

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


        ///// <summary>
        ///// 设置系统标准被禁用
        ///// </summary>
        ///// <returns></returns>
        //[NonDynamicMethod]
        //public async Task<IResponseOutput> SetSystemCriterionDisable(Guid dictionaryId, Guid? parentId)
        //{
        //    // 判断是否是阅片
        //    if (await _dictionaryRepository.AnyAsync(x => x.Id == parentId && x.Code == "ReadingStandard"))
        //    {
        //        // 判断当前阅片是否在项目里面存在
        //        var systemCriterion = await _readingQuestionCriterionSystemRepository.FirstOrDefaultAsync(x => x.CriterionId == dictionaryId);
        //        if (systemCriterion != null)
        //        {
        //            var trialCriterionIds = await _readingQuestionCriterionTrialRepository.Where(x => x.ReadingQuestionCriterionSystemId == systemCriterion.Id).Select(x=>x.ReadingQuestionCriterionSystemId).ToListAsync();
        //            await _readingQuestionCriterionTrialRepository.BatchDeleteNoTrackingAsync(x => x.ReadingQuestionCriterionSystemId == systemCriterion.Id);
        //            await _readingQuestionTrialRepository.BatchDeleteNoTrackingAsync(x => trialCriterionIds.Contains(x.ReadingQuestionCriterionTrialId));
        //            return ResponseOutput.Ok();
        //        }
        //    }

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

        ///// <summary>
        ///// 添加系统问题标准
        ///// </summary>
        ///// <returns></returns>
        //[NonDynamicMethod]
        //private async Task AddSystemQuestionCriterion()
        //{
        //    var useSystemQuestionCriterionIds = _readingQuestionCriterionSystemRepository.Select(x => x.CriterionId);
        //    var dictionaryParentId =await _dictionaryRepository.Where(x => x.Code == "ReadingStandard").Select(x => x.Id).FirstOrDefaultAsync();
        //    var criterionList = await _dictionaryRepository.Where(x => x.ParentId == dictionaryParentId && !useSystemQuestionCriterionIds.Contains(x.Id))
        //        .Select(x => new CriterionList()
        //        {
        //            Id = x.Id,
        //            Value = x.Value,
        //            ShowOrder=x.ShowOrder,
        //        }).ToListAsync();
        //    List<ReadingQuestionCriterionSystem> needAddCriterionList = new List<ReadingQuestionCriterionSystem>();
        //    criterionList.ForEach(x =>
        //    {
        //        needAddCriterionList.Add(new ReadingQuestionCriterionSystem()
        //        {
        //            CriterionId = x.Id,
        //            ShowOrder=x.ShowOrder,
        //            CriterionName = x.Value,
        //            IsEnable = false,
        //        });
        //    });
        //   await  _readingQuestionCriterionSystemRepository.AddRangeAsync(needAddCriterionList);
        //   await _readingQuestionCriterionSystemRepository.SaveChangesAsync();
        //}


        ///// <summary>
        ///// 获取预览问题信息
        ///// </summary>
        ///// <param name="inDto"></param>
        ///// <returns></returns>
        //[HttpPost]
        //public async Task<List<GetTrialReadingQuestionOutDto>> GetPreviewTheQuestion(GetPreviewTheQuestionInDto inDto)
        //{
        //    var trialQuestionQuery = from trialQuestion in _readingQuestionTrialRepository.Where(x=>x.ReadingQuestionCriterionTrialId== inDto.Id)
        //                    select new GetTrialReadingQuestionOutDto()
        //                    {
        //                        ReadingQuestionTrialId = trialQuestion.Id,
        //                        ReadingQuestionCriterionTrialId = trialQuestion.ReadingQuestionCriterionTrialId,
        //                        TrialId = trialQuestion.TrialId,
        //                        Type = trialQuestion.Type,
        //                        ParentTriggerValue = trialQuestion.ParentTriggerValue,
        //                        GroupName = trialQuestion.GroupName,
        //                        QuestionName = trialQuestion.QuestionName,
        //                        IsRequired = trialQuestion.IsRequired,
        //                        ShowOrder = trialQuestion.ShowOrder,
        //                        ParentId = trialQuestion.ParentId,
        //                        TypeValue = trialQuestion.TypeValue,
        //                        Answer = string.Empty
        //                    };
        //    var qusetionList = await trialQuestionQuery.OrderBy(x => x.ShowOrder).ToListAsync();
        //    List<GetTrialReadingQuestionOutDto> readingQuestionList = qusetionList.Where(x => x.ParentId == null).ToList();
        //    readingQuestionList.ForEach(x =>
        //    {
        //        _readingImageTaskService.FindChildQuestion(x, qusetionList);
        //    });

        //    return readingQuestionList;
        //}

        ///// <summary>
        ///// 设置项目标准是否生效
        ///// </summary>
        ///// <param name="inDto"></param>
        ///// <returns></returns>
        //public async Task<IResponseOutput> SetTrialReadingQuestionCriterionIsIsEnable(SetSystemReadingQuestionCriterionIsIsEnable inDto)
        //{
        //    await _readingQuestionCriterionTrialRepository.UpdatePartialFromQueryAsync(inDto.Id, x => new ReadingQuestionCriterionTrial()
        //    {
        //        IsEnable = inDto.IsEnable
        //    });

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

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

        #endregion


    }
}