using AyCode.Database.DataLayers;
using AyCode.Database.Tests;
using Microsoft.EntityFrameworkCore;
using Microsoft.VisualStudio.TestPlatform.ObjectModel;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;
using TIAM.Database.DataLayers.Users;
using TIAM.Database.DbContexts.Users;
using TIAM.Entities.Users;

namespace TIAM.Database.Test
{
    [TestClass]
    public class UserDalTests : DatabaseTestModelBase<UserDbContext>
    {
        private Mock<UserDbContext> _mockContext;
        private UserDal _userDal;

        [TestInitialize]
        public void TestInitialize()
        {
            //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);

            _userDal = PooledDal.CreateDal<UserDal>();
        }

        [TestMethod]
        [DataRow("test@tiam.hu")]
        public void GetUserByEmail_ReturnsUser_WhenUserExists(string email)
        {
            //var userDal = PooledDal.CreateDal<UserDal>();
            var user = _userDal.GetUserByEmail(email);
            
            Assert.IsNotNull(user);
            Assert.AreEqual(email, user.EmailAddress);
        }

        [TestMethod]
        [DataRow("test@tiam.hu")]
        public async Task GetUserByEmailAsync_ReturnsUser_WhenUserExists(string email)
        {
            User? user = null;
            //var userDal = PooledDal.CreateDal<UserDal>();

            user = await _userDal.GetUserByEmailAsync(email).ConfigureAwait(false);

            //user = await _userDal.SessionAsync(ctx => ctx.Users.FirstOrDefault(x => x.EmailAddress == email)).ConfigureAwait(false);

            //await using (var ctx = _userDal.Context)
            //{
            //    user = await ctx.Users.FirstOrDefaultAsync(x => x.EmailAddress == email).ConfigureAwait(false);
            //}


            Assert.IsNotNull(user);
            Assert.AreEqual(email, user.EmailAddress);
        }

        //[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);
        //}
    }
}