using Abp.Application.Services.Dto;
using Abp.Auditing;
using Abp.Authorization;
using Abp.Domain.Repositories;
using Abp.Linq.Extensions;
using Abp.Runtime.Caching;

using VberZero.AppService.AuditLogs.Dto;
using VberZero.AppService.Base;
using VberZero.AppService.Base.Dto;
using VberZero.Auditing;
using VberZero.BaseSystem;
using VberZero.BaseSystem.Users;
using VberZero.Tools.Lambda;
using VberZero.Tools.StringModel;

namespace VberZero.AppService.AuditLogs
{
    [AbpAuthorize, AuditLog("系统日志", "日志")]
    public class AuditLogAppServiceBase : VzCrudAppServiceBase<AuditLog, SysLogDto, long, VzPagedRequestDto>, IAuditLogsAppServiceBase
    {
        public AuditLogAppServiceBase(ICacheManager cacheManager, IRepository<AuditLog, long> repository, IRepository<User, long> userRepository, IRepository<UserLoginAttempt, long> userLoginRepository) : base(repository)
        {
            UserRepository = userRepository;
            UserLoginRepository = userLoginRepository;
            CacheManager = cacheManager;
        }

        protected IRepository<User, long> UserRepository { get; }
        protected IRepository<UserLoginAttempt, long> UserLoginRepository { get; }

        /// <summary>
        /// 登录日志
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<PagedResultDto<UserLoginDto>> GetAllLogin(VzPagedRequestDto input)
        {
            CheckGetAllPermission();

            var q1 = UserLoginRepository.GetAll();
            var query = from l in q1
                        join u in UserRepository.GetAll() on l.UserId equals u.Id into lu
                        from a in lu.DefaultIfEmpty()
                        select new UserLoginDto
                        {
                            Id = l.Id,
                            UserName = a.Surname + a.Name,
                            UserId = l.UserId,
                            TenantId = l.TenantId,
                            TenancyName = l.TenancyName,
                            UserNameOrEmailOrPhone = l.UserNameOrEmailOrPhone,
                            ClientName = l.ClientName,
                            ClientIpAddress = l.ClientIpAddress,
                            CreationTime = l.CreationTime,
                            BrowserInfo = l.BrowserInfo,
                            Result = l.Result,
                        };

            query = query.WhereIf(input.KeyWords.NotEmpty(),
                a => a.UserName.Contains(input.KeyWords) || a.UserNameOrEmailOrPhone.Contains(input.KeyWords) ||
                     a.ClientName.Contains(input.KeyWords) ||
                     a.ClientIpAddress.Contains(input.KeyWords) ||
                     a.BrowserInfo.Contains(input.KeyWords));
            if (input.SearchList is { Count: > 0 })
            {
                List<LambdaObject> objList = new List<LambdaObject>();
                foreach (var o in input.SearchList)
                {
                    if (o.KeyWords.Empty())
                        continue;
                    object keyWords = o.KeyWords;
                    objList.Add(new LambdaObject
                    {
                        FieldType = (LambdaFieldType)o.FieldType,
                        FieldName = o.KeyField,
                        FieldValue = keyWords,
                        ExpType = (LambdaExpType)o.ExpType
                    });
                }
                var exp = objList.GetExp<UserLoginDto>();
                query = query.Where(exp);
            }
            var totalCount = await AsyncQueryableExecuter.CountAsync(query);

            query = query.OrderByDescending(a => a.CreationTime);
            query = ApplyPaging(query, input);
            var entities = await AsyncQueryableExecuter.ToListAsync(query);
            var dtos = new PagedResultDto<UserLoginDto>(totalCount, entities.Select(MapToUserLoginDto).ToList());
            return dtos;
        }

        [DisableAuditing]
        public override async Task<PagedResultDto<SysLogDto>> GetAll(VzPagedRequestDto input)
        {
            CheckGetAllPermission();

            var q1 = CreateFilteredQuery(input).Where(a => a.LogType != 0);
            var query = from l in q1
                        join u in UserRepository.GetAll() on l.UserId equals u.Id into lu
                        from a in lu.DefaultIfEmpty()
                        select new SysLogDto
                        {
                            Id = l.Id,
                            UserName = a.Surname + a.Name,
                            ExecutionTime = l.ExecutionTime,
                            ExecutionDuration = l.ExecutionDuration,
                            MethodName = l.MethodName,
                            ServiceName = l.ServiceName,
                            Parameters = l.Parameters,
                            UserId = l.UserId,
                            ClientName = l.ClientName,
                            ClientIpAddress = l.ClientIpAddress,
                            BrowserInfo = l.BrowserInfo,
                        };
            query = query.WhereIf(input.KeyWords.NotEmpty(),
                a => a.UserName.Contains(input.KeyWords) || a.ServiceName.Contains(input.KeyWords) || a.MethodName.Contains(input.KeyWords) ||
                     a.ClientName.Contains(input.KeyWords) ||
                     a.ClientIpAddress.Contains(input.KeyWords) ||
                     a.BrowserInfo.Contains(input.KeyWords));
            if (input.SearchList is { Count: > 0 })
            {
                List<LambdaObject> objList = new List<LambdaObject>();
                foreach (var o in input.SearchList)
                {
                    if (o.KeyWords.Empty())
                        continue;
                    object keyWords = o.KeyWords;
                    objList.Add(new LambdaObject
                    {
                        FieldType = (LambdaFieldType)o.FieldType,
                        FieldName = o.KeyField,
                        FieldValue = keyWords,
                        ExpType = (LambdaExpType)o.ExpType
                    });
                }
                var exp = objList.GetExp<SysLogDto>();
                query = query.Where(exp);
            }
            var totalCount = await AsyncQueryableExecuter.CountAsync(query);

            query = query.OrderByDescending(a => a.Id);
            query = ApplyPaging(query, input);
            var entities = await AsyncQueryableExecuter.ToListAsync(query);
            var dtos = new PagedResultDto<SysLogDto>(totalCount, entities);
            return dtos;
        }

        protected override SysLogDto MapToEntityDto(AuditLog entity)
        {
            var dto = base.MapToEntityDto(entity);
            if (dto.UserId.HasValue)
            {
                dto.UserName = CacheManager.GetCache<string, User>(VzConsts.CacheSystemUser).Get($"{dto.UserId}",
                                   () => UserRepository.FirstOrDefault(a => a.Id == dto.UserId))?.FullName ?? "";
            }
            else
            {
                dto.UserName = "";
            }

            return dto;
        }

        protected UserLoginDto MapToUserLoginDto(UserLoginDto dto)
        {
            //var dto = ObjectMapper.Map<UserLoginDto>(entity);
            //if (dto.UserId.HasValue)
            //{
            //    dto.UserName = CacheManager.GetCache<string, User>(VzConsts.CacheSystemUser).Get($"{dto.UserId}",
            //                       () => UserRepository.FirstOrDefault(a => a.Id == dto.UserId))?.FullName ?? "";
            //}
            //else
            //{
            //    dto.UserName = "";
            //}
            dto.LoginResult = dto.Result.ToString();
            return dto;
        }
    }
}