using AutoMapper;
using EasyCaching.Core;
using EntityFrameworkCore.Triggered;
using IRaCIS.Core.Application.Interfaces;
using IRaCIS.Core.Application.Service;
using IRaCIS.Core.Application.ViewModel;
using IRaCIS.Core.Domain.Share;
using IRaCIS.Core.Infrastructure;

namespace IRaCIS.Core.Application.Triggers
{
    /// <summary>
    ///  处理  访视   末次评估  会影响Subject 状态
    /// </summary>
    public class SubjectVisitCheckPassedTrigger : IBeforeSaveTrigger<SubjectVisit>
    {

        private readonly IVisitTaskHelpeService _visitTaskHelpeService;

        private readonly IRepository<Subject> _subjectRepository;
        private readonly IRepository<ClinicalDataTrialSet> _clinicalDataTrialSetRepository;
        private readonly IRepository<ReadingClinicalData> _readingClinicalDataRepository;

        private readonly IRepository<ReadingQuestionCriterionTrial> _trialReadingCriterionRepository;

        private readonly IRepository<SubjectCriteriaEvaluationVisitFilter> _SubjectCriteriaEvaluationVisitFilterRepository;



        private readonly ISubjectCriteriaEvaluationService _subjectCriteriaEvaluationService;

        private readonly IRepository<SubjectCriteriaEvaluation> _subjectCriteriaEvaluationRepository;

        public SubjectVisitCheckPassedTrigger(IRepository<Subject> subjectRepository,
             IRepository<ClinicalDataTrialSet> clinicalDataTrialSetRepository,
            IRepository<ReadingClinicalData> readingClinicalDataRepository,
            IVisitTaskHelpeService visitTaskHelpeService, IRepository<ReadingQuestionCriterionTrial> trialReadingCriterionRepository,
            IRepository<SubjectCriteriaEvaluationVisitFilter> subjectCriteriaEvaluationVisitFilterRepository, ISubjectCriteriaEvaluationService subjectCriteriaEvaluationService 
            , IRepository<SubjectCriteriaEvaluation> subjectCriteriaEvaluationRepository)
        {
            _subjectCriteriaEvaluationRepository= subjectCriteriaEvaluationRepository;
            _subjectRepository = subjectRepository;
            _clinicalDataTrialSetRepository = clinicalDataTrialSetRepository;
            _readingClinicalDataRepository = readingClinicalDataRepository;
            this._clinicalDataTrialSetRepository = clinicalDataTrialSetRepository;
            _visitTaskHelpeService = visitTaskHelpeService;
            _trialReadingCriterionRepository = trialReadingCriterionRepository;
            _SubjectCriteriaEvaluationVisitFilterRepository = subjectCriteriaEvaluationVisitFilterRepository;
            _subjectCriteriaEvaluationService = subjectCriteriaEvaluationService;
        }



        public async Task BeforeSave(ITriggerContext<SubjectVisit> context, CancellationToken cancellationToken)
        {
            var subjectVisit = context.Entity;


            if (context.ChangeType == ChangeType.Modified)
            {

                // 一致性核查通过  生成读片任务
                if (context.UnmodifiedEntity?.CheckState != subjectVisit.CheckState && subjectVisit.CheckState == CheckStateEnum.CVPassed)
                {
                    //退回或者重阅的任务一致性核查通过了  此时设置Subject 重阅影响状态
                    if (context.Entity.IsPMBackOrReReading == true)
                    {
                        await _subjectRepository.UpdatePartialFromQueryAsync(context.Entity.SubjectId, u => new Subject() { IsReReadingOrBackInfluenceAnalysis = false });
                    }

                    context.Entity.IsPMBackOrReReading = false;

                    //找到手动生成任务的标准
                    var criterionList = await _trialReadingCriterionRepository.Where(t => t.IsAutoCreate == false && t.IsSigned == true).Select(t => new { t.Id, t.TrialId,t.IsReadingTaskViewInOrder }).ToListAsync();

                    foreach (var criterion in criterionList)
                    {
                        //if(!await _SubjectCriteriaEvaluationVisitFilterRepository.AnyAsync(t=>t.SubjectId==subjectVisit.SubjectId&& t.SubjectVisitId==subjectVisit.Id && t.TrialReadingCriterionId == criterion.Id))
                        //{
                        //    await _SubjectCriteriaEvaluationVisitFilterRepository.AddAsync(new SubjectCriteriaEvaluationVisitFilter() { SubjectId = subjectVisit.SubjectId, SubjectVisitId = subjectVisit.Id, TrialReadingCriterionId = criterion.Id });
                        //}

                        //如果参与评估，那么久对当前访视进行自动筛选
                        if( await _subjectCriteriaEvaluationRepository.AnyAsync(t=>t.SubjectId==subjectVisit.SubjectId && t.TrialReadingCriterionId==criterion.Id && t.IsJoinEvaluation))
                        {
                            await _subjectCriteriaEvaluationService.AutoSubjectCriteriaEvaluationVisitFilter(subjectVisit.SubjectId, subjectVisit.Id, criterion.Id);

                        }




                    }

                    await _visitTaskHelpeService.GenerateVisitTaskAsync(subjectVisit.TrialId, new List<Guid>() { subjectVisit.Id }, true);

                }

            }
            // 触发临床数据
            //if (context.ChangeType == ChangeType.Added)
            //{
            //    var cRCClinicalDatas = await _clinicalDataTrialSetRepository.Where(x => x.TrialId == context.Entity.TrialId && x.UploadRole == UploadRole.CRC && x.IsConfirm)

            //      .Select(x => new
            //      {
            //          x.Id,
            //          x.ClinicalDataLevel,
            //      }).ToListAsync();

            //    List<ReadingClinicalData> readingClinicals = new List<ReadingClinicalData>();
            //    readingClinicals.AddRange(

            //           cRCClinicalDatas.WhereIf(!context.Entity.IsBaseLine, x => x.ClinicalDataLevel == ClinicalLevel.SubjectVisit).Select(x => new ReadingClinicalData()
            //           {
            //               ClinicalDataTrialSetId = x.Id,
            //               IsVisit = true,
            //               SubjectId = context.Entity.SubjectId,
            //               ReadingId = context.Entity.Id,
            //               TrialId = context.Entity.TrialId

            //           }).ToList()

            //   );


            //    await _readingClinicalDataRepository.AddRangeAsync(readingClinicals);
            //    await _readingClinicalDataRepository.SaveChangesAsync();

            //}


        }
    }
}