using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

using Abp.Dependency;
using Abp.Domain.Repositories;
using Abp.Runtime.Caching;

using IwbZero.Authorization.Base.Permissions;
using IwbZero.Runtime.Caching;
using IwbZero.Runtime.Session;

namespace IwbZero.Authorization.Permissions
{
    public class DataPermissionManager : ISingletonDependency
    {
        public DataPermissionManager(IRepository<DataPermission, long> repository, IIwbSession abpSession, ICacheManager cacheManager)
        {
            Repository = repository;
            AbpSession = abpSession;
            CacheManager = cacheManager;
        }

        protected IRepository<DataPermission, long> Repository { get; }
        protected IIwbSession AbpSession { get; }
        protected ICacheManager CacheManager { get; }

        public virtual async Task AuthDataPermission(DataPermissionAuthDto input)
        {
            foreach (var type in input.OperTypes)
            {
                if (input.UserIds != null && input.UserIds.Any())
                {
                    var entities = await Repository.GetAllListAsync(a =>
                        a.Name == input.PermissionName && a.Access == type && a.AccessValue == input.Key && a.Master == 1);
                    foreach (var id in input.UserIds)
                    {
                        var entity = entities.FirstOrDefault(a => a.MasterValue == id);
                        if (entity == null)
                        {
                            await Repository.InsertAsync(new DataPermission()
                            {
                                Name = input.PermissionName,
                                Master = 1,
                                MasterValue = id,
                                Access = type,
                                AccessValue = input.Key,
                                IsGranted = true
                            });
                        }
                        else
                        {
                            if (!entity.IsGranted)
                            {
                                entity.IsGranted = true;
                                await Repository.UpdateAsync(entity);
                            }
                            entities.Remove(entity);
                        }
                        var cacheKey = $"Data-{id}@{AbpSession.TenantId ?? 0}";
                        await CacheManager.GetUserPermissionCache().RemoveAsync(cacheKey);
                    }
                    if (entities.Any())
                    {
                        foreach (var entity in entities)
                        {
                            await Repository.DeleteAsync(entity);
                        }
                    }
                }

                if (input.RoleIds != null && input.RoleIds.Any())
                {
                    var entities = await Repository.GetAllListAsync(a =>
                        a.Name == input.PermissionName && a.Access == type && a.AccessValue == input.Key && a.Master == 2);
                    foreach (var id in input.RoleIds)
                    {
                        var cacheKey = $"Data-{id}@{AbpSession.TenantId ?? 0}";
                        await CacheManager.GetRolePermissionCache().RemoveAsync(cacheKey);
                        var entity = entities.FirstOrDefault(a => a.MasterValue == id);
                        if (entity == null)
                        {
                            await Repository.InsertAsync(new DataPermission()
                            {
                                Name = input.PermissionName,
                                Master = 2,
                                MasterValue = id,
                                Access = type,
                                AccessValue = input.Key,
                                IsGranted = true
                            });
                        }
                        else
                        {
                            if (!entity.IsGranted)
                            {
                                entity.IsGranted = true;
                                await Repository.UpdateAsync(entity);
                            }
                            entities.Remove(entity);
                        }
                    }
                    if (entities.Any())
                    {
                        foreach (var entity in entities)
                        {
                            await Repository.DeleteAsync(entity);
                        }
                    }
                }
            }
        }

        public virtual async Task AuthUserDataPermission(string permissionName, string key, List<int> operTypes, List<string> userIds)
        {
            foreach (var type in operTypes)
            {
                var entities = await Repository.GetAllListAsync(a =>
                     a.Name == permissionName && a.Access == type && a.AccessValue == key && a.Master == 1);
                foreach (var id in userIds)
                {
                    var entity = entities.FirstOrDefault(a => a.MasterValue == id);
                    if (entity == null)
                    {
                        await Repository.InsertAsync(new DataPermission()
                        {
                            Name = permissionName,
                            Master = 1,
                            MasterValue = id,
                            Access = type,
                            AccessValue = key,
                            IsGranted = true
                        });
                    }
                    else
                    {
                        if (!entity.IsGranted)
                        {
                            entity.IsGranted = true;
                            await Repository.UpdateAsync(entity);
                        }
                        entities.Remove(entity);
                    }
                }
                if (entities.Any())
                {
                    foreach (var entity in entities)
                    {
                        await Repository.DeleteAsync(entity);
                    }
                }
            }
        }

        public virtual async Task AuthRoleDataPermission(string permissionName, string key, List<int> operTypes, List<string> roleIds)
        {
            foreach (var type in operTypes)
            {
                var entities = await Repository.GetAllListAsync(a =>
                     a.Name == permissionName && a.Access == type && a.AccessValue == key && a.Master == 2);
                foreach (var id in roleIds)
                {
                    var entity = entities.FirstOrDefault(a => a.MasterValue == id);
                    if (entity == null)
                    {
                        await Repository.InsertAsync(new DataPermission()
                        {
                            Name = permissionName,
                            Master = 2,
                            MasterValue = id,
                            Access = type,
                            AccessValue = key,
                            IsGranted = true
                        });
                    }
                    else
                    {
                        if (!entity.IsGranted)
                        {
                            entity.IsGranted = true;
                            await Repository.UpdateAsync(entity);
                        }
                        entities.Remove(entity);
                    }
                }
                if (entities.Any())
                {
                    foreach (var entity in entities)
                    {
                        await Repository.DeleteAsync(entity);
                    }
                }
            }
        }
    }
}