using Mapster;
using Znyc.CloudCar.Auth.HttpContextUser;
using Znyc.CloudCar.Configuration;
using Znyc.CloudCar.IRepository.User;
using Znyc.CloudCar.IServices.CaChe;
using Znyc.CloudCar.IServices.User;
using Znyc.CloudCar.Model.Dtos.User;
using Znyc.CloudCar.Model.Entities;
using Znyc.CloudCar.Model.ViewModels.ReportsCallBack;
using Znyc.CloudCar.Utility.Extensions;

namespace Znyc.CloudCar.Services.User
{
    public class UserService : IUserService
    {
        private readonly IUserRepository _userRepository;
        private readonly ICacheService _cacheService;
        private readonly IHttpContextUser _httpContextUser;
        private readonly IUserCardRepository _userCardRepository;

        public UserService(
            IUserRepository userRepository,
            ICacheService cacheService,
            IHttpContextUser httpContextUser,
            IUserCardRepository userCardRepository)
        {
            _userRepository = userRepository;
            _cacheService = cacheService;
            _httpContextUser = httpContextUser;
            _userCardRepository = userCardRepository;
        }

        /// <summary>
        ///     新增用户
        /// </summary>
        /// <param name="openId"></param>
        /// <param name="unionId"></param>
        /// <returns></returns>
        public async Task<UserEntity> AddUserAsync(WxUnifyUserAddInput wxUnifyUserAddInput, string openId, string unionId)
        {
            var user = await _userRepository.GetAsync(x => x.OpenId == openId && x.IsDeleted == false);
            if (user == null)
            {
                user = await _userRepository.InsertAsync(new UserEntity
                {
                    UserName = GlobalConstVars.User.Default_UserName,
                    OpenId = openId,
                    AvatarUrl = GlobalConstVars.User.DefaultImagePrefix + GlobalConstVars.User.DefaultAvataUrl,
                    Phone = "",
                    UnionId = unionId,
                    State = (int)GlobalEnumVars.CommonEnum.Normal,
                });
            }
            return user;
        }

        /// <summary>
        ///     根据Id获取用户信息
        /// </summary>
        /// <returns></returns>
        public async Task<UserOutput> GetUserAsync()
        {

            UserOutput userOutput = await _cacheService.GetUserAsync(_httpContextUser.Id);
            if (userOutput.IsNull())
            {
                userOutput = await _userRepository.GetAsync<UserOutput>(_httpContextUser.Id);
                if (userOutput.IsNull())
                {
                    return userOutput;
                }
                userOutput.AvatarUrl = userOutput.AvatarUrl;
                await _cacheService.SetUserAsync(userOutput.Id, userOutput);
            }
            return userOutput;
        }


        public async Task<UserOutput> GetUserByIdAsync(long id)
        {

            UserOutput userOutput = await _cacheService.GetUserAsync(id);
            if (userOutput.IsNull())
            {
                userOutput = await _userRepository.GetAsync<UserOutput>(id);
                if (userOutput.IsNull())
                {
                    return userOutput;
                }
                userOutput.AvatarUrl = userOutput.AvatarUrl;
                await _cacheService.SetUserAsync(userOutput.Id, userOutput);
            }
            return userOutput;
        }


        /// <summary>
        ///     修改用户信息
        /// </summary>
        /// <param name="userUpdateInput"></param>
        /// <returns></returns>
        public async Task<ResponseOutput> UpdateAsync(UserUpdateInput userUpdateInput)
        {
            ResponseOutput response = new ResponseOutput();
            UserEntity entity = await _userRepository.GetAsync(_httpContextUser.Id);
            if (entity.IsNull())
            {
                response.Successed = false;
                response.Msg = "用户不存在!";
                return response;
            }
            entity.UserName = userUpdateInput.UserName;
            entity.AvatarUrl = GlobalConstVars.User.DefaultImagePrefix+ userUpdateInput.AvatarUrl.Substring(userUpdateInput.AvatarUrl.LastIndexOf("/") + 1);
            entity.Phone = userUpdateInput.Phone;
            await _userRepository.UpdateAsync(entity);
            await _cacheService.RemoveUserAsync(_httpContextUser.Id);
            var userOutput = entity.Adapt<UserOutput>();
            userOutput.AvatarUrl = userOutput.AvatarUrl;
            var usercar = await _userCardRepository.GetAsync(x => x.UserId == _httpContextUser.Id && x.IsEnabled == true && x.EndTime > DateTime.Now);
            userOutput.CardType = usercar.IsNotNull() ? usercar.CardId : 0;
            response.Successed = true;
            response.Data = userOutput;
            response.Code = 1;
            return response;
        }

        /// <summary>
        /// 获取当前用户信息
        /// </summary>
        /// <returns></returns>
        public async Task<ResponseOutput> GetUserInfoAsync()
        {
            ResponseOutput response = new ResponseOutput();
            UserOutput userOutput = await _cacheService.GetUserAsync(_httpContextUser.Id);
            if (userOutput.IsNull())
            {
                userOutput = await _userRepository.GetAsync<UserOutput>(_httpContextUser.Id);
                if (userOutput.IsNull())
                {
                    response.Successed = false;
                    response.Msg = "当前用户不存在";
                    return response;
                }
                userOutput.AvatarUrl = userOutput.AvatarUrl;
                await _cacheService.SetUserAsync(userOutput.Id, userOutput);
            }
            var usercar = await _userCardRepository.Where(x => x.UserId == _httpContextUser.Id && x.IsEnabled == true && x.EndTime > DateTime.Now).OrderByDescending(x=>x.CardId).FirstAsync();
            userOutput.CardType = usercar.IsNotNull() ? usercar.CardId : 0;
            response.Successed = true;
            response.Data = userOutput;
            response.Code = 1;
            return response;
        }
    }
}