using AutoMapper;
using EasyCaching.Core;
using EntityFrameworkCore.Triggered;
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;

        public SubjectVisitCheckPassedTrigger(IRepository<Subject> subjectRepository,
             IRepository<ClinicalDataTrialSet> clinicalDataTrialSetRepository,
            IRepository<ReadingClinicalData> readingClinicalDataRepository,
            IVisitTaskHelpeService visitTaskHelpeService)
        {

            _subjectRepository = subjectRepository;
            _clinicalDataTrialSetRepository = clinicalDataTrialSetRepository;
            _readingClinicalDataRepository = readingClinicalDataRepository;
            this._clinicalDataTrialSetRepository = clinicalDataTrialSetRepository;
            _visitTaskHelpeService = visitTaskHelpeService;
        }

      

        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;

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

            }


        }
    }
}