using AyCode.Database.Tests.Users;
using Newtonsoft.Json;
using AyCode.Core.Helpers;
using TIAM.Database.DataLayers.Users;
using TIAM.Database.DbContexts.Users;
using TIAM.Entities.Profiles;
using TIAM.Entities.Users;
using TIAM.Models.Dtos.Users;
using TIAM.Entities.ServiceProviders;
using TIAM.Entities.Addresses;
using TIAM.Entities.Emails;

namespace TIAM.Database.Test
{
    [TestClass]
    public class UserDalTests : AcUserDalTestBase<UserDal, UserDbContext, User, Profile, UserToken, Company, UserToCompany, Address, EmailMessage>
    {
        //private Guid _registerUserId = Guid.Parse("1f7e0591-330b-463b-81ad-d01f2e65e23e");
        //private const string RegisterEmail = "qwerty@xxxxx.com";
        //private const string RegisterPassword = "elem'r";

        //private const string LoginEmail = "asdfsdf@ggggg.hu";
        //private const string LoginPassword = "alad'r";

        //private WebAssemblyHostConfiguration _configuration = new();
        //private Mock<UserDbContext> _mockContext;

        [TestInitialize]
        public void TestInitialize()
        {
            //AppSettingsConfiguration = InitAppSettingsConfiguration();

            //_configuration["JWT:Key"] = "Cee4400-rDMFkVvHPufyLDSzbfu2grgRhpepos299IhTLOXsljkcpt3yUR4RRjPQ";
            //_configuration["JWT:Audience"] = "http://localhost:5000";
            //_configuration["JWT:Issuer"] = "http://localhost:5000";

            //var options = new DbContextOptionsBuilder<UserDbContext>()
            //    .UseInMemoryDatabase(databaseName: "UserDatabase")
            //    .Options;

            //_mockContext = new Mock<UserDbContext>(options);

            //var mockSet = new Mock<DbSet<User>>();
            //_mockContext.Setup(c => c.Users).Returns(mockSet.Object);

            //_userDal = new UserDal(_mockContext.Object);
        }

        //[TestMethod]
        public async Task ConvertOldPassword()
        {
            //var loginService = new LoginService(Dal, AppSettingsConfiguration);
            var users = Dal.Context.Users.ToList();
            
            foreach (var user in users)
            {
                if (user.Password.Contains("$bcrypt$v=1$salt=")) continue;

                user.Password = PasswordHasher.HashPassword(user.Password, PasswordHasher.GenerateDynamicSalt(user.Id));
                await Dal.UpdateUserAsync(user);
            }
        }

        //[DataTestMethod]
        //public async Task RegisterUser_ReturnsUser_WhenUserExist()
        //{
        //    //var a = TiamConst.ProjectIdString;

        //    await Dal.RemoveUserAsync(_registerUserId); //kitöröljük a szemetet, ha korábbról bentmaradt - J.

        //    var loginService = new LoginService(Dal, AcEnv.AppConfiguration);
        //    var errorCode = await loginService.RegistrationAsync(_registerUserId, RegisterEmail, RegisterPassword, null);

        //    Assert.IsTrue(errorCode == AcErrorCode.Unset);

        //    var user = Dal.GetUserByEmail(RegisterEmail, false);

        //    Assert.IsNotNull(user);
        //    Assert.IsNotNull(user.Profile);
        //    Assert.IsNotNull(user.Profile.Address);

        //    await Dal.RemoveUserAsync(user); //kitöröljük a szemetet - J.
        //}

        //[DataTestMethod]
        //[DataRow([LoginEmail, LoginPassword])]
        //public void LoginUser_ReturnsUser_WhenUserExist()
        //{
        //    //var a = TiamConst.ProjectIdString;

        //    var loginService = new LoginService(Dal, AcEnv.AppConfiguration);

        //    #region Valid email+password test
        //    var loggedInModel = loginService.Login(LoginEmail, LoginPassword);            

        //    Assert.IsNotNull(loggedInModel);
        //    Assert.IsNotNull(loggedInModel.LoggedInUser);
        //    Assert.IsNotNull(loginService.LoggedInModel?.LoggedInUser);

        //    Assert.IsTrue(loggedInModel.LoginErrorCode == AcErrorCode.Unset, $"errorCode: {loggedInModel.LoginErrorCode}");
        //    Assert.IsTrue(loggedInModel.IsLoggedIn, $"loggedInModel.IsLoggedIn == false; errorCode: {loggedInModel.LoginErrorCode}");
        //    Assert.IsTrue(string.Equals(loggedInModel.LoggedInUser.EmailAddress, LoginEmail, StringComparison.CurrentCultureIgnoreCase));
        //    #endregion Valid email+password test

        //    #region Wrong email test
        //    loggedInModel = loginService.Login("gffsdgdfg@gu.hu", LoginPassword);

        //    Assert.IsNotNull(loggedInModel);
        //    Assert.IsFalse(loggedInModel.IsLoggedIn);
        //    Assert.IsTrue(loggedInModel.LoginErrorCode == AcErrorCode.WrongLoginData);
        //    #endregion Wrong email test

        //    #region Wrong password test
        //    loggedInModel = loginService.Login(LoginEmail, "fsdgfsdg");

        //    Assert.IsNotNull(loggedInModel);
        //    Assert.IsFalse(loggedInModel.IsLoggedIn);
        //    Assert.IsTrue(loggedInModel.LoginErrorCode == AcErrorCode.WrongLoginData);
        //    #endregion Wrong password test
        //}

        [DataTestMethod]
        [DataRow("540271F6-C604-4C16-8160-D5A7CAFEDF00")]
        public override void AcBase_GetUserById_ReturnsUser_WhenUserExists(string userIdString)
        {
            var user = AcBase_GetUserById(userIdString);

            Assert.IsTrue(user.ServiceProviders.Count > 0);
            Assert.IsTrue(user.UserToServiceProviders.Count > 0);
        }

        [DataTestMethod]
        [DataRow("test@tiam.hu")]
        public override void AcBase_GetUserByEmail_ReturnsUser_WhenUserExists(string email)
        {
            var user = AcBase_GetUserByEmail(email);

            Assert.IsTrue(user.ServiceProviders.Count > 0);
            Assert.IsTrue(user.UserToServiceProviders.Count > 0);
        }
        
        [DataTestMethod]
        [DataRow("test@tiam.hu")]
        public async Task GetUserByEmailAsync_ReturnsUser_WhenUserAndRelationsExists(string email)
        {
            var user = await AcBase_GetUserByEmailAsync_ReturnsUser_WhenUserExists(email);

            Assert.IsTrue(user.ServiceProviders.Count > 0);
            Assert.IsTrue(user.UserToServiceProviders.Count > 0);
        }

        [DataTestMethod]
        [DataRow("540271F6-C604-4C16-8160-D5A7CAFEDF00")]
        public override void AcBase_GetUserModelDtoDetailById_ReturnsUser_WhenUserExists(string userIdString)
            => base.AcBase_GetUserModelDtoDetailById_ReturnsUser_WhenUserExists(userIdString);

        [DataTestMethod]
        [DataRow("540271F6-C604-4C16-8160-D5A7CAFEDF00")]
        [DataRow("dcf451d2-cc4c-4ac2-8c1f-da00041be1fd")]
        [DataRow("ac612aa8-863b-4b4f-9d63-f5d261b5c5f9")]
        public async Task SerializeUserModelDto_ReturnDeserializedUser_WhenUserAndRelationsExists(string userIdString)
        {
            var userId = Guid.Parse(userIdString);

            JsonSerializerSettings options = new()
            {
                ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
                NullValueHandling = NullValueHandling.Ignore
            };

            var userModel = await Dal.GetUserModelDtoByIdAsync<UserModelDto>(userId, false).ConfigureAwait(false);

            var serializedUserModel = JsonConvert.SerializeObject(userModel, options);
            userModel = JsonConvert.DeserializeObject<UserModelDto>(serializedUserModel);

            Assert.IsNotNull(userModel);
            Assert.IsNotNull(userModel.UserDto);
            Assert.IsNotNull(userModel.ProfileDto);

            if (userId != Guid.Parse("540271F6-C604-4C16-8160-D5A7CAFEDF00")) return; //csak az "540271F6.."-nek van product-ja! - J.

            Assert.IsTrue(userModel.Products.Count > 0);
            Assert.IsTrue(userModel.UserProductMappings.Count > 0);

            Assert.IsTrue(userModel.ServiceProviders.Count > 0);
            Assert.IsTrue(userModel.UserToServiceProviders.Count > 0);
        }

        [DataTestMethod]
        [DataRow(["e31044d7-1771-4a32-8dd9-6f9853ed53c6", "0a831191-70a3-4504-9ec4-c5902affaba7", "8eed080c-d2ce-4cc3-bcfe-2268c220bba7", "addUser_test9432@tiam.hu"])]
        public override async Task AcBase_AddUserTest(string[] userIdProfileIdAddressIdEmailStrings)
            => await base.AcBase_AddUserTest(userIdProfileIdAddressIdEmailStrings);


        //[TestMethod]
        //[DataRow("test@tiam.hu")]
        //public async Task GetUserByEmailAsync_ReturnsUser_WhenUserExists(string email)
        //{
        //    // Arrange
        //    var user = new User { EmailAddress = email };
        //    var users = new[] { user }.AsQueryable();

        //    var mockSet = new Mock<DbSet<User>>();
        //    mockSet.As<IQueryable<User>>().Setup(m => m.Provider).Returns(users.Provider);
        //    mockSet.As<IQueryable<User>>().Setup(m => m.Expression).Returns(users.Expression);
        //    mockSet.As<IQueryable<User>>().Setup(m => m.ElementType).Returns(users.ElementType);
        //    mockSet.As<IQueryable<User>>().Setup(m => m.GetEnumerator()).Returns(users.GetEnumerator());

        //    _mockContext.Setup(c => c.Users).Returns(mockSet.Object);

        //    // Act
        //    var result = await _userDal.GetUserByEmailAsync(email);

        //    // Assert
        //    Assert.IsNotNull(result);
        //    Assert.AreEqual(email, result.EmailAddress);
        //}

        //[TestMethod]
        //[DataRow("TEST@TEST.COM")]
        //public async Task GetUserByEmailAsync_ReturnsNull_WhenUserDoesNotExist(string email)
        //{
        //    // Arrange
        //    var users = new User[0].AsQueryable();

        //    var mockSet = new Mock<DbSet<User>>();
        //    mockSet.As<IQueryable<User>>().Setup(m => m.Provider).Returns(users.Provider);
        //    mockSet.As<IQueryable<User>>().Setup(m => m.Expression).Returns(users.Expression);
        //    mockSet.As<IQueryable<User>>().Setup(m => m.ElementType).Returns(users.ElementType);
        //    mockSet.As<IQueryable<User>>().Setup(m => m.GetEnumerator()).Returns(users.GetEnumerator());

        //    _mockContext.Setup(c => c.Users).Returns(mockSet.Object);

        //    // Act
        //    var result = await _userDal.GetUserByEmailAsync(email);

        //    // Assert
        //    Assert.IsNull(result);
        //}

        //[TestMethod]
        //[DataRow("TEST@TEST.COM", "+1234567890", "password")]
        //public async Task CreateUserAsync_ShouldReturnTrue_WhenUserIsCreated(string email, string phoneNumbr, string password)
        //{
        //    // Arrange
        //    var user = new User
        //    {
        //        Id = Guid.NewGuid(),
        //        EmailAddress = email,
        //        PhoneNumber = phoneNumbr,
        //        Password = password
        //    };

        //    var mockSet = new Mock<DbSet<User>>();
        //    _mockContext.Setup(x => x.Users).Returns(mockSet.Object);
        //    _mockContext.Setup(x => x.Users.Add(user)).Returns(() => null);

        //    _mockContext.Setup(x => x.SaveChangesAsync(It.IsAny<CancellationToken>()))
        //    .ReturnsAsync(1)
        //    .Verifiable();

        //    // Act
        //    var result = await _userDal.CreateUserAsync(user);

        //    // Assert
        //    Assert.IsTrue(result);
        //}

        //[TestMethod]
        //[DataRow("TEST@TEST.COM", "+1234567890", "password")]
        //public async Task UpdateUserAsync_ShouldUpdateUser(string email, string phoneNumbr, string password)
        //{
        //    // Arrange
        //    var user = new User(Guid.NewGuid(), email, phoneNumbr, password);
        //    _mockContext.Object.Users.Add(user);
        //    await _mockContext.Object.SaveChangesAsync();

        //    // Act
        //    user.EmailAddress = email;
        //    var result = await _userDal.UpdateUserAsync(user);

        //    // Assert
        //    Assert.IsTrue(result);
        //    var updatedUser = _mockContext.Object.Users.Single(u => u.EmailAddress == user.EmailAddress);
        //    Assert.AreEqual(email, updatedUser.EmailAddress);
        //}
    }
}