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

using IRaCIS.Core.Domain.Models;
using Microsoft.AspNetCore.Mvc;
using IRaCIS.Core.Application.Interfaces;
using IRaCIS.Core.Application.ViewModel;
using IRaCIS.Core.Infra.EFCore;
using IRaCIS.Core.Infrastructure;
using IRaCIS.Core.Domain.Share;
using MimeKit;
using MailKit.Security;
using Microsoft.AspNetCore.Authorization;
using Panda.DynamicWebApi.Attributes;

namespace IRaCIS.Core.Application.Service
{
    /// <summary>
    /// 项目外部人员  录入流程相关
    /// </summary>	
    [ApiExplorerSettings(GroupName = "Trial")]
    public class TrialExternalUserService : BaseService, ITrialExternalUserService
    {
        private readonly IRepository<TrialExternalUser> _trialExternalUseRepository;
        private readonly IRepository<User> _userRepository;
        private readonly IRepository<TrialUser> _trialUserRepository;
        private readonly IRepository<TrialSiteUserSurvey> _trialSiteSurveyUserRepository;
        private readonly IRepository<TrialSiteUser> _trialSiteUserRepository;

        public TrialExternalUserService(IRepository<TrialExternalUser> trialExternalUseRepository, IRepository<User> userRepository, IRepository<TrialUser> trialUserRepository,
            IRepository<TrialSiteUserSurvey> trialSiteSurveyUserRepository,IRepository<TrialSiteUser> trialSiteUserRepository)
        {
            _trialExternalUseRepository = trialExternalUseRepository;
            _userRepository = userRepository;
            _trialUserRepository = trialUserRepository;
            _trialSiteSurveyUserRepository = trialSiteSurveyUserRepository;
            _trialSiteUserRepository = trialSiteUserRepository;
        }


        [HttpPost]
        public async Task<List<TrialExternalUserView>> GetTrialExternalUserList(TrialExternalUserQuery queryTrialExternalUser)
        {

            var trialExternalUserQueryable = _trialExternalUseRepository.Where(t => t.TrialId == queryTrialExternalUser.TrialId)
                .WhereIf(!string.IsNullOrEmpty(queryTrialExternalUser.Phone), t => t.Phone.Contains(queryTrialExternalUser.Phone))
                .WhereIf(!string.IsNullOrEmpty(queryTrialExternalUser.Email), t => t.Email.Contains(queryTrialExternalUser.Email))
                .WhereIf(!string.IsNullOrEmpty(queryTrialExternalUser.Name), t => (t.LastName + " / " + t.FirstName).Contains(queryTrialExternalUser.Name))
            .ProjectTo<TrialExternalUserView>(_mapper.ConfigurationProvider);

            return await trialExternalUserQueryable.ToListAsync();
        }

        /// <summary>
        /// 验证  在系统中是否存在该类型的账户  返回true  表示 不存在 可以添加和更新|存在但是信息一致，false 需要提示不一致项（前端 可以直接用我返回的错误信息，或者根据返回的用户信息实体，自己设置格式显示）
        /// </summary>
        /// <param name="addOrEditTrialExternalUser"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IResponseOutput> VerifyUserIsCanAddOrUpdate(VerifyUserAdd addOrEditTrialExternalUser)
        {

            var existUser = await _userRepository.FirstOrDefaultAsync(t => t.EMail == addOrEditTrialExternalUser.Email && t.UserTypeId == addOrEditTrialExternalUser.UserTypeId);

            if (existUser != null)
            {
                if (existUser.LastName != addOrEditTrialExternalUser.LastName || existUser.FirstName != addOrEditTrialExternalUser.FirstName)
                {
                    return ResponseOutput.NotOk($"该用户在系统中账户名为：{existUser.LastName + " / " + existUser.FirstName} 电话：{existUser.Phone}，与填写信息存在不一致项, 现将界面信息修改为与系统一致，可进行保存", new { existUser.LastName, existUser.FirstName, existUser.Phone });
                }

            }
            return ResponseOutput.Ok();

        }


        /// <summary>
        /// 添加和更新接口   已验证邮箱和账户类型不允许添加重复项
        /// </summary>
        /// <param name="addOrEditTrialExternalUser"></param>
        /// <returns></returns>
        public async Task<IResponseOutput> AddOrUpdateTrialExternalUser(TrialExternalUserAddOrEdit addOrEditTrialExternalUser)
        {

            //var verifyExp1 = new EntityVerifyExp<TrialExternalUser>()
            //{
            //    VerifyExp = t => t.Email == addOrEditTrialExternalUser.Email && t.UserTypeId == addOrEditTrialExternalUser.UserTypeId,
            //    VerifyMsg = ""
            //};
            //var entity = await _trialExternalUseRepository.InsertOrUpdateAsync(addOrEditTrialExternalUser, false, verifyExp1);


            if (addOrEditTrialExternalUser.Id == null)
            {
                var existSysUser = await _userRepository.FirstOrDefaultAsync(t => t.EMail == addOrEditTrialExternalUser.Email && t.UserTypeId == addOrEditTrialExternalUser.UserTypeId);

                if (existSysUser != null)
                {
                    if (existSysUser.LastName != addOrEditTrialExternalUser.LastName || existSysUser.FirstName != addOrEditTrialExternalUser.FirstName)
                    {
                        return ResponseOutput.NotOk($"该用户在系统中账户名为：{existSysUser.LastName + " / " + existSysUser.FirstName} 电话：{existSysUser.Phone}，与填写信息存在不一致项, 现将界面信息修改为与系统一致，可进行保存", new { existSysUser.LastName, existSysUser.FirstName, existSysUser.Phone }, ApiResponseCodeEnum.NeedTips);
                    }

                }

                //处理  生成账户

                if (await _trialExternalUseRepository.AnyAsync(t =>
                        t.Email == addOrEditTrialExternalUser.Email &&
                        t.UserTypeId == addOrEditTrialExternalUser.UserTypeId && t.TrialId == addOrEditTrialExternalUser.TrialId))
                {
                    return ResponseOutput.NotOk("该外部用户表已存在 相同邮箱用户类型的账户");
                }


                var addEntity = _mapper.Map<TrialExternalUser>(addOrEditTrialExternalUser);

                await _trialExternalUseRepository.AddAsync(addEntity);


                var existUser = await _userRepository.FirstOrDefaultAsync(t => t.EMail == addOrEditTrialExternalUser.Email && t.UserTypeId == addOrEditTrialExternalUser.UserTypeId);

                if (existUser != null)
                {
                    addEntity.IsSystemUser = true;
                    addEntity.SystemUserId = existUser.Id;

                }
                else
                {
                    //生成账户  并插入

                    var generateUser = _mapper.Map<User>(addOrEditTrialExternalUser);

                    generateUser.Code = _userRepository.Select(t => t.Code).DefaultIfEmpty().Max() + 1;


                    generateUser.UserCode = AppSettings.UserCodePrefix + generateUser.Code.ToString("D4");

                    generateUser.UserName = generateUser.UserCode;

                    generateUser.UserTypeEnum = _repository.Where<UserType>(t => t.Id == generateUser.UserTypeId).Select(t => t.UserTypeEnum).First();

                    generateUser.Password = MD5Helper.Md5("123456");

                    generateUser.Status = UserStateEnum.Disable;

                    var newAddUser = await _repository.AddAsync(generateUser);


                    addEntity.IsSystemUser = false;
                    addEntity.SystemUserId = newAddUser.Id;


                }

                await _trialExternalUseRepository.SaveChangesAsync();

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

            }
            else
            {
                return ResponseOutput.NotOk("这里不允许编辑，删除后再添加");


                if (await _trialExternalUseRepository.AnyAsync(t =>
                        t.Email == addOrEditTrialExternalUser.Email &&
                        t.UserTypeId == addOrEditTrialExternalUser.UserTypeId && t.Id != addOrEditTrialExternalUser.Id && t.TrialId == addOrEditTrialExternalUser.TrialId))
                {
                    return ResponseOutput.NotOk("该邮箱和用户类型，已存在该账户");
                }

                //if (addOrEditTrialExternalUser.IsSystemUser)
                //{
                //    return ResponseOutput.NotOk("系统账户不允许编辑");
                //}


                var needUpdateEntity =
                  await _trialExternalUseRepository.FirstOrDefaultAsync(t => t.Id == addOrEditTrialExternalUser.Id);

                //更改之前  先验证是否在系统账户中存在

                _mapper.Map(addOrEditTrialExternalUser, needUpdateEntity);


                await _trialExternalUseRepository.SaveChangesAsync();

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

            }


        }




        [HttpDelete("{trialExternalUserId:guid}/{isSystemUser:bool}/{systemUserId}")]
        public async Task<IResponseOutput> DeleteTrialExternalUser(Guid trialExternalUserId, bool isSystemUser, Guid systemUserId)
        {
            var success = await _trialExternalUseRepository.DeleteFromQueryAsync(t => t.Id == trialExternalUserId);

            if (isSystemUser == false)
            {
                await _userRepository.DeleteFromQueryAsync(t => t.Id == systemUserId);
            }

            return ResponseOutput.Result(success);
        }


        /// <summary>
        /// 勾选用户 批量发送邮件 
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public async Task<IResponseOutput> SendInviteEmail(TrialExternalUserSendEmail sendEmail)
        {

            var trialInfo = await _repository.FirstOrDefaultAsync<Trial>(t => t.Id == sendEmail.TrialId);

            foreach (var userInfo in sendEmail.SendUsers)
            {
                var messageToSend = new MimeMessage();
                //发件地址
                messageToSend.From.Add(new MailboxAddress("GRR", "iracis_grr@163.com"));
                //收件地址
                messageToSend.To.Add(new MailboxAddress(String.Empty, userInfo.Email));
                //主题
                messageToSend.Subject = "GRR External User survey (Verification Code)";

                var baseApiUrl = sendEmail.BaseUrl.Remove(sendEmail.BaseUrl.IndexOf("#")) + "api";

                var sysUserInfo = await _userRepository.Where(t => t.Id == userInfo.SystemUserId).Include(t => t.UserTypeRole).FirstOrDefaultAsync();


                var builder = new BodyBuilder();

                int verificationCode = new Random().Next(100000, 1000000);

                if (sysUserInfo.IsFirstAdd)
                {
                    await _userRepository.UpdateFromQueryAsync(t => t.Id == sysUserInfo.Id,
                        u => new User() { Password = MD5Helper.Md5(verificationCode.ToString()) });
                }


                builder.HtmlBody = @$"<body style='font-family: 微软雅黑;padding: 0;margin: 0;'>
                                      <div style='padding-left: 40px;background: #f6f6f6'>
                                        <div style='padding-top: 20px;'>
                                          <div style='line-height: 40px;font-size: 18px'>
                                            {sysUserInfo.LastName + "/" + sysUserInfo.FirstName}:
                                          </div>
                                          <div style='line-height: 40px;padding-left: 40px;margin-bottom: 10px;'>
                                            您参与的临床试验项目 {trialInfo.ExperimentName} ,独立影像评估相关工作将在网上进行。项目及账号信息为:
                                          </div>
                                          <div style='border: 1px solid #eee;box-sizing:border-box;width: 80%;background: #fff;padding: 20px;line-height: 40px;font-size: 14px;border-radius: 5px;margin-left: 60px;margin-bottom: 30px;'>
                                            <div>
                                              项目编号: {trialInfo.TrialCode}
                                            </div>
                                            <div>
                                              试验方案号: {trialInfo.ResearchProgramNo}
                                            </div>
                                            <div>
                                              试验名称: {trialInfo.ExperimentName}
                                            </div>
                                            <div>
                                              用户名: {sysUserInfo.UserName}
                                            </div>
                                            <div>
                                              密码: {(sysUserInfo.IsFirstAdd ? verificationCode.ToString()+"(请在登录后进行修改)" : "***(您已有账号, 若忘记密码, 请通过邮箱找回)")}
                                            </div>
                                            <div>
                                              角色: {sysUserInfo.UserTypeRole.UserTypeShortName}
                                            </div>
                                            <div>
                                              系统登录地址: {sendEmail.BaseUrl}  (请确认加入后再登陆)
                                            </div>
                                          </div>
                                          <a href='  {sendEmail.RouteUrl + "?Id="+ userInfo.Id+ "&IsExternalUser=1"}' style='margin-left:60px;font-size:14px;text-decoration: none;display: inline-block;height: 40px;width: 140px;background: #00D1B2;color:#fff;border-radius: 5px;line-height: 40px;text-align: center;margin-bottom: 100px;'>
                                            查看并确认
                                          </a>      
                                        </div>
                                      </div>
                                    </body>";


                messageToSend.Body = builder.ToMessageBody();

                using (var smtp = new MailKit.Net.Smtp.SmtpClient())
                {
                    smtp.MessageSent += (sender, args) =>
                    {

                        _ = _trialExternalUseRepository.UpdateFromQueryAsync(t => t.Id == userInfo.Id, u => new TrialExternalUser() { InviteState = TrialExternalUserStateEnum.HasSend, ExpireTime = DateTime.Now.AddDays(7) }).Result;

                    };

                    smtp.ServerCertificateValidationCallback = (s, c, h, e) => true;

                    await smtp.ConnectAsync("smtp.163.com", 25, SecureSocketOptions.StartTls);

                    await smtp.AuthenticateAsync("iracis_grr@163.com", "XLWVQKZAEKLDWOAH");

                    await smtp.SendAsync(messageToSend);

                    await smtp.DisconnectAsync(true);
                }


            }

            return ResponseOutput.Ok();

        }




        /// <summary>
        ///  不带Token 访问  用户选择   参与  不参与    Id:  TrialExternalUserId
        /// </summary>
        /// <param name="editTrialUserPreparation"></param>
        /// <returns></returns>
        [AllowAnonymous]
        public async Task<IResponseOutput> TrialExternalUserJoinTrial(TrialExternalUserConfirm editTrialUserPreparation)
        {

            var needUpdate = await _trialExternalUseRepository.FirstOrDefaultAsync(t => t.Id == editTrialUserPreparation.Id);


            if (DateTime.Now > needUpdate.ExpireTime)
            {
                return ResponseOutput.NotOk("邀请加入时间已过期，重新被邀请后才可以进行确认操作");
            }

            _mapper.Map(editTrialUserPreparation, needUpdate);

            needUpdate.InviteState = TrialExternalUserStateEnum.UserConfirmed;


            var trialId = needUpdate.TrialId;
            var userId = needUpdate.SystemUserId;

            //判断TrialUser中是否存在  不存在就插入
            if (!await _trialUserRepository.AnyAsync(t => t.TrialId == trialId && t.UserId == userId))
            {

                await _trialUserRepository.AddAsync(new TrialUser() { TrialId = trialId, UserId = userId });

                await _trialExternalUseRepository.UpdateFromQueryAsync(t => t.TrialId == trialId && t.SystemUserId == userId,
                    u => new TrialExternalUser() { InviteState = TrialExternalUserStateEnum.UserConfirmed });

            }
            await _userRepository.UpdateFromQueryAsync(t => t.Id == userId, u => new User() { Status = UserStateEnum.Enable });

            var success = await _trialExternalUseRepository.SaveChangesAsync();

            return ResponseOutput.Ok();

        }

        /// <summary>
        ///  不带Token 访问  Site调研用户 加入项目   Id:  TrialSiteSurveyUserId
        /// </summary>
        /// <param name="editInfo"></param>
        /// <returns></returns>
        [AllowAnonymous]
        public async Task<IResponseOutput> TrialSiteSurveyUserJoinTrial(TrialExternalUserConfirm editInfo)
        {

            var needUpdate = await _trialSiteSurveyUserRepository.Where(t => t.Id == editInfo.Id).Include(t=>t.TrialSiteSurvey).FirstOrDefaultAsync();


            if (DateTime.Now > needUpdate.ExpireTime)
            {
                return ResponseOutput.NotOk("邀请加入时间已过期，重新被邀请后才可以进行确认操作");
            }

            _mapper.Map(editInfo, needUpdate);

            //needUpdate.InviteState = TrialExternalUserStateEnum.UserConfirmed;


            if (needUpdate.SystemUserId==null)
            {
                return ResponseOutput.NotOk("调研表系统用户Id 存储有问题");
            }

            var trialId = needUpdate.TrialSiteSurvey.TrialId;
            var siteId= needUpdate.TrialSiteSurvey.SiteId;
            var userId = (Guid)needUpdate.SystemUserId;


            if (!_trialUserRepository.Where(t => t.TrialId == trialId && t.UserId == userId).Any())
            {
                await _trialUserRepository.AddAsync(new TrialUser() { TrialId = trialId, UserId = userId });

                await _trialSiteUserRepository.AddAsync(new TrialSiteUser() { TrialId = trialId, SiteId = siteId, UserId = userId });
            }

            await _userRepository.UpdateFromQueryAsync(t => t.Id == needUpdate.SystemUserId, u => new User() { Status = UserStateEnum.Enable });


            var success =await  _trialExternalUseRepository.SaveChangesAsync();

            return ResponseOutput.Ok();

        }



        /// <summary>
        /// 不带Token 访问   页面获取项目基本信息  和参与情况 (已经确认了 就不允许再次确认)  Id:  TrialExternalUserId/TrialSiteSurveyUserId  
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [AllowAnonymous]
        public async Task<TrialInfoWithPreparationInfo> JoinBasicInfo(Guid id,bool isExternalUser)
        {
            if (isExternalUser)
            {
                return (await _trialExternalUseRepository.Where(t => t.Id == id)
                    .ProjectTo<TrialInfoWithPreparationInfo>(_mapper.ConfigurationProvider).FirstOrDefaultAsync()).IfNullThrowException();
            }
            else
            {
                return (await _trialSiteSurveyUserRepository.Where(t => t.Id == id)
                    .ProjectTo<TrialInfoWithPreparationInfo>(_mapper.ConfigurationProvider).FirstOrDefaultAsync()).IfNullThrowException();
            }
          
        }





        /// <summary>
        /// 加入项目    
        /// </summary>
        /// <param name="trialId"></param>
        /// <param name="trialExternalUserId"></param>
        /// <returns></returns>
        [HttpGet("{trialId:guid}/{trialExternalUserId:guid}")]
        [NonDynamicMethod]
        public async Task<IResponseOutput> UserConfirmJoinTrial(Guid trialId, Guid trialExternalUserId)
        {

            var externalUser = await _trialExternalUseRepository.FirstOrDefaultAsync(t => t.Id == trialExternalUserId);


            //判断TrialUser中是否存在  不存在就插入
            if (!await _repository.AnyAsync<TrialUser>(t => t.TrialId == trialId && t.UserId == externalUser.SystemUserId))
            {
                await _repository.AddAsync(new TrialUser() { TrialId = trialId, UserId = (Guid)externalUser.SystemUserId });

                await _trialExternalUseRepository.UpdateFromQueryAsync(t => t.Id == trialExternalUserId,
                    u => new TrialExternalUser() { InviteState = TrialExternalUserStateEnum.UserConfirmed });

                await _userRepository.UpdateFromQueryAsync(t => t.Id == externalUser.SystemUserId, u => new User() { Status = UserStateEnum.Enable });

                await _userRepository.SaveChangesAsync();
            }



            return ResponseOutput.Ok();


        }


    }
}