using System;
using System.Collections.Generic;
using System.Data;
using System.Threading.Tasks;
using Znyc.Admin.Commons.Const;
using Znyc.Admin.Commons.Encrypt;
using Znyc.Admin.Commons.Enums;
using Znyc.Admin.Commons.Mapping;
using Znyc.Admin.Commons.Pages;
using Znyc.Admin.Commons.Services;
using Znyc.Admin.Security.Dtos;
using Znyc.Admin.Security.Entitys;
using Znyc.Admin.Security.IRepositories;
using Znyc.Admin.Security.IServices;

namespace Znyc.Admin.Security.Services
{
    /// <summary>
    ///
    /// </summary>
    public class AdminUserService : BaseService<AdminUser, AdminUserOutputDto, long>, IAdminUserService
    {
        private readonly IAdminUserRepository _adminUserRepository;
        private readonly IAdminUserLogOnRepository _adminUserLogOnRepository;
        private readonly IRoleService _roleService;
        private readonly IOrganizeService _organizeService;

        /// <summary>
        ///
        /// </summary>
        /// <param name="repository"></param>
        /// <param name="userLogOnRepository"></param>
        /// <param name="logService"></param>
        /// <param name="roleService"></param>
        /// <param name="organizeService"></param>
        public AdminUserService(IAdminUserRepository repository, IAdminUserLogOnRepository adminUserLogOnRepository,
             IRoleService roleService, IOrganizeService organizeService) : base(repository)
        {
            _adminUserRepository = repository;
            _roleService = roleService;
            _organizeService = organizeService;
            _adminUserLogOnRepository = adminUserLogOnRepository;
        }

        /// <summary>
        /// 用户登陆验证。
        /// </summary>
        /// <param name="userName">用户名</param>
        /// <param name="password">密码（第一次md5加密后）</param>
        /// <returns>验证成功返回用户实体，验证失败返回null|提示消息</returns>
        public async Task<Tuple<AdminUser, string>> Validate(string userName, string password)
        {
            AdminUser userEntity = await _adminUserRepository.GetUserByLogin(userName);

            if (userEntity == null)
            {
                return new Tuple<AdminUser, string>(null, ReturnConst.User_Not_Exist);
            }

            if (userEntity.Status == -1)
            {
                return new Tuple<AdminUser, string>(null,ReturnConst.User_Disable);
            }

            AdminUserLogOn userSinginEntity = _adminUserLogOnRepository.GetByUserId(userEntity.Id);
            string inputPassword = MD5Util
                .GetMD5_32(DEncrypt.Encrypt(MD5Util.GetMD5_32(password).ToLower(), userSinginEntity.AdminUserSecretkey)
                    .ToLower()).ToLower();

            if (inputPassword != userSinginEntity.AdminUserPassword)
            {
                return new Tuple<AdminUser, string>(null, ReturnConst.Password_Error);
            }
            else
            {
                AdminUserLogOn userLogOn = _adminUserLogOnRepository.GetWhere("AdminUserId='" + userEntity.Id + "'");
                //    if (userLogOn.AllowEndTime < DateTime.Now)
                //        return new Tuple<AdminUser, string>(null, "您的账号已过期，请联系系统管理员！");
                //    if (userLogOn.LockEndDate > DateTime.Now)
                //    {
                //        var dateStr = userLogOn.LockEndDate.ToEasyStringDQ();
                //        return new Tuple<AdminUser, string>(null, "当前被锁定，请" + dateStr + "登录");
                //    }

                //    if (userLogOn.FirstVisitTime == null)
                //        userLogOn.FirstVisitTime = userLogOn.PreviousVisitTime = DateTime.Now;
                //    else
                //        userLogOn.PreviousVisitTime = DateTime.Now;
                userLogOn.LogOnCount++;
                userLogOn.LastVisitTime = DateTime.Now;
                userLogOn.UserOnLine = true;
                await _adminUserLogOnRepository.UpdateAsync(userLogOn, userLogOn.Id);
                return new Tuple<AdminUser, string>(userEntity, "");
            }
        }

        /// <summary>
        /// 用户登陆验证。
        /// </summary>
        /// <param name="userName">用户名</param>
        /// <param name="password">密码（第一次md5加密后）</param>
        /// <param name="userType">用户类型</param>
        /// <returns>验证成功返回用户实体，验证失败返回null|提示消息</returns>
        public async Task<Tuple<AdminUser, string>> Validate(string userName, string password, UserType userType)
        {
            AdminUser userEntity = await _adminUserRepository.GetUserByLogin(userName);

            if (userEntity == null)
            {
                return new Tuple<AdminUser, string>(null, ReturnConst.User_Not_Exist);
            }

            if (userEntity.Status == -1)
            {
                return new Tuple<AdminUser, string>(null,ReturnConst.User_Disable);
            }

            AdminUserLogOn userSinginEntity = _adminUserLogOnRepository.GetByUserId(userEntity.Id);

            string inputPassword = MD5Util
                .GetMD5_32(DEncrypt.Encrypt(MD5Util.GetMD5_32(password).ToLower(), userSinginEntity.AdminUserSecretkey)
                    .ToLower()).ToLower();

            if (inputPassword != userSinginEntity.AdminUserPassword)
            {
                return new Tuple<AdminUser, string>(null,ReturnConst.Password_Error);
            }
            else
            {
                AdminUserLogOn userLogOn = _adminUserLogOnRepository.GetWhere("UserId='" + userEntity.Id + "'");
                //if (userLogOn.AllowEndTime < DateTime.Now)
                //    return new Tuple<AdminUser, string>(null, "您的账号已过期，请联系系统管理员！");
                //if (userLogOn.LockEndDate > DateTime.Now)
                //{
                //    var dateStr = userLogOn.LockEndDate.ToEasyStringDQ();
                //    return new Tuple<AdminUser, string>(null, "当前被锁定，请" + dateStr + "登录");
                //}

                //if (userLogOn.FirstVisitTime == null)
                //    userLogOn.FirstVisitTime = userLogOn.PreviousVisitTime = DateTime.Now;
                //else
                //    userLogOn.PreviousVisitTime = DateTime.Now;
                userLogOn.LogOnCount++;
                userLogOn.LastVisitTime = DateTime.Now;
                userLogOn.UserOnLine = true;
                await _adminUserLogOnRepository.UpdateAsync(userLogOn, userLogOn.Id);
                return new Tuple<AdminUser, string>(userEntity, "");
            }
        }

        /// <summary>
        /// 根据用户账号查询用户信息
        /// </summary>
        /// <param name="userName"></param>
        /// <returns></returns>
        public async Task<AdminUser> GetByUserName(string userName)
        {
            return await _adminUserRepository.GetByUserName(userName);
        }

        /// <summary>
        /// 根据用户手机号码查询用户信息
        /// </summary>
        /// <param name="mobilephone">手机号码</param>
        /// <returns></returns>
        public async Task<AdminUser> GetUserByMobilePhone(string mobilephone)
        {
            return await _adminUserRepository.GetUserByMobilePhone(mobilephone);
        }

        /// <summary>
        /// 根据Account、手机号查询用户信息
        /// </summary>
        /// <param name="account">登录账号</param>
        /// <returns></returns>
        public async Task<AdminUser> GetUserByLogin(string account)
        {
            return await _adminUserRepository.GetUserByLogin(account);
        }

        /// <summary>
        /// 根据第三方OpenId查询用户信息
        /// </summary>
        /// <param name="openIdType">第三方类型</param>
        /// <param name="openId">OpenId值</param>
        /// <returns></returns>
        public AdminUser GetUserByOpenId(string openIdType, string openId)
        {
            return _adminUserRepository.GetUserByOpenId(openIdType, openId);
        }

        /// <summary>
        /// 根据userId查询用户信息
        /// </summary>
        /// <param name="openIdType">第三方类型</param>
        /// <param name="userId">userId</param>
        /// <returns></returns>
        public UserOpenIds GetUserOpenIdByuserId(string openIdType, long userId)
        {
            return _adminUserRepository.GetUserOpenIdByuserId(openIdType, userId);
        }

        /// <summary>
        /// 更新用户信息,第三方平台
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="userLogOnEntity"></param>
        /// <param name="userOpenIds"></param>
        /// <param name="trans"></param>
        public bool UpdateUserByOpenId(AdminUser entity, AdminUserLogOn userLogOnEntity, UserOpenIds userOpenIds,
            IDbTransaction trans = null)
        {
            return _adminUserRepository.UpdateUserByOpenId(entity, userLogOnEntity, userOpenIds, trans);
        }

        /// <summary>
        /// 根据微信UnionId查询用户信息
        /// </summary>
        /// <param name="unionId">UnionId值</param>
        /// <returns></returns>
        public AdminUser GetUserByUnionId(string unionId)
        {
            return _adminUserRepository.GetUserByUnionId(unionId);
        }

        /// <summary>
        /// 更新用户
        /// </summary>
        /// <param name="userInPut"></param>
        /// <returns></returns>
        //public bool UpdateUserByOpenId(AdminUserInputDto userInPut)
        //{
        //    var user = GetUserByOpenId(userInPut.OpenIdType, userInPut.OpenId);
        //    user.HeadIcon = userInPut.HeadIcon;
        //    user.UserName = userInPut.UserName;
        //    user.Gender = userInPut.Gender;
        //    return _adminUserRepository.Update(user, user.Id);
        //}

        /// <summary>
        /// 根据条件查询数据库,并返回对象集合(用于分页数据显示)
        /// </summary>
        /// <param name="search">查询的条件</param>
        /// <returns>指定对象的集合</returns>
        public async Task<PageResult<AdminUserOutputDto>> FindWithPagerSearchAsync(SearchUserModel search)
        {
            bool order = search.Order == "asc" ? false : true;
            string where = GetDataPrivilege(false);

            if (!string.IsNullOrEmpty(search.Keywords))
            {
                @where += string.Format(
                    " and (UserName like '%{0}%' or Account like '%{0}%'  or MobilePhone like '%{0}%')",
                    search.Keywords);
            }



            if (!string.IsNullOrEmpty(search.StartTime))
            {
                @where += " and CreatedTime >='" + search.StartTime + " 00:00:00'";
            }

            if (!string.IsNullOrEmpty(search.EndTime))
            {
                @where += " and CreatedTime <='" + search.EndTime + " 23:59:59'";
            }

            PagerInfo pagerInfo = new PagerInfo
            {
                CurrenetPageIndex = search.CurrenetPageIndex,
                PageSize = search.PageSize
            };
            List<AdminUser> list = await repository.FindWithPagerAsync(where, pagerInfo, search.Sort, order);
            List<AdminUserOutputDto> resultList = list.MapTo<AdminUserOutputDto>();
            List<AdminUserOutputDto> listResult = new List<AdminUserOutputDto>();
            foreach (AdminUserOutputDto item in resultList)
            {
                if (!string.IsNullOrEmpty(item.OrganizeId.ToString()))
                {
                    item.OrganizeName = _organizeService.Get(item.OrganizeId)?.FullName;
                }

                if (!string.IsNullOrEmpty(item.RoleId.ToString().ToString()))
                {
                    item.RoleName = _roleService.GetRoleNameStr(item.RoleId.ToString());
                }

                if (!string.IsNullOrEmpty(item.DepartmentId.ToString()))
                {
                    item.DepartmentName = _organizeService.Get(item.DepartmentId).FullName;
                }
                //if (!string.IsNullOrEmpty(item.DutyId))
                //{
                //    item.DutyName = _roleService.Get(item.DutyId).FullName;
                //}
                listResult.Add(item);
            }

            PageResult<AdminUserOutputDto> pageResult = new PageResult<AdminUserOutputDto>
            {
                CurrentPage = pagerInfo.CurrenetPageIndex,
                Items = listResult,
                ItemsPerPage = pagerInfo.PageSize,
                TotalItems = pagerInfo.RecordCount
            };
            return pageResult;
        }

        public bool CreateUserByWxOpenId(UserInputDto userInPut)
        {
            throw new NotImplementedException();
        }

        public bool UpdateUserByOpenId(UserInputDto userInPut)
        {
            throw new NotImplementedException();
        }
    }
}