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

using IRaCIS.Core.Application.Service;
using IRaCIS.Core.Application.Filter;
using IRaCIS.Core.Application.Helper;
using IRaCIS.Core.Application.Interfaces;
using IRaCIS.Core.Application.ViewModel;
using IRaCIS.Core.Domain.Share;
using IRaCIS.Core.Infrastructure;
using Medallion.Threading;
using Microsoft.AspNetCore.Mvc;

namespace IRaCIS.Core.Application.Service
{
    /// <summary>
    /// 项目外部人员  录入流程相关
    /// </summary>	
    [ApiExplorerSettings(GroupName = "Trial")]
    public class TrialExternalUserService(IRepository<TrialExternalUser> _trialExternalUseRepository,
        IRepository<UserRole> _userRoleRepository,
         IRepository<IdentityUser> _identityUserRepository,
        IRepository<TrialUserRole> _trialUserRoleRepository,
         IRepository<TrialIdentityUser> _trialIdentityUserRepository,
        IRepository<Trial> _trialRepository,
        IRepository<UserType> _userTypeRepository,
        IMailVerificationService _mailVerificationService,
        IDistributedLockProvider _distributedLockProvider, IMapper _mapper, IUserInfo _userInfo, IStringLocalizer _localizer) : BaseService, ITrialExternalUserService
    {




        [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>
        /// 添加和更新接口   已验证邮箱和账户类型不允许添加重复项
        /// </summary>
        /// <param name="addOrEditTrialExternalUser"></param>
        /// <returns></returns>
        //[Authorize(Policy = IRaCISPolicy.PM_APM)]
        [UnitOfWork]
        [TrialGlobalLimit( "AfterStopCannNotOpt" )]
        public async Task<IResponseOutput> AddOrUpdateTrialExternalUser(TrialExternalUserAddAndSendEmail addOrEditTrialExternalUser)
        {

            if (addOrEditTrialExternalUser.Id == null)
            {
                var @lock = _distributedLockProvider.CreateLock($"UserCode");

                using (await @lock.AcquireAsync())
                {
                    var existSysUser = await _identityUserRepository.Where(t => t.EMail == addOrEditTrialExternalUser.Email, true).Include(t => t.UserRoleList).FirstOrDefaultAsync();

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

                    }

                    //处理  生成账户

                    if (await _trialExternalUseRepository.AnyAsync(t =>
                            t.Email == addOrEditTrialExternalUser.Email &&
                            t.UserTypeId == addOrEditTrialExternalUser.UserTypeId && t.TrialId == addOrEditTrialExternalUser.TrialId))
                    {
                        //---系统已经存在与列表中填写的邮箱和用户类型相同的账户，请确认。
                        return ResponseOutput.NotOk(_localizer["TrialExternalUser_EmailTypeDuplicate"]);
                    }



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

                    await _trialExternalUseRepository.AddAsync(addEntity);


                    var trialType = await _trialRepository.Where(t => t.Id == addOrEditTrialExternalUser.TrialId).Select(t => t.TrialType).FirstOrDefaultAsync();

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

                    }
                    else
                    {

                        //生成账户  并插入

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

                        if (trialType == TrialType.NoneOfficial)
                        {
                            generateUser.IsTestUser = true;
                        }

                        // 外部人员生成账号 都是外部的
                        generateUser.IsZhiZhun = false;

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


                        generateUser.UserCode = AppSettings.GetCodeStr(generateUser.Code, nameof(UserRole));

                        generateUser.UserName = generateUser.UserCode;


                        generateUser.Password = MD5Helper.Md5(IRCEmailPasswordHelper.GenerateRandomPassword(10));

                        generateUser.Status = UserStateEnum.Disable;

                        var addRole = _mapper.Map<UserRole>(generateUser);
                        addRole.UserTypeEnum = _userTypeRepository.Where(t => t.Id == addOrEditTrialExternalUser.UserTypeId).Select(t => t.UserTypeEnum).First();
                        addRole.UserTypeId = addOrEditTrialExternalUser.UserTypeId;

                        generateUser.UserRoleList = new List<UserRole>() { addRole };

                        var newAddUser = await _identityUserRepository.AddAsync(generateUser);

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


                        existSysUser = newAddUser;

                    }

                    #region 验证用户 能否加入

                    if (trialType == TrialType.OfficialTrial || trialType == TrialType.Training)
                    {

                        if (existSysUser.IsTestUser)
                        {
                            //---正式类型 、培训类型的项目 不允许加入测试用户 
                            throw new BusinessValidationFailedException(_localizer["TrialExternalUser_TestUserNotAllowed"]);

                        }
                    }

                    if (trialType == TrialType.NoneOfficial)
                    {

                        if (existSysUser.IsTestUser == false)
                        {
                            //---测试项目  不允许加入正式用户 
                            throw new BusinessValidationFailedException(_localizer["TrialExternalUser_FormalUserNotAllowed"]);
                        }
                    }

                    #endregion


                    await _trialExternalUseRepository.SaveChangesAsync();


                    //添加的时候就发邮件  现在省略
                    if (addOrEditTrialExternalUser.IsSendEmail)
                    {
                        await SendExternalUserJoinEmail(new TrialExternalUserSendEmail()
                        {
                            BaseUrl = addOrEditTrialExternalUser.BaseUrl,
                            RouteUrl = addOrEditTrialExternalUser.RouteUrl,
                            TrialId = addOrEditTrialExternalUser.TrialId,
                            SendUsers = new List<UserEmail>()
                        {
                            new UserEmail()
                            {
                                Id = addEntity.Id,
                                Email=addEntity.Email,
                                IsSystemUser=addEntity.IsSystemUser,
                                SystemUserId=addEntity.SystemUserId,
                                UserTypeId=addOrEditTrialExternalUser.UserTypeId
                            }
                        }
                        });
                    }


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

            }
            else
            {
                //---人员信息不支持编辑，请删除后重新添加。
                return ResponseOutput.NotOk(_localizer["TrialExternalUser_NotEditable"]);

            }
        }




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

            if (await _trialIdentityUserRepository.AnyAsync(t => t.TrialId == trialExternalUser.TrialId && t.IdentityUserId == trialExternalUser.SystemUserId))
            {
                //---当前用户已参与到项目，不允许删除
                return ResponseOutput.NotOk(_localizer["TrialExternalUser_CannotDelete"]);
            }

            var success = await _trialExternalUseRepository.BatchDeleteNoTrackingAsync(t => t.Id == trialExternalUserId);

            //if (isSystemUser == false)
            //{
            //    await _userRoleRepository.BatchDeleteNoTrackingAsync(t => t.Id == systemUserId);
            //}

            return ResponseOutput.Result(success);
        }


        //New  省掉邀请流程
        [HttpPost]
        //[Authorize(Policy = IRaCISPolicy.PM_APM)]
        [TrialGlobalLimit( "AfterStopCannNotOpt" )]
        [UnitOfWork]
        public async Task<IResponseOutput> SendExternalUserJoinEmail(TrialExternalUserSendEmail sendEmail)
        {
            var trialId = sendEmail.TrialId;

            foreach (var userInfo in sendEmail.SendUsers)
            {
                var userId = userInfo.SystemUserId;
                var userTypeId = userInfo.UserTypeId;

                var findTrialUser = await _trialIdentityUserRepository.FirstOrDefaultAsync(t => t.TrialId == trialId && t.IdentityUserId == userId, true);

                var findUserRoleId = await _identityUserRepository.Where(t => t.Id == userId,true).SelectMany(t => t.UserRoleList).Where(t => t.UserTypeId == userTypeId).Select(t => t.Id).FirstOrDefaultAsync();

                if (findTrialUser == null || findUserRoleId==Guid.Empty)
                {
                    return ResponseOutput.NotOk("database dirty data ");
                }
                else
                {
                    var findTrialUserRole = await _trialUserRoleRepository.FirstOrDefaultAsync(t => t.TrialId == trialId && t.UserRole.IdentityUserId == userId && t.UserRole.UserTypeId == userTypeId, true);

                    if (findTrialUserRole==null)
                    {

                        await _trialUserRoleRepository.AddAsync(new TrialUserRole() { TrialId = trialId,  TrialUserId=findTrialUser.Id, UserId = findUserRoleId, JoinTime = DateTime.Now });

                        await _userRoleRepository.BatchUpdateNoTrackingAsync(t => t.IdentityUserId == userId, u => new UserRole() { Status = UserStateEnum.Enable });

                        await _trialExternalUseRepository.BatchUpdateNoTrackingAsync(t => t.Id == userInfo.Id, u => new TrialExternalUser() { IsJoin = true });


                        await _userRoleRepository.SaveChangesAsync();
                    }
                }

                //判断TrialUser中是否存在  不存在就插入  注意退出了，也不能再加进来
                

                await _mailVerificationService.ExternalUserJoinEmail(trialId, userId,userTypeId, sendEmail.BaseUrl, sendEmail.RouteUrl);

            }

            return ResponseOutput.Ok();

        }






    }
}