using BetaRill.Core.Primitives;
using BetaRill.Domain.DomainModels;
using BetaRill.Domain.DomainModels.Users;
using BetaRill.Infrastructure;
using BetaRill.Infrastructure.Repositories;
using Microsoft.AspNet.Identity;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace BetaRill.Application.Services.Identity
{
    public class IdentityUserStore : IUserStore<IdentityUser, string>, IUserRoleStore<IdentityUser, string>,
                                     IUserClaimStore<IdentityUser, string>, IUserLoginStore<IdentityUser, string>,
                                     IUserPasswordStore<IdentityUser, string>, IUserSecurityStampStore<IdentityUser, string>, IDisposable
    {
        public EntityManager EntityManager { get; private set; }

        public IdentityUserStore(EntityManager entityManager)
        {
            EntityManager = entityManager;
        }

        public Task<IdentityUser> FindByIdAsync(string id)
        {
            var user = EntityManager.GetRepository<UserRepository>().Find(id);
            return Task.FromResult(GetIdentityUser(user));
        }

        public Task<IdentityUser> FindByNameAsync(string name)
        {
            var user = EntityManager.GetRepository<UserRepository>().FindByUserName(name);
            return Task.FromResult(GetIdentityUser(user));
        }

        public Task CreateAsync(IdentityUser identityUser)
        {
            CheckUser(identityUser);
            EntityManager.GetRepository<UserRepository>().Insert(GetUser(identityUser));
            return EntityManager.SaveAsync();
        }

        public Task UpdateAsync(IdentityUser identityUser)
        {
            CheckUser(identityUser);
            var user = EntityManager.GetRepository<UserRepository>().Find(identityUser.Id);
            CheckUser(user);
            user.UpdatePasswordHash(identityUser.Password, Guid.NewGuid().ToString());
            EntityManager.GetRepository<UserRepository>().Update(user);
            return EntityManager.SaveAsync();
        }

        public Task DeleteAsync(IdentityUser identityUser)
        {
            CheckUser(identityUser);
            EntityManager.GetRepository<UserRepository>().Delete(GetUser(identityUser));
            return EntityManager.SaveAsync();
        }

        public Task AddClaimAsync(IdentityUser identityUser, System.Security.Claims.Claim claim)
        {
            CheckUser(identityUser);
            CheckClaim(claim);
            var user = EntityManager.GetRepository<UserRepository>().Find(identityUser.Id);
            CheckUser(user);
            var newId = EntityManager.GetRepository<ClaimRepository>().GenerateID();
            var newClaim = new Claim(newId, user.Id, claim.Type, claim.Value);
            user.Claims.Add(newClaim);
            EntityManager.GetRepository<UserRepository>().Update(user);
            return EntityManager.SaveAsync();
        }

        public Task<IList<System.Security.Claims.Claim>> GetClaimsAsync(IdentityUser identityUser)
        {
            CheckUser(identityUser);
            var user = EntityManager.GetRepository<UserRepository>().Find(identityUser.Id);
            CheckUser(user);
            return Task.FromResult<IList<System.Security.Claims.Claim>>(user.Claims.Select(cl => new System.Security.Claims.Claim(cl.Type,cl.Value)).ToList());
        }

        public Task RemoveClaimAsync(IdentityUser identityUser, System.Security.Claims.Claim claim)
        {
            CheckUser(identityUser);
            CheckClaim(claim);
            var user = EntityManager.GetRepository<UserRepository>().Find(identityUser.Id);
            CheckUser(user);
            var removedClaim = user.Claims.FirstOrDefault(cl => cl.Type == claim.Type && cl.Value == claim.Value);
            user.Claims.Remove(removedClaim);
            EntityManager.GetRepository<UserRepository>().Update(user);
            return EntityManager.SaveAsync();
        }

        public Task AddLoginAsync(IdentityUser identityUser, UserLoginInfo userLoginInfo)
        {
            CheckUser(identityUser);
            CheckLogin(userLoginInfo);
            var user = EntityManager.GetRepository<UserRepository>().Find(identityUser.Id);
            CheckUser(user);
            var newId = EntityManager.GetRepository<LoginRepository>().GenerateID();
            var newLogin = new Login(newId, user.Id, userLoginInfo.LoginProvider, userLoginInfo.ProviderKey, DateTime.Now);
            user.Logins.Add(newLogin);
            EntityManager.GetRepository<UserRepository>().Update(user);
            return EntityManager.SaveAsync();
        }

        public Task<IdentityUser> FindAsync(UserLoginInfo userLoginInfo)
        {
            CheckLogin(userLoginInfo);
            var identityUser = default(IdentityUser);
            var login = EntityManager.GetRepository<LoginRepository>().FindByProviderAndKey(userLoginInfo.LoginProvider, userLoginInfo.ProviderKey);
            identityUser = (login == null) ? identityUser : GetIdentityUser(login.User);
            return Task.FromResult(identityUser);
        }

        public Task<IList<UserLoginInfo>> GetLoginsAsync(IdentityUser identityUser)
        {
            CheckUser(identityUser);
            var user = EntityManager.GetRepository<UserRepository>().Find(identityUser.Id);
            CheckUser(user);
            return Task.FromResult<IList<UserLoginInfo>>(user.Logins.Select(lg => new UserLoginInfo(lg.Provider, lg.Key)).ToList());
        }

        public Task RemoveLoginAsync(IdentityUser identityUser, UserLoginInfo userLoginInfo)
        {
            CheckUser(identityUser);
            CheckLogin(userLoginInfo);
            var user = EntityManager.GetRepository<UserRepository>().Find(identityUser.Id);
            CheckUser(user);
            var login = user.Logins.FirstOrDefault(lg => lg.Provider == userLoginInfo.LoginProvider && lg.Key == userLoginInfo.ProviderKey);
            user.Logins.Remove(login);
            EntityManager.GetRepository<UserRepository>().Update(user);
            return EntityManager.SaveAsync();
        }

        public Task AddToRoleAsync(IdentityUser identityUser, string roleName)
        {
            CheckUser(identityUser);
            CheckRole(roleName);
            var user = EntityManager.GetRepository<UserRepository>().Find(identityUser.Id);
            CheckUser(user);
            var role = EntityManager.GetRepository<RoleRepository>().FindByTitle(roleName);
            CheckRole(role);
            user.Roles.Add(role);
            EntityManager.GetRepository<UserRepository>().Update(user);
            return EntityManager.SaveAsync();
        }

        public Task<IList<string>> GetRolesAsync(IdentityUser identityUser)
        {
            CheckUser(identityUser);
            var user = EntityManager.GetRepository<UserRepository>().Find(identityUser.Id);
            CheckUser(user);
            return Task.FromResult<IList<string>>(user.Roles.Select(ro => ro.Title).ToList());
        }

        public Task<bool> IsInRoleAsync(IdentityUser identityUser, string roleName)
        {
            CheckUser(identityUser);
            CheckRole(roleName);
            var user = EntityManager.GetRepository<UserRepository>().Find(identityUser.Id);
            CheckUser(user);
            return Task.FromResult(user.Roles.Any(ro => ro.Title == roleName));
        }

        public Task RemoveFromRoleAsync(IdentityUser identityUser, string roleName)
        {
            CheckUser(identityUser);
            CheckRole(roleName);
            var user = EntityManager.GetRepository<UserRepository>().Find(identityUser.Id);
            CheckUser(user);
            var role = user.Roles.FirstOrDefault(ro => ro.Title == roleName);
            user.Roles.Remove(role);
            EntityManager.GetRepository<UserRepository>().Update(user);
            return EntityManager.SaveAsync();
        }

        public Task<string> GetPasswordHashAsync(IdentityUser identityUser)
        {
            CheckUser(identityUser);
            return Task.FromResult(identityUser.Password);
        }

        public Task<bool> HasPasswordAsync(IdentityUser identityUser)
        {
            CheckUser(identityUser);
            return Task.FromResult(!string.IsNullOrWhiteSpace(identityUser.Password));
        }

        public Task SetPasswordHashAsync(IdentityUser identityUser, string password)
        {
            identityUser.Password = password;
            return Task.FromResult(0);
        }

        public Task<string> GetSecurityStampAsync(IdentityUser identityUser)
        {
            CheckUser(identityUser);
            return Task.FromResult(identityUser.SecurityStamp);
        }

        public Task SetSecurityStampAsync(IdentityUser identityUser, string stamp)
        {
            identityUser.SecurityStamp = stamp;
            return Task.FromResult(0);
        }

        private void CheckUser(IdentityUser identityUser)
        {
            (identityUser == null).IfTrue(() => { throw new ArgumentNullException("User does not exist."); });
        }

        private void CheckUser(User user)
        {
            (user == null).IfTrue(() => { throw new ArgumentException("Identity User does not correspond to user entity."); });
        }

        private void CheckClaim(System.Security.Claims.Claim claim)
        {
            (claim == null).IfTrue(() => { throw new ArgumentNullException("Claim does not exist."); });
        }

        private void CheckLogin(UserLoginInfo userLoginInfo)
        {
            (userLoginInfo == null).IfTrue(() => { throw new ArgumentNullException("Login info does not exist."); });
        }

        private void CheckRole(Role role)
        {
            (role == null).IfTrue(() => { throw new ArgumentException("The provided role name does not correspond to a role entity."); });
        }

        private void CheckRole(string roleName)
        {
            string.IsNullOrWhiteSpace(roleName).IfTrue(() => { throw new ArgumentNullException("Role Name cannot be null or empty."); });
        }

        private User GetUser(IdentityUser identityUser)
        {
            return (identityUser == null) ? null : CreateUser(identityUser);
        }

        private User CreateUser(IdentityUser identityUser)
        {
            var credential = new Credential(identityUser.Email, identityUser.UserName, identityUser.Password, identityUser.SecurityStamp);
            var session = new Session(identityUser.SessionId, identityUser.Ip, identityUser.LoginAttempt, DateTime.Now);
            var meta = new UserMeta(DateTime.Now, DateTime.Now, UserStatus.Active);
            return new User(identityUser.Id, credential, session, meta);
        }

        private IdentityUser CreateIdentityUser(User user)
        {
            var identityUser = new IdentityUser();
            MapIdentityUser(user, identityUser);
            return identityUser;
        }

        private IdentityUser GetIdentityUser(User user)
        {
            return (user == null) ? null : CreateIdentityUser(user);
        }

        private void MapIdentityUser(User user, IdentityUser identityUser)
        {
            identityUser.Id = user.Id;
            identityUser.Email = user.Credential.Email;
            identityUser.UserName = user.Credential.UserName;
            identityUser.Password = user.Credential.Password;
            identityUser.SecurityStamp = user.Credential.SecurityStamp;
            identityUser.SessionId = user.Session.SessionID;
            identityUser.Ip = user.Session.IP;
            identityUser.LoginAttempt = user.Session.LoginAttempt;
        }

        public void Dispose() { }
    }
}