using IRaCIS.Application.Interfaces;
using IRaCIS.Core.Infra.EFCore;
using IRaCIS.Core.Domain.Share;
using IRaCIS.Core.Application.Filter;
using Microsoft.AspNetCore.Mvc;
using IRaCIS.Core.Application.Service.WorkLoad.DTO;
using Microsoft.AspNetCore.Authorization;
using IRaCIS.Core.Application.Auth;
using IRaCIS.Core.Application.Service.Reading.Dto;
using MassTransit;
using IRaCIS.Core.Application.Service.Reading;
using IRaCIS.Core.Infra.EFCore.Common;
using Panda.DynamicWebApi.Attributes;
using IRaCIS.Core.Application.Contracts;
using IRaCIS.Core.Infrastructure;

namespace IRaCIS.Application.Services
{
    /// <summary>
    /// 阅片问题.标准
    /// </summary>
    [ApiExplorerSettings(GroupName = "Reading")]
    public class ReadingQuestionService : BaseService, IReadingQuestionService
    {

        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<OrganInfo> _organInfoRepository;
        private readonly IRepository<ReadingTableQuestionSystem> _readingTableQuestionSystemRepository;
        private readonly IRepository<ReadingTaskQuestionAnswer> _readingTaskQuestionAnswer;
        private readonly IRepository<PreviousPDF> _previousPDFRepository;

        public 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,
            IRepository<ReadingTableQuestionTrial> readingTableQuestionTrialRepository,
            IRepository<ReadingCriterionPage> readingCriterionPageRepository,
            IRepository<Trial> trialRepository,
            IRepository<OrganInfo> organInfoRepository,
            IRepository<ReadingTableQuestionSystem> readingTableQuestionSystemRepository,
            IRepository<ReadingTaskQuestionAnswer> readingTaskQuestionAnswer,
            IRepository<PreviousPDF> previousPDFRepository
          )
        {
            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._organInfoRepository = organInfoRepository;
            this._readingTableQuestionSystemRepository = readingTableQuestionSystemRepository;
            this._readingTaskQuestionAnswer = readingTaskQuestionAnswer;
            this._previousPDFRepository = previousPDFRepository;
        }




        /// <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>
        /// <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>
        /// <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.ToListAsync();
            return result;
        }



        /// <summary>
        /// 获取项目的表格问题
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<ReadingTableQuestionTrialView>> 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.ToListAsync();
            return result;
        }


        /// <summary>
        /// 新增修改系统表格问题
        /// </summary>
        /// <param name="addOrEditReadingTableQuestionSystem"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IResponseOutput> AddOrUpdateReadingTableQuestionSystem(ReadingTableQuestionSystemAddOrEdit addOrEditReadingTableQuestionSystem)
        {
          
            var entity = await _readingTableQuestionSystemRepository.InsertOrUpdateAsync(addOrEditReadingTableQuestionSystem, true);
      
            return ResponseOutput.Ok(entity.Id.ToString());

        }

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

            var entity = await _readingTableQuestionTrialRepository.InsertOrUpdateAsync(addOrEditReadingTableQuestionTrial, 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("当前问题存在子问题 删除失败");
            }

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

        /// <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("当前问题存在子问题 删除失败");
            }

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


        /// <summary>
        /// 获取系统表格其他问题
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<CriterionOtherQuestionOutDto>> GetReadingTableOtherQuestionSystem(GetReadingTableOtherQuestionSystemInDto inDto)
        {
            var types = new List<string>()
            {
                "select","radio"
            };
            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()
                {
                    QuestionId = x.Id,
                    QuestionName = x.QuestionName,
                    TypeValue = x.TypeValue,
                }).ToListAsync();

            return questionList;
        }

        /// <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.IsConfirm).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 _trialRepository.UpdatePartialFromQueryAsync(inDto.TrialId, x => new Trial()
            {
                ArbitrationRule = inDto.ArbitrationRule,
                //IsArbitrationReading = inDto.IsArbitrationReading,
            });

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


        /// <summary>
        /// 验证是否要同步标准
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<NeedSynchronize> VerifyeCriterionNeedSynchronize(VerifyeCriterionNeedSynchronizeInDto inDto)
        {
            var trialCriterion = await _readingQuestionCriterionTrialRepository.Where(x => x.TrialId == inDto.TrialId&&x.IsConfirm).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>
        /// 同步标准到项目新(2022-08-10)
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        public async Task SynchronizeCriterion(SynchronizeCriterionInDto inDto)
        {
            var trialCriterion = await _readingQuestionCriterionTrialRepository.Where(x => x.TrialId == inDto.TrialId&&x.IsConfirm).AsNoTracking().FirstOrDefaultAsync();

            if (trialCriterion != null)
            {
                if (trialCriterion.ReadingQuestionCriterionSystemId != null)
                {

                    // 将系统里面的问题转为项目问题
                    var newTrialQuestionList = await _readingQuestionSystemRepository.Where(x => x.ReadingQuestionCriterionSystemId == trialCriterion.ReadingQuestionCriterionSystemId)
                      .ProjectTo<ReadingQuestionTrial>(_mapper.ConfigurationProvider).ToListAsync();
                    newTrialQuestionList.ForEach(x => {
                        x.Id = NewId.NextGuid();
                        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();

                        var firstQuestion = trialQuestionList.Where(y => y.ReadingQuestionSystemId == x.ReadingQuestionSystemId).FirstOrDefault();
                        if (firstQuestion != null)
                        {
                            var systemData = _mapper.Map<ReadingQuestionSystem>(x);
                            if (firstQuestion.IsJudgeQuestion)
                            {
                                if (firstQuestion.TypeValue != x.TypeValue)
                                {
                                    firstQuestion.AnswerCombination = string.Empty;
                                    firstQuestion.AnswerGroup = string.Empty;
                                    firstQuestion.JudgeType = JudgeTypeEnum.None;
                                }
                            }
                            var newData = _mapper.Map(systemData, firstQuestion);
                            newData.Id = x.Id;
                            newData.ReadingQuestionSystemId = x.ReadingQuestionSystemId;
                            question = newData.Clone();
                        }

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

                      


                        needAddDatas.Add(question);
                    };

                    await _readingQuestionTrialRepository.BatchDeleteNoTrackingAsync(x => x.ReadingQuestionCriterionTrialId == trialCriterion.Id);
                    await _readingQuestionTrialRepository.AddRangeAsync(needAddDatas);
                    await _readingQuestionCriterionTrialRepository.UpdatePartialFromQueryAsync(trialCriterion.Id, x => new ReadingQuestionCriterionTrial()
                    {
                        SynchronizeTime = DateTime.Now
                    });




                    #region 表格问题
                    var newTrialTableQuestionList = await _readingTableQuestionSystemRepository.Where(x => x.SystemCriterionId == trialCriterion.ReadingQuestionCriterionSystemId)
                   .ProjectTo<ReadingTrialTableQuestionData>(_mapper.ConfigurationProvider).ToListAsync();

                    var copyNewTrialTableQuestionList = newTrialTableQuestionList.Clone();

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


                        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(needAddTableDatas);
                    #endregion






                    await _readingQuestionTrialRepository.SaveChangesAsync();
                }
            }
          
        }


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

            }).FirstNotNullAsync();

            return result;
        }


        /// <summary>
        /// 新增修改项目标准分页
        /// </summary>
        /// <param name="addOrEditReadingCriterionPage"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IResponseOutput> AddOrUpdateReadingCriterionPage(ReadingCriterionPageAddOrEdit addOrEditReadingCriterionPage)
        {

            var entity = await _readingCriterionPageRepository.InsertOrUpdateAsync(addOrEditReadingCriterionPage, true);
            return ResponseOutput.Ok(entity.Id.ToString());

        }

        /// <summary>
        /// 删除标准分页
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        [HttpDelete("{Id:guid}")]
        public async Task<IResponseOutput> DeleteReadingCriterionPage(Guid Id)
        {
            var success = await _readingCriterionPageRepository.DeleteFromQueryAsync(t => t.Id == Id, true);
            return ResponseOutput.Ok();
        }

        ///// <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>
        [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)
                 .Where(x=>x.IsEnable);
            return await query.ToPagedListAsync(inDto.PageIndex, inDto.PageSize, inDto.SortField.IsNullOrEmpty() ? nameof(ReadingQuestionCriterionSystemView.ShowOrder) : inDto.SortField,
             inDto.Asc);
        }


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

        /// <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>
        /// <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="readingQuestionCriterionSystemId"></param>
        ///// <returns></returns>
        //[HttpDelete("{readingQuestionCriterionSystemId:guid}")]
        //public async Task<IResponseOutput> DeleteReadingQuestionCriterionSystem(Guid readingQuestionCriterionSystemId)
        //{
        //     await _readingQuestionCriterionSystemRepository.DeleteFromQueryAsync(t => t.Id == readingQuestionCriterionSystemId);
        //    var success = await _readingQuestionCriterionSystemRepository.SaveChangesAsync();
        //    return ResponseOutput.Result(success);
        //}



        /// <summary>
        /// 新增修改系统问题
        /// </summary>
        /// <param name="indto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IResponseOutput> AddOrUpdateReadingQuestionSystem(AddOrUpdateReadingQuestionSystemInDto indto)
        {
            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("问题编号重复");
            }
            var entity = await _readingQuestionSystemRepository.InsertOrUpdateAsync(indto, true);
            return ResponseOutput.Ok(entity.Id.ToString());
        }

        /// <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.PageIndex, inDto.PageSize, nameof(ReadingQuestionSystemView.ShowOrder),
             inDto.Asc);
        }

        /// <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,
                    QuestionName = x.QuestionName,
                    TypeValue=x.TypeValue,
                    GroupName = x.GroupName,
                }).ToListAsync();

            return questionList;
        }

        /// <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("此问题存在子问题,请先删除子问题");
            }
            await _readingQuestionSystemRepository.DeleteFromQueryAsync(t => t.Id == id);
            var success = await _readingQuestionSystemRepository.SaveChangesAsync();
            return ResponseOutput.Result(success);
        }

        /// <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);
            var needAddSystemDataList = await _readingQuestionCriterionSystemRepository.Where(x => !trialUsrSystemIds.Contains(x.Id)&&x.Dictionary.IsEnable&& !trialCriterionNames.Contains(x.CriterionName)).Include(x=>x.ReadingQuestionSystemList).ToListAsync();
            List<ReadingQuestionCriterionTrial> needAddCriterionList = new List<ReadingQuestionCriterionTrial>();
            List<ReadingQuestionTrial> needAddQuestionList = new List<ReadingQuestionTrial>();
            needAddSystemDataList.ForEach(x =>
            {
                var criterion = new ReadingQuestionCriterionTrial()
                {
                    CriterionName = x.CriterionName,
                    IsEnable = false,
                    ReadingQuestionCriterionSystemId = x.Id,
                    TrialId = trialId,
                    IsCompleteConfig=x.IsCompleteConfig,
                    Id = NewId.NextGuid(),
                };
                List<ReadingQuestionSystem> systemQuestionList = x.ReadingQuestionSystemList.Clone();
                
                // 同步问题暂时注释
                //List<ReadingQuestionTrial> readingQuestionTrialList = new List<ReadingQuestionTrial>();
                //SetChildParentQuestion(criterion.Id, trialId, systemQuestionList, readingQuestionTrialList);
                needAddCriterionList.Add(criterion);
                //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);
            });

        }

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

        /// <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)
                 .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> 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("当前问题已经设置了裁判标准了,修改失败");
                }
            }

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


            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("问题编号重复");
            }
            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))
                  .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="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<CriterionOtherQuestionOutDto>> GetTrialCriterionOtherQuestion(GetTrialCriterionOtherQuestionInDto inDto)
        {
            var types = new List<string>()
            {
                "select","radio"
            };
            var questionList = await _readingQuestionTrialRepository.Where(x => x.ReadingQuestionCriterionTrialId == inDto.ReadingQuestionCriterionTrialId)
                   .Where(x => types.Contains(x.Type))
                .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,
                    QuestionName = x.QuestionName,
                    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("此问题存在子问题,请先删除子问题");
            }
            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<string>> GetTrialGroupNameList(GetTrialGroupNameListInDto inDto)
        {
            var result = await _readingQuestionTrialRepository.Where(x => x.ReadingQuestionCriterionTrialId == inDto.CriterionId && x.Type == "group")
                .Where(x=>x.ReadingCriterionPageId==inDto.ReadingCriterionPageId)
                  .Select(x => x.GroupName).ToListAsync();

            return result;

        }


        /// <summary>
        /// 获取系统问题分组
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<List<string>> GetSystemGroupNameList(GetTrialGroupNameListInDto inDto)
        {
            var result = await _readingQuestionSystemRepository.Where(x => x.ReadingQuestionCriterionSystemId == inDto.CriterionId && x.Type == "group")
                  .Select(x => x.GroupName).ToListAsync();
            return result;

        }
    }
}