//--------------------------------------------------------------------
//     此代码由T4模板自动生成  byzhouhang 20210918
//	   生成时间 2024-07-30 10:39:09 
//     对此文件的更改可能会导致不正确的行为，并且如果重新生成代码，这些更改将会丢失。
//--------------------------------------------------------------------

using IRaCIS.Core.Domain.Models;
using Microsoft.AspNetCore.Mvc;
using IRaCIS.Core.Application.Interfaces;
using IRaCIS.Core.Application.ViewModel;
using Newtonsoft.Json;
using IRaCIS.Core.Domain.Share;
using IRaCIS.Core.Infrastructure;
using MailKit;
using IRaCIS.Application.Services;
namespace IRaCIS.Core.Application.Service
{
    /// <summary>
    /// UserFeedBackService
    /// </summary>	
    [ApiExplorerSettings(GroupName = "Management")]
    public class UserFeedBackService : BaseService, IUserFeedBackService
    {

        private readonly IRepository<UserFeedBack> _userFeedBackRepository;

        public UserFeedBackService(IRepository<UserFeedBack> userFeedBackRepository)
        {
            _userFeedBackRepository = userFeedBackRepository;
        }

        [HttpPost]
        public async Task<PageOutput<UserFeedBackView>> GetUserFeedBackList(UserFeedBackQuery inQuery)
        {

            var isCRCOrIR = _userInfo.UserTypeEnumInt == (int)UserTypeEnum.ClinicalResearchCoordinator || _userInfo.UserTypeEnumInt == (int)UserTypeEnum.CRA || _userInfo.UserTypeEnumInt == (int)UserTypeEnum.IndependentReviewer;

            var userFeedBackQueryable = _userFeedBackRepository
                  .WhereIf(isCRCOrIR, t => t.CreateUserId == _userInfo.Id)
                  .WhereIf(inQuery.State != null, t => t.State == inQuery.State)
                   .WhereIf(inQuery.TrialId != null, t => t.TrialId == inQuery.TrialId)
                  .WhereIf(inQuery.QuestionType != null, t => t.QuestionType == inQuery.QuestionType)
                  .WhereIf(inQuery.BeginCreatime != null, t => t.CreateTime >= inQuery.BeginCreatime)

                  .WhereIf(inQuery.EndCreatime != null, t => t.CreateTime == inQuery.EndCreatime)
                  .WhereIf(inQuery.UserTypeEnum != null, t => t.CreateUser.UserTypeEnum == inQuery.UserTypeEnum)
                   .WhereIf(!string.IsNullOrEmpty(inQuery.FeedBackUserKeyInfo), t => t.CreateUser.FullName.Contains(inQuery.FeedBackUserKeyInfo)|| t.CreateUser.UserName.Contains(inQuery.FeedBackUserKeyInfo))
                  .WhereIf(!string.IsNullOrEmpty(inQuery.QuestionDescription), t => t.QuestionDescription.Contains(inQuery.QuestionDescription))
                  .WhereIf(!string.IsNullOrEmpty(inQuery.TrialKeyInfo), t => t.Trial.ExperimentName.Contains(inQuery.TrialKeyInfo) || t.Trial.TrialCode.Contains(inQuery.TrialKeyInfo))
                  .WhereIf(!string.IsNullOrEmpty(inQuery.SubejctAndVisitKeyInfo), t => t.Subject.Code.Contains(inQuery.SubejctAndVisitKeyInfo) || t.SubjectVisit.VisitName.Contains(inQuery.SubejctAndVisitKeyInfo))
                  .WhereIf(!string.IsNullOrEmpty(inQuery.TrialSiteCode), t => t.TrialSite.TrialSiteCode.Contains(inQuery.TrialSiteCode))

                .ProjectTo<UserFeedBackView>(_mapper.ConfigurationProvider);

            var pageList = await userFeedBackQueryable.ToPagedListAsync(inQuery.PageIndex, inQuery.PageSize, string.IsNullOrWhiteSpace(inQuery.SortField) ? nameof(UserFeedBackView.Id) : inQuery.SortField, inQuery.Asc);

            return pageList;
        }

        [HttpPost]
        public async Task<IResponseOutput> GetUserFeedBackInfo(GetUserFeedBackQuery inQuery)
        {
            if (inQuery.Id == null && inQuery.VisitTaskId == null)
            {
                throw new BusinessValidationFailedException("Id  或者VisitTaskId 必传一个");
            }

            var result = await _userFeedBackRepository.WhereIf(inQuery.Id == null, t => t.VisitTaskId == inQuery.VisitTaskId)
                .WhereIf(inQuery.VisitTaskId == null, t => t.Id == inQuery.Id).ProjectTo<UserFeedBackView>(_mapper.ConfigurationProvider).FirstOrDefaultAsync();

            return ResponseOutput.Ok(result);
        }


        public async Task<IResponseOutput> AddOrUpdateUserFeedBack(UserFeedBackAddOrEdit addOrEditUserFeedBack,
            [FromServices] IMailVerificationService mailService)
        {
            addOrEditUserFeedBack.ScreenshotListStr = JsonConvert.SerializeObject(addOrEditUserFeedBack.ScreenshotList);

            if (addOrEditUserFeedBack.VisitTaskId != null)
            {
                var info = await _repository.Where<VisitTask>(t => t.Id == addOrEditUserFeedBack.VisitTaskId).Select(t => new { t.SubjectId, t.SourceSubjectVisitId, t.Subject.TrialSiteId }).FirstOrDefaultAsync();

                if (info != null)
                {
                    addOrEditUserFeedBack.SubjectId = info.SubjectId;
                    addOrEditUserFeedBack.TrialSiteId = info.TrialSiteId;
                    addOrEditUserFeedBack.SubjectVisitId = info.SourceSubjectVisitId;
                }
            }

            else if (addOrEditUserFeedBack.SubjectVisitId != null)
            {
                var info = await _repository.Where<SubjectVisit>(t => t.Id == addOrEditUserFeedBack.SubjectVisitId).Select(t => new { t.TrialSiteId, t.SubjectId }).FirstOrDefaultAsync();

                if (info != null)
                {
                    addOrEditUserFeedBack.TrialSiteId = info.TrialSiteId;
                    addOrEditUserFeedBack.SubjectId = info.SubjectId;
                }
            }
            else if (addOrEditUserFeedBack.SubjectId != null)
            {
                var info = await _repository.Where<Subject>(t => t.Id == addOrEditUserFeedBack.SubjectId).Select(t => new { t.TrialSiteId }).FirstOrDefaultAsync();

                if (info != null)
                {
                    addOrEditUserFeedBack.TrialSiteId = info.TrialSiteId;
                }
            }



            var entity = await _userFeedBackRepository.InsertOrUpdateAsync(addOrEditUserFeedBack, true);

            if (addOrEditUserFeedBack.VisitTaskId != null || addOrEditUserFeedBack.Id == null)
            {
                await mailService.UserFeedBackMail(entity.Id);
            }

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

        }

        /// <summary>
        /// 批量更新状态
        /// </summary>
        /// <param name="batchUpdateCommand"></param>
        /// <returns></returns>
        [HttpPut]
        public async Task<IResponseOutput> BatchUpdateFeedBackState(BatchUpdateCommand batchUpdateCommand)
        {
            await _userFeedBackRepository.BatchUpdateNoTrackingAsync(t => batchUpdateCommand.IdList.Contains(t.Id), u => new UserFeedBack() { State = batchUpdateCommand.State });

            return ResponseOutput.Ok();
        }


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


    }
}