public class AMUserStore : IUserStore<ApplicationUser>,
                                          IUserPasswordStore<ApplicationUser>,
                                          IUserRoleStore<ApplicationUser>,
                                          IUserEmailStore<ApplicationUser>


    {
        protected AMDbContext _db;
        protected PortalContext _dbPortalContext;

        public AMUserStore()
        {
            _db = new AMDbContext();
            _dbPortalContext = new PortalContext();
        }

        public void Dispose()
        {
            _db.Dispose();
        }

        public async Task<ApplicationUser> FindByIdAsync(string userId)
        {
            ApplicationUser result = null;

            Guid userIdGuid = Guid.Parse(userId);
            var user = await _db.Users.Where(p => p.Id == userIdGuid).FirstOrDefaultAsync();

            if (user != null)
            {
                result = new ApplicationUser();
                result.Id = user.Id.ToString();
                result.UserName = user.Username;
                result.PasswordHash = user.Password;
            }

            return result;
        }

        public async Task<ApplicationUser> FindByNameAsync(string userName)
        {
            ApplicationUser result = null;

            var user = await _db.Users.Where(p => p.Username == userName).FirstOrDefaultAsync();
            //var roles = ((IList<string>)_dbPortalContext.UserRoles.Where(x => x.UserId.Equals(userIdGuid)).Select(x => x.Roles.ToString()).ToList());

            if (user != null)
            {
                result = new ApplicationUser();
                result.Id = user.Id.ToString();
                result.UserName = user.Username;
                result.PasswordHash = user.Password;
            }

            return result;
        }



        public Task<string> GetPasswordHashAsync(ApplicationUser user)
        {
            return Task.FromResult(user.PasswordHash);
        }

        public Task<bool> HasPasswordAsync(ApplicationUser user)
        {
            return Task.FromResult(string.IsNullOrEmpty(user.PasswordHash));
        }

        public Task SetPasswordHashAsync(ApplicationUser user, string passwordHash)
        {
            var userId = Guid.Parse(user.Id);
            var selectedUser = _db.Users.FirstOrDefault(u => u.Id.Equals(userId));

            selectedUser.Password = passwordHash;

            return _db.SaveChangesAsync();

        }

        public Task UpdateAsync(ApplicationUser user)
        {
            var userId = Guid.Parse(user.Id);
            var selectedUser = _db.Users.FirstOrDefault(u => u.Id.Equals(userId));
            var context = _db;
            context.Entry(selectedUser).State = EntityState.Modified;
            return _db.SaveChangesAsync();

        }
        public Task CreateAsync(ApplicationUser user)
        {
            throw new NotImplementedException();
        }

        public Task DeleteAsync(ApplicationUser user)
        {
            throw new NotImplementedException();
        }

        public Task AddToRoleAsync(ApplicationUser user, string roleName)
        {
            // convert  roleName  to  enum Roles
            Roles roleNameEnum = (Roles)Enum.Parse(typeof(Roles), roleName);
            Guid userIdGuid = Guid.Parse(user.Id);
            var roles = _dbPortalContext.UserRoles.Where(x => x.UserId.Equals(userIdGuid)).Select(x => x.Roles).ToList();
            if (!roles.Contains(roleNameEnum))
            {
                UserRole userRole = new UserRole
                {
                    Id = Guid.NewGuid(),
                    UserId = Guid.Parse(user.Id),
                    Roles = roleNameEnum
                };

                _dbPortalContext.UserRoles.Add(userRole);

            }
            return _dbPortalContext.SaveChangesAsync();

        }

        public Task RemoveFromRoleAsync(ApplicationUser user, string roleName)
        {
            Guid userIdGuid = Guid.Parse(user.Id);
            var roles = _dbPortalContext.UserRoles.Where(x => x.UserId.Equals(userIdGuid)).FirstOrDefault();
            if (roles == null)
            {

            }
            _dbPortalContext.UserRoles.Remove(roles);

            return _dbPortalContext.SaveChangesAsync();
        }

        public Task<IList<string>> GetRolesAsync(ApplicationUser user)
        {
            Guid userIdGuid = Guid.Parse(user.Id);
            var roles = ((IList<string>)_dbPortalContext.UserRoles.Where(x => x.UserId.Equals(userIdGuid)).Select(x => x.Roles.ToString()).ToList());
            return Task.FromResult(roles);
        }

        public Task<bool> IsInRoleAsync(ApplicationUser user, string roleName)
        {
            Guid userIdGuid = Guid.Parse(user.Id);
            Roles roleNameEnum = (Roles)Enum.Parse(typeof(Roles), roleName);
            var roles = _dbPortalContext.UserRoles.Where(x => x.UserId.Equals(userIdGuid)).Select(x => x.Roles).ToList();


            return Task.FromResult(roles.Contains(roleNameEnum));
        }

        public Task SetEmailAsync(ApplicationUser user, string email)
        {
            throw new NotImplementedException();
        }

        public Task<string> GetEmailAsync(ApplicationUser user)
        {
            var userId = Guid.Parse(user.Id);
            var result = _dbPortalContext.Accounts.Include(a => a.User).FirstOrDefault(a => a.User.Id.Equals(userId));
            string userEmail = null;
            if (result != null)
            {
                userEmail = result.Sol_Cust_Contact;
                return Task.FromResult(userEmail);
            }


            else
                return Task.FromResult(userEmail);
        }


        public Task<bool> GetEmailConfirmedAsync(ApplicationUser user)
        {
            var userId = Guid.Parse(user.Id);
            var selectedUser = _dbPortalContext.Users.Where(u => u.Id.Equals(userId)).FirstOrDefault();
            return Task.FromResult(selectedUser.EmailValidated);
        }

        public Task SetEmailConfirmedAsync(ApplicationUser user, bool confirmed)
        {
            throw new NotImplementedException();
        }

        public Task<ApplicationUser> FindByEmailAsync(string email)
        {
            ApplicationUser result = null;
            var user = _db.Users.Where(u => u.Email.Equals(email)).FirstOrDefault();
            if (user != null)
            {
                result = new ApplicationUser();
                result.Id = user.Id.ToString();
                result.UserName = user.Username;
                result.Email = user.Email;

            }

            return Task.FromResult(result);
        }
    }