using AutoMapper;
using IRaCIS.Core.Domain.Models;
using IRaCIS.Core.Domain.Share;
using IRaCIS.Core.Infra.EFCore;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Localization;
using Moq;
using NUnit.Framework;
using NUnit.Framework.Interfaces;
using System.Collections.Generic;
using System.Linq;
using System;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore.Metadata;
using Moq.EntityFrameworkCore;
using System.Xml;
using SharpCompress.Common;

namespace IRaCIS.Core.Test
{
    [TestFixture]
    public class RepositoryTests
    {
        private Repository<User> _userRepository;
        private Mock<IRaCISDBContext> _mockDbContext;
        private Mock<DbSet<User>> _mockSet;
        private List<User> _users;

        [SetUp]
        public void Setup()
        {
            // Create a mock DbContext with an in-memory list of users
            _users = new List<User>
        {
            new User {  UserName = "Alice" },
            new User {  UserName = "Bob" },
            new User {  UserName = "Charlie" }
        };
            _mockDbContext = new Mock<IRaCISDBContext>();
            _mockSet = new Mock<DbSet<User>>();
            _mockSet.As<IQueryable<User>>().Setup(m => m.Provider).Returns(_users.AsQueryable().Provider);
            _mockSet.As<IQueryable<User>>().Setup(m => m.Expression).Returns(_users.AsQueryable().Expression);
            _mockSet.As<IQueryable<User>>().Setup(m => m.ElementType).Returns(_users.AsQueryable().ElementType);
            _mockSet.As<IQueryable<User>>().Setup(m => m.GetEnumerator()).Returns(_users.GetEnumerator());

            _mockDbContext.Setup(x => x.Set<User>()).Returns(_mockSet.Object);
            _userRepository = new Repository<User>(_mockDbContext.Object);
        }

        [Test]
        public void GetAll_ReturnsAllUsers()
        {
            // Act
            var result = _userRepository._dbSet.ToList();

            // Assert
            Assert.AreEqual(_users.Count, result.Count);
            CollectionAssert.AreEquivalent(_users, result);
        }


        [Test]
        public async Task Test_Add()
        {
            var addEntity = new User { UserName = "test" };


            //Act
             await  _userRepository.AddAsync(addEntity);

            //Assert
            _mockDbContext.Verify(x => x.Add(addEntity), Times.Once);
  


            //Act
        
        }



    }
    public class Tests
    {
        [SetUp]
        public void Setup()
        {
        }

        [Test]
        public void Test1()
        {
            Assert.Pass();
        }

        public class MoqService
        {

            [Test]
            public async Task testAdd()
            {
                var users = new List<User>
                {
                    new User { UserName = "test 1"},
                    new User {UserName = "Product 2"},
                    new User { UserName = "Product 3"}
                };

                //Arrange
                var dbContext = new Mock<IRaCISDBContext>();
                dbContext.Setup(x => x.Set<User>()).ReturnsDbSet(users);
                var mapperMock = new Mock<IMapper>();
                var userInfoMock = new Mock<IUserInfo>();
                var localizerMock = new Mock<IStringLocalizer>();

                var repository = new Repository<User>(dbContext.Object, mapperMock.Object, userInfoMock.Object, localizerMock.Object);


                var entity = new User { UserName = "Test Entity" };

                //Act
                await repository.AddAsync(entity);

                //Assert
                dbContext.Verify(x => x.Add(entity), Times.Once);
                dbContext.Verify(x => x.SaveChanges(), Times.Once);
            }

        }

        [Test]
        public async Task Add_Success()
        {
            // Arrange
            var mockSet = new Mock<DbSet<User>>();
            var mockContext = new Mock<IRaCISDBContext>();
            mockContext.Setup(m => m.Set<User>()).Returns(mockSet.Object);


            var mapperMock = new Mock<IMapper>();
            var userInfoMock = new Mock<IUserInfo>();
            var localizerMock = new Mock<IStringLocalizer>();

            var repository = new Repository(mockContext.Object, mapperMock.Object, userInfoMock.Object, localizerMock.Object);


            var entity = new User { UserName = "Test Entity" };

            //Act
            await repository.AddAsync(entity);


            // Assert
            mockContext.Verify(x => x.Add(entity), Times.Once);
        }
    }
}