//--------------------------------------------------------------------
//     此代码由T4模板自动生成  byzhouhang 20210918
//	   生成时间 2023-03-17 11:58:57 
//     对此文件的更改可能会导致不正确的行为，并且如果重新生成代码，这些更改将会丢失。
//--------------------------------------------------------------------

using IRaCIS.Core.Domain.Models;
using Microsoft.AspNetCore.Mvc;
using IRaCIS.Core.Application.Interfaces;
using IRaCIS.Core.Application.ViewModel;
using IRaCIS.Core.Application.Contracts.DTO;
using System.Linq;
using System.Linq.Dynamic.Core;

namespace IRaCIS.Core.Application.Service
{
    /// <summary>
    /// SubjectCriteriaEvaluationService
    /// </summary>	
    [ApiExplorerSettings(GroupName = "Trial")]
    public class SubjectCriteriaEvaluationService : BaseService, ISubjectCriteriaEvaluationService
    {

        private readonly IRepository<SubjectCriteriaEvaluation> _subjectCriteriaEvaluationRepository;
        private readonly IRepository<Subject> _subjectRepository;
        private readonly IRepository<SubjectVisit> _subjectVisitRepository;
        private readonly IRepository<SubjectCriteriaEvaluationVisitFilter> _subjectCriteriaEvaluationVisitFilterRepository;
        private readonly IRepository<SubjectCriteriaEvaluationVisitStudyFilter> _subjectCriteriaEvaluationVisitStudyFilterRepository;



        public SubjectCriteriaEvaluationService(IRepository<SubjectCriteriaEvaluation> subjectCriteriaEvaluationRepository, IRepository<Subject> subjectRepository,
            IRepository<SubjectCriteriaEvaluationVisitFilter> subjectCriteriaEvaluationVisitFilterRepository, IRepository<SubjectVisit> subjectVisitRepository,
            IRepository<SubjectCriteriaEvaluationVisitStudyFilter> subjectCriteriaEvaluationVisitStudyFilterRepository)
        {
            _subjectCriteriaEvaluationRepository = subjectCriteriaEvaluationRepository;
            _subjectRepository = subjectRepository;
            _subjectCriteriaEvaluationVisitFilterRepository = subjectCriteriaEvaluationVisitFilterRepository;
            _subjectVisitRepository = subjectVisitRepository;
            _subjectCriteriaEvaluationVisitStudyFilterRepository = subjectCriteriaEvaluationVisitStudyFilterRepository;

        }


        /// <summary>
        /// subject  某标准  是否评估列表
        /// </summary>
        /// <param name="inQuery"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<PageOutput<SubjectCriteriaEvaluationView>> GetSubjectCriteriaEvaluationList(SubjectCriteriaEvaluationQuery inQuery)
        {

            var subjectCriteriaEvaluationQueryable = from subject in _subjectRepository
                   .WhereIf(!string.IsNullOrWhiteSpace(inQuery.SubjectCode), t => t.Code.Contains(inQuery.SubjectCode))
                  .WhereIf(!string.IsNullOrWhiteSpace(inQuery.TrialSiteCode), t => t.TrialSite.TrialSiteCode.Contains(inQuery.TrialSiteCode))
                  .WhereIf(inQuery.SubjectStatus != null, t => t.Status == inQuery.SubjectStatus)

                                                     join subjectCriteriaEvaluation in _subjectCriteriaEvaluationRepository.Where(t => t.TrialReadingCriterionId == inQuery.TrialReadingCriterionId) on subject.Id equals subjectCriteriaEvaluation.SubjectId into d
                                                     from subjectCriteriaEvaluation in d.DefaultIfEmpty()

                                                     select new SubjectCriteriaEvaluationView()
                                                     {
                                                         SubjectCode = subject.Code,
                                                         SubjectId = subject.Id,
                                                         SubjectStatus = subject.Status,
                                                         TrialSiteCode = subject.TrialSite.TrialSiteCode,

                                                         Id = subjectCriteriaEvaluation.Id,
                                                         TrialReadingCriterionId = inQuery.TrialReadingCriterionId,

                                                         IsImageFiltering = subjectCriteriaEvaluation.IsImageFiltering,
                                                         IsJoinEvaluation = subjectCriteriaEvaluation.IsJoinEvaluation,
                                                     };





            var pageList = await subjectCriteriaEvaluationQueryable.ToPagedListAsync(inQuery.PageIndex, inQuery.PageSize, inQuery.SortField == string.Empty ? nameof(SubjectCriteriaEvaluationView.SubjectCode) : inQuery.SortField, inQuery.Asc);

            return pageList;
        }


        /// <summary>
        ///  添加 编辑 是否参与评估
        /// </summary>
        /// <param name="addOrEditSubjectCriteriaEvaluation"></param>
        /// <returns></returns>
        public async Task<IResponseOutput> AddOrUpdateSubjectCriteriaEvaluation(SubjectCriteriaEvaluationAddOrEdit addOrEditSubjectCriteriaEvaluation)
        {
            //  在此处拷贝automapper 映射

            var entity = await _subjectCriteriaEvaluationRepository.InsertOrUpdateAsync(addOrEditSubjectCriteriaEvaluation, true);

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

        }



        /// <summary>
        /// 评估访视筛选列表
        /// </summary>
        /// <param name="inQuery"></param>
        /// <returns></returns>
        public async Task<List<SubjectCriteriaEvaluationVisitFilterView>> GetSubjectCriteriaEvaluationVisitFilterList(SubjectCriteriaEvaluationVisitFilterQuery inQuery)
        {




            var subjectCriteriaEvaluationVisitFilterQueryable = from subjectVisit in _subjectVisitRepository.Where(t => t.SubjectId == inQuery.SubjectId)


                                                                join subjectCriteriaEvaluationVisitFilter in _subjectCriteriaEvaluationVisitFilterRepository.Where(t => t.TrialReadingCriterionId == inQuery.TrialReadingCriterionId) on subjectVisit.Id equals subjectCriteriaEvaluationVisitFilter.SubjectVisitId into d
                                                                from subjectCriteriaEvaluationVisitFilter in d.DefaultIfEmpty()

                                                                select new SubjectCriteriaEvaluationVisitFilterView()
                                                                {
                                                                    VisitName = subjectVisit.VisitName,
                                                                    SubjectVisitId = subjectVisit.Id,
                                                                    SubjectId = subjectVisit.SubjectId,
                                                                    TrialReadingCriterionId = inQuery.TrialReadingCriterionId,
                                                                    LatestScanDate = subjectVisit.LatestScanDate,
                                                                    EarliestScanDate = subjectVisit.LatestScanDate,
                                                                    ImageDeterminationResultState = subjectCriteriaEvaluationVisitFilter.ImageDeterminationResultState,
                                                                    ImageFilterState = subjectCriteriaEvaluationVisitFilter.ImageFilterState,
                                                                    IsGeneratedTask = subjectCriteriaEvaluationVisitFilter.IsGeneratedTask,

                                                                };







            return await subjectCriteriaEvaluationVisitFilterQueryable.ToListAsync();
        }

        /// <summary>
        /// 评估访视 判断结果    影像筛选状态  手动添加/编辑接口
        /// </summary>
        /// <param name="addOrEditSubjectCriteriaEvaluationVisitFilter"></param>
        /// <returns></returns>
        public async Task<IResponseOutput> AddOrUpdateSubjectCriteriaEvaluationVisitFilter(SubjectCriteriaEvaluationVisitFilterAddOrEdit addOrEditSubjectCriteriaEvaluationVisitFilter)
        {

            var entity = await _subjectCriteriaEvaluationVisitFilterRepository.InsertOrUpdateAsync(addOrEditSubjectCriteriaEvaluationVisitFilter, true);

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

        }


        /// <summary>
        /// 获取dicom     访视检查列表  （序列的 CreateTime    是否为空 代表了记录是否创建、IsConfirmed 代表 保存  确认）
        /// </summary>
        /// <returns></returns>
        public async Task<SelctStudySeriesView> GetVisitStudyAndSeriesList(VisitStudyAndSeriesQuery inQuery)
        {
            var studyList = await _repository.Where<DicomStudy>(s => s.SubjectVisitId == inQuery.SubjectVisitId).ProjectTo<SelectStudyView>(_mapper.ConfigurationProvider).ToListAsync();

            var studyIds = studyList.Select(t => t.StudyId).ToList();


            var query = from series in _repository.Where<DicomSeries>(t => studyIds.Contains(t.StudyId))
                        join visitStudyFilter in _subjectCriteriaEvaluationVisitStudyFilterRepository.Where(t => t.TrialReadingCriterionId == inQuery.TrialReadingCriterionId && t.SubjectVisitId == inQuery.SubjectVisitId) on series.Id equals visitStudyFilter.SeriesId into d
                        from visitStudyFilter in d.DefaultIfEmpty()

                        select new SelectSeriesView()
                        {
                            Description=series.Description,
                            BodyPartExamined=series.BodyPartExamined,
                            BodyPartForEdit=series.BodyPartForEdit,
                            Modality=series.Modality,
                            SeriesInstanceUid=series.SeriesInstanceUid,
                            StudyCode=series.DicomStudy.StudyCode,
                            SeriesNumber=series.SeriesNumber,
                            SeriesTime=series.SeriesTime,
                           

                            StudyTime = series.DicomStudy.StudyTime,
                            StudyId = series.StudyId,
                            SeriesId = series.Id,
                            SubjectVisitId =series.SubjectVisitId,
                            TrialReadingCriterionId= inQuery.TrialReadingCriterionId,

                            CreateTime = visitStudyFilter.CreateTime,
                            IsConfirmed=visitStudyFilter.IsConfirmed,
                        };


            var seriesList = query.ToList();




            return new SelctStudySeriesView { StudyList = studyList, SeriesList = seriesList };

        }

        /// <summary>
        /// 批量保存或者确认  选择的序列
        /// </summary>
        /// <returns></returns>
        public async Task<IResponseOutput> BatchAddSubjectCriteriaEvaluationVisitStudyFilter( List<SubjectCriteriaEvaluationVisitStudyFilterAddOrEdit>  batchList)
        {
           


            //var entity = await _subjectCriteriaEvaluationVisitStudyFilterRepository.InsertOrUpdateAsync(addOrEditSubjectCriteriaEvaluationVisitStudyFilter, true);

            return ResponseOutput.Ok();

        }



        //[HttpDelete("{subjectCriteriaEvaluationId:guid}")]
        //      public async Task<IResponseOutput> DeleteSubjectCriteriaEvaluation(Guid subjectCriteriaEvaluationId)
        //{
        //	  var success = await _subjectCriteriaEvaluationRepository.DeleteFromQueryAsync(t => t.Id == subjectCriteriaEvaluationId,true);
        //            return ResponseOutput.Ok();
        //}


    }
}