using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using AsbCloudApp.Data;
using AsbCloudDb.Model;
using AsbCloudInfrastructure.Services.Cache;
using Mapster;

namespace AsbCloudInfrastructure.Services
{
    public class UserRoleService : CrudServiceBase<UserRoleDto, UserRole>
    {
        private readonly CacheTable<UserRole> cacheUserRoles;
        private readonly CacheTable<PermissionInfo> cachePermissionsInfo;
        private readonly CacheTable<Permission> cachePermissions;
        private int counter = 0;

        public UserRoleService(IAsbCloudDbContext context, CacheDb cacheDb) : base(context)
        {
            cacheUserRoles = cacheDb.GetCachedTable<UserRole>((AsbCloudDbContext)context);
            cachePermissionsInfo = cacheDb.GetCachedTable<PermissionInfo>((AsbCloudDbContext)context);
            cachePermissions = 
                cacheDb.GetCachedTable<Permission>((AsbCloudDbContext)context);
        }

        public override async Task<PaginationContainer<UserRoleDto>> GetPageAsync(int skip = 0, 
            int take = 32, CancellationToken token = default)
        {
            var rolesDtos = await base.GetPageAsync(skip, take,token);

            rolesDtos.Items = rolesDtos.Items.Select(FillUserRoleWithPermissions).ToList();

            return rolesDtos;
        }

        public override async Task<UserRoleDto> GetAsync(int id, CancellationToken token = default)
        {
            var roleDto = await base.GetAsync(id,token);

            return roleDto is null 
                ? null 
                : FillUserRoleWithPermissions(roleDto);
        }

        public override async Task<int> UpdateAsync(int id, UserRoleDto item, CancellationToken token = default)
        {
            foreach (var p in item.Permissions)
                p.IdUserRole = item.Id;
            
            var result = await base.UpdateAsync(id, item, token);

            await cachePermissions.RemoveAsync(r => r.IdUserRole == item.Id, token)
                .ConfigureAwait(false);

            var newPermissions = item.Permissions.Adapt<Permission>();
            
            await cachePermissions.InsertAsync(newPermissions, token);
        
            return result;
        }

        private UserRoleDto FillUserRoleWithPermissions(UserRoleDto roleDto)
        {
            roleDto.Permissions = cachePermissions.Where(c =>
                c.IdUserRole == roleDto.Id).Adapt<PermissionDto>();

            return roleDto;
        }

        // private IEnumerable<int> GetAncestorsPermissionIds(int idRole, IEnumerable<int> currentPermissionsIds, 
        //     int? idParent, ref int counter)
        // {
        //     if (idParent == default) 
        //         return currentPermissionsIds;
        //
        //     if (counter > 10)
        //     {
        //         Trace.WriteLine($"User role with id: {idRole} has more than 10 nested parents");
        //         return currentPermissionsIds;
        //     }
        //
        //     var parentRole = cacheUserRoles.FirstOrDefault(r => r.Id == idParent)
        //         .Adapt<UserRoleDto>();
        //     var parentRolePermissionsIds = cachePermissions.Where(p =>
        //         p.IdUserRole == parentRole.Id).Select(perm => perm.IdPermission);
        //     var resultPermissions = currentPermissionsIds.Union(parentRolePermissionsIds);
        //
        //     counter++;
        //
        //     return GetAncestorsPermissionIds(parentRole.Id, resultPermissions, 
        //         parentRole.IdParent, ref counter);
        // }
    }
}