using AyCode.Database.Tests.Users;
using Newtonsoft.Json;
using AyCode.Core.Consts;
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 Microsoft.AspNetCore.Components.WebAssembly.Hosting;
using TIAM.Entities.ServiceProviders;
using TIAM.Entities.Addresses;
using TIAMWebApp.Server.Services.Logins;
using AyCode.Interfaces.Users;
using Microsoft.EntityFrameworkCore;

namespace TIAM.Database.Test
{
    [TestClass]
    public class UserDalTests : AcUserDalTestBase<UserDal, UserDbContext, User, Profile, UserToken, TiamServiceProvider, UserToServiceProvider, Address>
    {
        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);
            }
        }

        [TestMethod]
        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, AppSettingsConfiguration);
            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.
        }

        [TestMethod]
        public void LoginUser_ReturnsUser_WhenUserExist()
        {
            //var a = TiamConst.ProjectIdString;

            var loginService = new LoginService(Dal, AppSettingsConfiguration);

            #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
        }

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

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

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

            Assert.IsTrue(user.ServiceProviders.Count > 0);
            Assert.IsTrue(user.UserToServiceProviders.Count > 0);
        }
        
        [TestMethod]
        [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);
        }

        [TestMethod]
        [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(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.Profile);

            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 async Task AddUserTest(string[] userIdProfileIdAddressIdEmailStrings)
        {
            var userId = Guid.Parse(userIdProfileIdAddressIdEmailStrings[0]);
            var profileId = Guid.Parse(userIdProfileIdAddressIdEmailStrings[1]);
            var addressId = Guid.Parse(userIdProfileIdAddressIdEmailStrings[2]);
            var email = userIdProfileIdAddressIdEmailStrings[3];

            var fromAddress = "Budapest, Liszt Ferenc tér";
            var toAddress = "1211 Budapest, Kossuth Lajos utca 145";
            //var userProductToCarId = Guid.Parse("97179a87-d99f-4f12-b7b2-75e21aaec6ab");

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

            var user = new User(userId, email, "235664", "dsfglfjg45r34903t3kggvq");
            user.ProfileId = profileId;

            var profile = new Profile();
            profile.Id = profileId;;
            profile.Name = "Add user test name";

            var address = new Address();
            address.Id = addressId;
            address.Latitude = 5362.2341652256;
            address.Longitude = 5362.2341333317;
            address.AddressText = "1214 Kossuth Lajos utca 124.";

            user.Profile = profile;
            user.Profile.AddressId = addressId;
            user.Profile.Address = address;

            Assert.IsTrue(await Dal.AddUserAsync(user));
            user = Dal.GetUserById(userId, false);
            
            Assert.IsNotNull(user);
            Assert.IsNotNull(user.Profile);
            Assert.IsNotNull(user.Profile.Address);

            Assert.IsTrue(await Dal.RemoveUserAsync(userId)); //mielőbb kitöröljük, h ne maradjon szemét a db-ben - J.

            user = Dal.GetUserById(userId, false);
            Assert.IsNull(user); //a korábbi törlés miatt NULL kell legyen - J.
        }
        //[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);
        //}
    }
}