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

using Abp.Dependency;
using Abp.Domain.Repositories;

using IwbZero.Authorization.Base.Permissions;
using IwbZero.Authorization.Base.Roles;
using IwbZero.Authorization.Base.Users;
using IwbZero.Authorization.Users;

using Microsoft.AspNet.Identity;

namespace IwbZero.Authorization.Roles
{
    /// <summary>
    /// Implements 'Role Store' of ASP.NET Identity Framework.
    /// </summary>
    public abstract class IwbRoleStore<TRole, TUser> :
        IQueryableRoleStore<TRole, int>,
        IRolePermissionStore<TRole>,
        ITransientDependency

        where TRole : IwbSysRole<TUser>, new()
        where TUser : IwbSysUser<TUser>
    {
        private readonly IRepository<TRole> _roleRepository;
        private readonly IRepository<UserRole, long> _userRoleRepository;
        private readonly IRepository<PermissionSetting, long> _permissionSettingRepository;

        /// <summary>
        /// Constructor.
        /// </summary>
        protected IwbRoleStore(
            IRepository<TRole> roleRepository,
            IRepository<UserRole, long> userRoleRepository,
            IRepository<PermissionSetting, long> permissionSettingRepository)
        {
            _roleRepository = roleRepository;
            _userRoleRepository = userRoleRepository;
            _permissionSettingRepository = permissionSettingRepository;
        }

        public virtual IQueryable<TRole> Roles => _roleRepository.GetAll();

        public virtual async Task CreateAsync(TRole role)
        {
            await _roleRepository.InsertAsync(role);
        }

        public virtual async Task UpdateAsync(TRole role)
        {
            await _roleRepository.UpdateAsync(role);
        }

        public virtual async Task DeleteAsync(TRole role)
        {
            await _userRoleRepository.DeleteAsync(ur => ur.RoleId == role.Id);
            await _roleRepository.DeleteAsync(role);
        }

        public virtual async Task<TRole> FindByIdAsync(int roleId)
        {
            return await _roleRepository.FirstOrDefaultAsync(a => a.Id == roleId);
        }

        public virtual async Task<TRole> FindByNameAsync(string roleName)
        {
            var normalizedName = NormalizeKey(roleName);

            return await _roleRepository.FirstOrDefaultAsync(
                role => role.NormalizedName == normalizedName
                );
        }

        public virtual async Task<TRole> FindByDisplayNameAsync(string displayName)
        {
            return await _roleRepository.FirstOrDefaultAsync(
                role => role.DisplayName == displayName
                );
        }

        public virtual async Task AddPermissionAsync(TRole role, PermissionGrantInfo permissionGrant)
        {
            if (await HasPermissionAsync(role.Id, permissionGrant))
            {
                return;
            }

            await _permissionSettingRepository.InsertAsync(new PermissionSetting
            {
                TenantId = role.TenantId,
                Master = 1,
                MasterValue = role.Id + "",
                Name = permissionGrant.Name,
                IsGranted = permissionGrant.IsGranted
            });
        }

        /// <inheritdoc/>
        public virtual async Task RemovePermissionAsync(TRole role, PermissionGrantInfo permissionGrant)
        {
            await _permissionSettingRepository.DeleteAsync(
                a => a.MasterValue == role.Id + "" && a.Master == 1 &&
                                     a.Name == permissionGrant.Name &&
                                     a.IsGranted == permissionGrant.IsGranted
                );
        }

        /// <inheritdoc/>
        public virtual Task<IList<PermissionGrantInfo>> GetPermissionsAsync(TRole role)
        {
            return GetPermissionsAsync(role.Id);
        }

        public async Task<IList<PermissionGrantInfo>> GetPermissionsAsync(int roleId)
        {
            return (await _permissionSettingRepository.GetAllListAsync(p => p.Master == 1 && p.MasterValue == roleId + ""))
                .Select(p => new PermissionGrantInfo(p.Name, p.Access, p.AccessValue, p.IsGranted))
                .ToList();
        }

        /// <inheritdoc/>
        public virtual async Task<bool> HasPermissionAsync(int roleId, PermissionGrantInfo permissionGrant)
        {
            return await _permissionSettingRepository.FirstOrDefaultAsync(
                p => p.Master == 1 && p.MasterValue == roleId + "" &&
                     p.Name == permissionGrant.Name &&
                     p.IsGranted == permissionGrant.IsGranted
                ) != null;
        }

        /// <inheritdoc/>
        public virtual async Task RemoveAllPermissionSettingsAsync(TRole role)
        {
            await _permissionSettingRepository.DeleteAsync(s => s.Master == 1 && s.MasterValue == role.Id + "");
        }

        protected virtual string NormalizeKey(string key)
        {
            return key.ToUpperInvariant();
        }

        public virtual void Dispose()
        {
            //No need to dispose since using IOC.
        }
    }
}