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 IRaCIS.Core.Domain.Share.Reading;

namespace IRaCIS.Application.Services
{
    /// <summary>
    /// 阅片期配置
    /// </summary>
    [ApiExplorerSettings(GroupName = "Reading")]
    public class ReadingPeriodSetService : BaseService
    {

        public IRepository<SubjectVisit> _subjectVisitRepository;
        private readonly IRepository<ReadingPeriodSet> _readingPeriodSetRepository;
        private readonly IRepository<Site> _siteSetRepository;

        public ReadingPeriodSetService(IRepository<SubjectVisit> subjectVisitRepository,
            IRepository<ReadingPeriodSet> ReadingPeriodSetRepository,
           IRepository<Site> SiteSetRepository
          )
        {
            _subjectVisitRepository = subjectVisitRepository;
            _readingPeriodSetRepository = ReadingPeriodSetRepository;
            _siteSetRepository = SiteSetRepository;
        }


        /// <summary>
        /// 新增或者修改
        /// </summary>
        /// <param name="addOrEditReadingPeriodSet"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IResponseOutput> AddOrUpdateReadingPeriodSet(ReadingPeriodSetAddOrEdit addOrEditReadingPeriodSet)
        {
            if (addOrEditReadingPeriodSet.Id == null)
            {
                var entity = _mapper.Map<ReadingPeriodSet>(addOrEditReadingPeriodSet);
                entity.ReadingPeriodSites = addOrEditReadingPeriodSet.SiteIds.Select(x => new ReadingPeriodSite()
                {
                    ReadingPeriodSetId = entity.Id,
                    SiteId = x,
                }).ToList();

                await _readingPeriodSetRepository.AddAsync(entity, true);
                return ResponseOutput.Ok();
            }
            else
            {
                var entity = (await _readingPeriodSetRepository.Where(t => t.Id == addOrEditReadingPeriodSet.Id, true).Include(t => t.ReadingPeriodSites).FirstOrDefaultAsync()).IfNullThrowException();
                _mapper.Map(addOrEditReadingPeriodSet, entity);
                entity.ReadingPeriodSites = addOrEditReadingPeriodSet.SiteIds.Select(x => new ReadingPeriodSite()
                {
                    ReadingPeriodSetId = entity.Id,
                    SiteId = x,
                }).ToList();
                var success = await _readingPeriodSetRepository.SaveChangesAsync();
                return ResponseOutput.Ok();

            }
        }

        /// <summary>
        /// 分页获取
        /// </summary>
        /// <param name="query"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<PageOutput<ReadingPeriodSetView>>  GetReadingPeriodSetList(ReadingPeriodSetQuery query)
		{
		     var readquery =_readingPeriodSetRepository.AsQueryable().Include(x=>x.ReadingPeriodSites)
                .WhereIf(query.TrialId!=null,x=>x.TrialId==query.TrialId)
                .WhereIf(query.ReadingPeriodName != null, x => x.ReadingPeriodName.Contains(query.ReadingPeriodName))
                .ProjectTo<ReadingPeriodSetView>(_mapper.ConfigurationProvider);
                var pageList= await readquery.ToPagedListAsync(query.PageIndex, query.PageSize, query.SortField == null ? "CreateTime" : query.SortField,
               query.SortAsc);

            return pageList;
		}

        /// <summary>
        /// 获取单挑
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpPost("ReadingPeriodSet/GetReadingPeriodSet/{id:guid}")]
        public async Task<ReadingPeriodSetView> GetReadingPeriodSet(Guid id)
        {
            var data = await _readingPeriodSetRepository.AsQueryable().Include(x => x.ReadingPeriodSites).Where(x => x.Id == id).ProjectTo<ReadingPeriodSetView>(_mapper.ConfigurationProvider).FirstOrDefaultAsync();

            return data;

        }


        /// <summary>
        /// 设置阅片期配置是否生效
        /// </summary>
        /// <param name="indto"></param>
        /// <returns></returns>
        [HttpPut]
        public async Task<IResponseOutput> SetReadingPeriodSetEffect(SetReadingPeriodSetEffect indto)
        {
            var readquery =await _readingPeriodSetRepository.UpdatePartialNowNoQueryAsync(indto.Id, x => new ReadingPeriodSet() {
                IsTakeEffect = indto.IsTakeEffect
            });
            bool result=  await _readingPeriodSetRepository.SaveChangesAsync();
            return ResponseOutput.Result(result);
        }



        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="readingPeriodSetId"></param>
        /// <returns></returns>
        [HttpDelete("{readingPeriodSetId:guid}")]
        public async Task<IResponseOutput> DeleteReadingPeriodSet(Guid readingPeriodSetId)
        {
            var success = await _repository.BatchDeleteAsync<ReadingPeriodSet>(t => t.Id == readingPeriodSetId);
            return ResponseOutput.Result(success);
        }
    }
}