using IRaCIS.Core.Infrastructure.ExpressionExtend;
using IRaCIS.Application.Interfaces;
using IRaCIS.Application.Contracts;
using IRaCIS.Core.Infra.EFCore;
using IRaCIS.Core.Domain.Share;
using IRaCIS.Core.Infrastructure;
using System.Text.RegularExpressions;
using Autofac.Extras.DynamicProxy;
using IRaCIS.Core.API.Utility.AOP;

using Microsoft.AspNetCore.Mvc;
using Panda.DynamicWebApi.Attributes;

namespace IRaCIS.Application.Services
{
    [ApiExplorerSettings(GroupName = "Management")]
    [Intercept(typeof(UserAddAOP))]
    public class UserService : BaseService, IUserService
    {
        private readonly IRepository<User> _userRepository;
        private readonly IMailVerificationService _mailVerificationService;
        private readonly IRepository<VerificationCode> _verificationCodeRepository;
        private readonly IRepository<Doctor> _doctorRepository;
        private readonly IRepository<TrialUser> _userTrialRepository;
        public UserService(IRepository<User> userRepository,

            IMailVerificationService mailVerificationService,
            IRepository<VerificationCode> verificationCodeRepository,
            IRepository<Doctor> doctorRepository,
            IRepository<TrialUser> userTrialRepository

         )
        {
            _userRepository = userRepository;
            _mailVerificationService = mailVerificationService;
            _verificationCodeRepository = verificationCodeRepository;
            _doctorRepository = doctorRepository;
            _userTrialRepository = userTrialRepository;
        }

        /// <summary>发送验证码 邮箱或者手机号 New </summary>

        [HttpGet("{email}")]
        public async Task<IResponseOutput> SendVerificationCode(string email)
        {

            //检查手机或者邮箱是否有效
            if (!Regex.IsMatch(email, @"^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$"))
            {

                return ResponseOutput.NotOk("Please input a legal email");

            }

            ////查找改邮箱或者手机的用户
            //var exist = await _userRepository.AnyAsync(t => t.EMail == email);

            //if (!exist)
            //{
            //    return ResponseOutput.NotOk("No user with this email exists.");

            //}
            //var user = await _userRepository.FirstOrDefaultAsync(t => t.EMail == email);


            //验证码 6位
            int verificationCode = new Random().Next(100000, 1000000);

            await _mailVerificationService.SendMailEditEmail(_userInfo.Id, _userInfo.RealName , email, verificationCode);

            return ResponseOutput.Ok();

        }


        [HttpPut("{newEmail}/{verificationCode}")]
        public async Task<IResponseOutput> SetNewEmail(  string newEmail,string verificationCode)
        {


            var verificationRecord = await _verificationCodeRepository
                .FirstOrDefaultAsync(t => t.UserId == _userInfo.Id && t.Code == verificationCode && t.CodeType == 0);

            //检查数据库是否存在该验证码
            if (verificationRecord == null)
            {

                return ResponseOutput.NotOk("Verification code error");

            }
            else
            {
                //检查验证码是否失效
                if (verificationRecord.ExpirationTime < DateTime.Now)
                {
                    return ResponseOutput.NotOk("The verification code has expired");

                }
                else //验证码正确 并且 没有超时 
                {
                    //更新密码
                    //var pwd = MD5Helper.Md5(newPwd);
                    //var count = _doctorRepository.Update<Doctor>().Where(t => t.Id == doctor.Id).Set(d => d.Password == pwd).ExecuteAffrows();


                    if (await _userRepository.AnyAsync(t =>  (t.EMail == newEmail && t.UserTypeId == _userInfo.UserTypeId && t.Id != _userInfo.Id)))
                    {
                        return ResponseOutput.NotOk("The mailbox  for this user type already exists");
                    }

                    var success = await _userRepository.UpdateFromQueryAsync(t => t.Id == _userInfo.Id, u => new User()
                    {
                        EMail= newEmail
                    });

                    //删除验证码历史记录
                    await _verificationCodeRepository.DeleteFromQueryAsync(t => t.UserId == _userInfo.Id && t.CodeType ==0);

                    return ResponseOutput.Result(success);

                }
            }
        }


        [HttpPut("{newPhone}")]
        public async Task<IResponseOutput> SetNewPhone( string newPhone)
        {


            var success = await _userRepository.UpdateFromQueryAsync(t => t.Id == _userInfo.Id, u => new User()
            {
                Phone = newPhone
            });

            return ResponseOutput.Ok();
        }


        [HttpPut("{newUserName}")]
        public async Task<IResponseOutput> SetNewUserName( string newUserName)
        {

            if (await _userRepository.AnyAsync(t => t.UserName == newUserName && t.Id != _userInfo.Id))
            {
                return ResponseOutput.NotOk("UserId  already exists");
            }
            var success = await _userRepository.UpdateFromQueryAsync(t => t.Id == _userInfo.Id, u => new User()
            {
                UserName = newUserName
            });

            return ResponseOutput.Ok();
        }




     

        /// <summary>
        /// 发送验证码 邮箱或者手机号
        /// </summary>
        /// <param name="emailOrPhone"></param>
        /// <param name="verificationType"></param>
        /// <param name="isReviewer"></param>
        /// <returns></returns>
        [HttpGet("{emailOrPhone}/{verificationType:int}")]
        public async Task<IResponseOutput> SendVerificationCode(string emailOrPhone, VerifyType verificationType, bool isReviewer = false)
        {
            if (string.IsNullOrEmpty(emailOrPhone))
            {
                return ResponseOutput.NotOk(verificationType == VerifyType.Email ? "Please input email" : "Please input phone");

            }
            //防止输入前后有空格
            var emailOrPhoneStr = emailOrPhone.Trim();

            //检查手机或者邮箱是否有效
            if (!Regex.IsMatch(emailOrPhoneStr, @"/^1[34578]\d{9}$/") && !Regex.IsMatch(emailOrPhoneStr, @"^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$"))
            {

                return ResponseOutput.NotOk(verificationType == VerifyType.Email
                    ? "Please input a legal email"
                    : "Please input a legal phone");

            }

            //医生登录
            if (isReviewer)
            {
                var exist = await _doctorRepository.AnyAsync(t => t.EMail == emailOrPhoneStr || t.Phone == emailOrPhoneStr);

                if (!exist)
                {
                    return ResponseOutput.NotOk(verificationType == VerifyType.Email
                        ? "No user with this email exists."
                        : "No user with this phone exists.");

                }

                var user = await _doctorRepository.FirstOrDefaultAsync(t => t.EMail == emailOrPhoneStr || t.Phone == emailOrPhoneStr);
                //邮箱
                if (verificationType == VerifyType.Email)
                {
                    //验证码 6位
                    int verificationCode = new Random().Next(100000, 1000000);

                    await _mailVerificationService.SendMail(user.Id, user.ChineseName, emailOrPhoneStr,
                        verificationCode);
                }
                //手机短信
                else
                {

                }

            }
            else//管理用户登录
            {
                //查找改邮箱或者手机的用户
                var exist = await _userRepository.AnyAsync(t => t.EMail == emailOrPhoneStr || t.Phone == emailOrPhoneStr);

                if (!exist)
                {
                    return ResponseOutput.NotOk(verificationType == VerifyType.Email
                        ? "No user with this email exists."
                        : "No user with this phone exists.");

                }
                var user = await _userRepository.FirstOrDefaultAsync(t => t.EMail == emailOrPhoneStr || t.Phone == emailOrPhoneStr);
                //邮箱
                if (verificationType == VerifyType.Email)
                {
                    //验证码 6位
                    int verificationCode = new Random().Next(100000, 1000000);

                    await _mailVerificationService.SendMail(user.Id, user.LastName + ' ' + user.FirstName, emailOrPhoneStr,
                        verificationCode);
                }
                //手机短信
                else
                {

                }
            }

            return ResponseOutput.Ok();
        }


        /// <summary>
        /// 验证设置新密码
        /// </summary>
        /// <param name="resetPwdModel"></param>
        /// <returns></returns>
        [HttpPost]

        public async Task<IResponseOutput> SetNewPassword(ResetPasswordCommand resetPwdModel)
        {
            if (resetPwdModel.IsReviewer)
            {
                var emailOrPhoneStr = resetPwdModel.EmailOrPhone.Trim();
                var verificationCodeStr = resetPwdModel.VerificationCode.Trim();
                var user = await _doctorRepository.FirstOrDefaultAsync(t => t.EMail == emailOrPhoneStr || t.Phone == emailOrPhoneStr);

                var verificationRecord = await _verificationCodeRepository
                    .FirstOrDefaultAsync(t => t.UserId == user.Id && t.Code == verificationCodeStr && t.CodeType == resetPwdModel.VerificationType);

                //检查数据库是否存在该验证码
                if (verificationRecord == null)
                {

                    return ResponseOutput.NotOk("Verification code error");

                }
                else
                {
                    //检查验证码是否失效
                    if (verificationRecord.ExpirationTime < DateTime.Now)
                    {
                        return ResponseOutput.NotOk("The verification code has expired");

                    }
                    else //验证码正确 并且 没有超时 
                    {
                        //更新密码
                        var success = await _doctorRepository.UpdateFromQueryAsync(t => t.Id == user.Id, u => new Doctor()
                        {
                            Password = resetPwdModel.NewPwd
                        });

                        //删除验证码历史记录
                        await _verificationCodeRepository.DeleteFromQueryAsync(t => t.UserId == user.Id && t.CodeType == resetPwdModel.VerificationType);

                        return ResponseOutput.Result(success);

                    }
                }
            }
            else
            {
                var emailOrPhoneStr = resetPwdModel.EmailOrPhone.Trim();
                var verificationCodeStr = resetPwdModel.VerificationCode.Trim();

                var user = await _userRepository.FirstOrDefaultAsync(t => t.EMail == emailOrPhoneStr || t.Phone == emailOrPhoneStr);


                var verificationRecord = await _verificationCodeRepository
                    .FirstOrDefaultAsync(t => t.UserId == user.Id && t.Code == verificationCodeStr && t.CodeType == resetPwdModel.VerificationType);

                //检查数据库是否存在该验证码
                if (verificationRecord == null)
                {

                    return ResponseOutput.NotOk("Verification code error");

                }
                else
                {
                    //检查验证码是否失效
                    if (verificationRecord.ExpirationTime < DateTime.Now)
                    {
                        return ResponseOutput.NotOk("The verification code has expired");

                    }
                    else //验证码正确 并且 没有超时 
                    {
                        //更新密码
                        //var pwd = MD5Helper.Md5(newPwd);
                        //var count = _doctorRepository.Update<Doctor>().Where(t => t.Id == doctor.Id).Set(d => d.Password == pwd).ExecuteAffrows();

                        var success = await _userRepository.UpdateFromQueryAsync(t => t.Id == user.Id, u => new User()
                        {
                            Password = resetPwdModel.NewPwd,
                            PasswordChanged = true
                        });

                        //删除验证码历史记录
                        await _verificationCodeRepository.DeleteFromQueryAsync(t => t.UserId == user.Id && t.CodeType == resetPwdModel.VerificationType);

                        return ResponseOutput.Result(success);

                    }
                }
            }

        }















        /// <summary>
        /// 获取用户列表
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<PageOutput<UserListDTO>> GetUserList(UserListQueryDTO param)
        {
            var userQueryable = _userRepository.Where(x => x.UserTypeEnum != UserTypeEnum.SuperAdmin)
                  .WhereIf(!string.IsNullOrWhiteSpace(param.UserName), t => t.UserName.Contains(param.UserName) || (t.LastName + ' ' + t.FirstName).Contains(param.UserName))
                  .WhereIf(!string.IsNullOrWhiteSpace(param.Phone), t => t.Phone.Contains(param.Phone))
                  .WhereIf(!string.IsNullOrWhiteSpace(param.OrganizationName), t => t.OrganizationName.Contains(param.OrganizationName))
                  .WhereIf(param.UserType != null, t => t.UserTypeId == param.UserType)
                  .WhereIf(param.UserState != null, t => t.Status == param.UserState)
                  .ProjectTo<UserListDTO>(_mapper.ConfigurationProvider);

            return await userQueryable.ToPagedListAsync(param.PageIndex, param.PageSize, param.SortField == string.Empty ? "UserName" : param.SortField, param.Asc);


        }

        /// <summary>
        /// 根据用户Id获取用户详细信息[New]
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet("{id:guid}")]
        public async Task<UserDetailDTO> GetUser(Guid id)
        {
            var userQuery = _userRepository.Where(t => t.Id == id).ProjectTo<UserDetailDTO>(_mapper.ConfigurationProvider);
            return await (userQuery.FirstOrDefaultAsync()).IfNullThrowException();
        }

        /// <summary>
        /// 添加用户
        /// </summary>
        /// <param name="userAddModel"></param>
        /// <returns></returns>
        public async Task<IResponseOutput<UserAddedReturnDTO>> AddUser(UserCommand userAddModel)
        {
            if (await _userRepository.AnyAsync(t => t.UserName == userAddModel.UserName  ||(t.EMail == userAddModel.EMail && t.UserTypeId == userAddModel.UserTypeId)))
            {
                return ResponseOutput.NotOk(" UserId   or The mailbox  for this user type already exists", new UserAddedReturnDTO());
            }

            var saveItem = _mapper.Map<User>(userAddModel);

            saveItem.Code = await _userRepository.Select(t => t.Code).DefaultIfEmpty().MaxAsync() + 1;

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

            if (saveItem.IsZhiZhun)
            {
                saveItem.OrganizationName = "Zhizhun";
            }

            //验证码 6位
            int verificationCode = new Random().Next(100000, 1000000);

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

            await _userRepository.AddAsync(saveItem);

            var success = await _userRepository.SaveChangesAsync();

            return ResponseOutput.Result(success, new UserAddedReturnDTO { Id = saveItem.Id, UserCode = saveItem.UserCode, VerificationCode = verificationCode });

        }

        /// <summary>
        /// 更新用户
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public async Task<IResponseOutput> UpdateUser(UserCommand model)
        {

            // 判断当前用户名是否已经存在
            if (await _userRepository.AnyAsync(t => (t.UserName == model.UserName && t.Id != model.Id) || (t.EMail == model.EMail && t.UserTypeId==model.UserTypeId && t.Id != model.Id)))
            {
                return ResponseOutput.NotOk("UserId   or The mailbox  for this user type already exists");
            }

            var user = await _userRepository.FirstOrDefaultAsync(t => t.Id == model.Id);

            if (user == null) return Null404NotFound(user);

            _mapper.Map(model, user);

            if (user.IsZhiZhun)
            {
                user.OrganizationName = "Zhizhun";
            }
            var success = await _userRepository.SaveChangesAsync();

            return ResponseOutput.Result(success);

        }

        /// <summary>
        /// 删除用户
        /// </summary>
        /// <param name="userId"></param>
        /// <returns></returns>
        [HttpDelete("{userId:guid}")]
        public async Task<IResponseOutput> DeleteUser(Guid userId)
        {
            if (await _userTrialRepository.AnyAsync(t => t.Id == userId))
            {
                return ResponseOutput.NotOk("This user has participated in the trial and couldn't be deleted");
            }

            var success = await _userRepository.DeleteFromQueryAsync(t => t.Id == userId);

            return ResponseOutput.Result(success);
        }

        /// <summary>
        /// 禁用或者启用账户
        /// </summary>
        /// <param name="userId"></param>
        /// <param name="state"></param>
        /// <returns></returns>

        [HttpPost("{userId:guid}/{state:int}")]
        public async Task<IResponseOutput> UpdateUserState(Guid userId, UserStateEnum state)
        {
            var success = await _userRepository.UpdateFromQueryAsync(u => u.Id == userId, t => new User
            {
                Status = state
            });
            return ResponseOutput.Result(success);
        }

        /// <summary>
        /// 重置密码为 默认密码
        /// </summary>
        /// <param name="userId"></param>
        /// <returns></returns>
        [HttpGet("{userId:guid}")]

        public async Task<IResponseOutput> ResetPassword(Guid userId)
        {
            var success = await _userRepository.UpdateFromQueryAsync(t => t.Id == userId, u => new User()
            {
                Password = MD5Helper.Md5(StaticData.DefaultPassword),
                PasswordChanged = false
            });

            return ResponseOutput.Result(success);
        }

        /// <summary>
        /// 修改密码,当前支持旧密码修改密码，手机及邮箱验证码后续支持[New]
        /// </summary>
        /// <param name="editPwModel"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IResponseOutput> ModifyPassword(EditPasswordCommand editPwModel)
        {


            if( !string.IsNullOrEmpty(editPwModel.NewUserName))
            {
                if (await _userRepository.AnyAsync(t => t.UserName == editPwModel.NewUserName && t.Id != _userInfo.Id))
                {
                    return ResponseOutput.NotOk("UserId  already exists");
                }

                var success = await _userRepository.UpdateFromQueryAsync(t => t.Id == _userInfo.Id, u => new User()
                {
                    UserName = editPwModel.NewUserName,
                });

            }

            //验证旧密码OK
            if (await _userRepository.FirstOrDefaultAsync(t => t.Id == _userInfo.Id && t.Password == editPwModel.OldPassWord) != null)
            {
                var success = await _userRepository.UpdateFromQueryAsync(t => t.Id == _userInfo.Id, u => new User()
                {
                    Password = editPwModel.NewPassWord,
                    IsFirstAdd = false
                });

                return ResponseOutput.Result(success);
            }

            //医生密码
            if (await _doctorRepository.AnyAsync(t => t.Id == _userInfo.Id && t.Password == editPwModel.OldPassWord))
            {
                var success = await _doctorRepository.UpdateFromQueryAsync(t => t.Id == _userInfo.Id, u => new Doctor()
                {
                   
                    Password = editPwModel.NewPassWord
                });

                return ResponseOutput.Result(success);
            }

            return ResponseOutput.NotOk("Old password is wrong.");

        }


        /// <summary>
        /// 用户登陆
        /// </summary>
        /// <param name="userName"></param>
        /// <param name="password"></param>
        /// <returns></returns>
        [NonDynamicMethod]
        public async Task<IResponseOutput<LoginReturnDTO>> Login(string userName, string password)
        {
            var userLoginReturnModel = new LoginReturnDTO();


            var loginUser = await _userRepository.Where(u => u.UserName == userName && u.Password == password).ProjectTo<UserBasicInfo>(_mapper.ConfigurationProvider).FirstOrDefaultAsync();

            if (loginUser == null)
            {
                //此处下面 代码 为了支持医生也能登录 而且前端不加选择到底是管理用户 还是医生用户  奇怪的需求 无法理解

                var loginDoctor = await _doctorRepository.Where(u => u.Phone == userName && u.Password == password).ProjectTo<UserBasicInfo>(_mapper.ConfigurationProvider).FirstOrDefaultAsync();

                if (loginDoctor == null)
                {
                    return ResponseOutput.NotOk("Please check the user name or password.", new LoginReturnDTO());

                }

                userLoginReturnModel.BasicInfo = loginDoctor;

                
                return ResponseOutput.Ok(userLoginReturnModel);

            }

            if (loginUser.Status == 0)
            {
                return ResponseOutput.NotOk("The user has been disabled!", new LoginReturnDTO());
            }

            userLoginReturnModel.BasicInfo = loginUser;

           
            return ResponseOutput.Ok(userLoginReturnModel);

        }



    }
}