using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Moq;


using WfApi.Controllers;
using Shared;
using DTO;

namespace XUnitTest
{
    public class UnitTest1
    {
        private readonly Mock<IUserService<UserDTO>> _mockUserService;
        private readonly Mock<ILogger<UsersController>> _mockLogger;
        private readonly UsersController _userController;

        public UnitTest1()
        {
            // Initialisation des mocks
            _mockUserService = new Mock<IUserService<UserDTO>>();
            _mockLogger = new Mock<ILogger<UsersController>>();
            _userController = new UsersController(_mockUserService.Object, _mockLogger.Object);
        }



        [Fact]
        public async Task Get_ReturnsOk_WhenUserExists()
        {
            // Arrange
            var userId = 1;
            var userDTO = new UserDTO
            {
                Id = userId,
                Pseudo = "test",
                Email = "test@unitaire.fr",
                ImageProfil = "http://test",
                Password = "1234"
            };

            _mockUserService.Setup(service => service.GetUserById(userId)).ReturnsAsync(userDTO); 

            // Act
            var result = await _userController.Get(userId);

            // Assert
           Assert.IsType<OkObjectResult>(result); 
        }




        [Fact]
        public async Task GetAllUsers_ReturnsOk()
        {
            // Arrange
            var userDTO = new UserDTO
            {
                Id = 1,
                Pseudo = "test",
                Email = "test@unitaire.fr",
                ImageProfil = "http://test",
                Password = "1234"
            };
            var userDTO2 = new UserDTO
            {
                Id = 2,
                Pseudo = "test",
                Email = "test@unitaire.fr",
                ImageProfil = "http://test",
                Password = "1234"
            };

            _mockUserService.Setup(service => service.GetUserById(1)).ReturnsAsync(userDTO);
            _mockUserService.Setup(service => service.GetUserById(2)).ReturnsAsync(userDTO);

            // Act
            var result = await _userController.GetAllUsers();

            // Assert
            Assert.IsType<OkObjectResult>(result);
        }



        [Fact]
        public async Task GetHashPassword_ReturnsOk_WhenPasswordHashIsFound()
        {
            // Arrange
            var username = "testUser";
            var expectedHash = "hashedPassword"; 

            var taskResult = Task.FromResult(expectedHash);
            _mockUserService.Setup(service => service.GetHashPassword(username)).Returns(taskResult);

            // Act
            var result = await _userController.GetHashPassword(username);

            // Assert
            Assert.IsType<OkObjectResult>(result);
        }

        [Fact]
        public async Task GetUserByUsername_ReturnsOk_WhenPasswordHashIsFound()
        {
            // Arrange
            var username = "testUser";
            var userDTO = new UserDTO
            {
                Id = 1,
                Pseudo = "testUser",
                Email = "test@unitaire.fr",
                ImageProfil = "http://test",
                Password = "1234"
            };

            var taskResult = Task.FromResult(userDTO);
            _mockUserService.Setup(service => service.GetUserByUsername(username)).Returns(taskResult);

            // Act
            var result = await _userController.GetUserByUsername(username);

            // Assert
            Assert.IsType<OkObjectResult>(result);
        }

        [Fact]
        public async Task GetUserByEmail_ReturnsOk_WhenUserExists()
        {
            // Arrange
            var email = "test@unitaire.fr";
            var userDTO = new UserDTO
            {
                Id = 1,
                Pseudo = "testUser",
                Email = email,
                ImageProfil = "http://test",
                Password = "1234"
            };

            
            var taskResult = Task.FromResult(userDTO);
            _mockUserService.Setup(service => service.GetUserByEmail(email)).Returns(taskResult);

            // Act
            var result = await _userController.GetUserByEmail(email);

            // Assert
            Assert.IsType<OkObjectResult>(result);
        }

        [Fact]
        public async Task GetCountUser_ReturnsOk_WhenCountIsSuccessful()
        {
            // Arrange
            var expectedCount = 5;  
            var taskResult = Task.FromResult(expectedCount);

            _mockUserService.Setup(service => service.CountUser()).Returns(taskResult);

            // Act
            var result = await _userController.GetCountUser();

            // Assert
            Assert.IsType<OkObjectResult>(result);
        }

        [Fact]
        public async Task GetExistUsername_ReturnsOk_WhenUserExists()
        {
            // Arrange
            var username = "testUser";
            var taskResult = Task.FromResult(true);

            
            _mockUserService.Setup(service => service.ExistUsername(username)).Returns(taskResult);

            // Act
            var result = await _userController.GetExistUsername(username);

            // Assert
            Assert.IsType<OkObjectResult>(result); 
         
        }

        [Fact]
        public async Task GetExistEmail_ReturnsOk_WhenEmailExists()
        {
            // Arrange
            var email = "test@unitaire.fr";
            var taskResult = Task.FromResult(true);  

            _mockUserService.Setup(service => service.ExistEmail(email)).Returns(taskResult);

            // Act
            var result = await _userController.GetExistEmail(email);

            // Assert
            Assert.IsType<OkObjectResult>(result);
         
        }
        [Fact]
        public async Task UpdateUser_ReturnsOk_WhenUserDataIsValid()
        {
            // Arrange
            var id = 1;
            var updatedUser = new UserDTO
            {
                Id = id,
                Pseudo = "UpdatedUser",
                Email = "updated@unitaire.fr",
                ImageProfil = "http://updatedImage.com",
                Password = "newPassword123"
            };

            var taskResult = Task.FromResult(updatedUser);  

            _mockUserService.Setup(service => service.UpdateUser(id, updatedUser)).Returns(taskResult);

            // Act
            var result = await _userController.UpdateUser(id, updatedUser);

            // Assert
            var okResult = Assert.IsType<OkObjectResult>(result);

            Assert.IsType<OkObjectResult>(result);
        }
        [Fact]
        public async Task CreateUser_ReturnsCreatedAtAction_WhenUserIsValid()
        {
            // Arrange
            var newUser = new UserDTO
            {
                Id = 2,
                Pseudo = "NewUser",
                Email = "newuser@unitaire.fr",
                ImageProfil = "http://newuserimage.com",
                Password = "newPassword123"
            };

            _mockUserService.Setup(service => service.GetUserById(newUser.Id)).ReturnsAsync((UserDTO)null);

            _mockUserService.Setup(service => service.AddUser(newUser)).Verifiable();

            // Act
            var result = await _userController.CreateUser(newUser);

            // Assert
            var createdResult = Assert.IsType<CreatedAtActionResult>(result);
            Assert.Equal(newUser.Id, createdResult.RouteValues["id"]);  
        }


        [Fact]
        public async Task DeletePlayer_ReturnsOk_WhenPlayerExists()
        {
            // Arrange
            var id = 1;
            var existingPlayer = new UserDTO
            {
                Id = id,
                Pseudo = "ExistingUser",
                Email = "existing@unitaire.fr",
                ImageProfil = "http://existingimage.com",
                Password = "existingPassword123"
            };

            _mockUserService.Setup(service => service.GetUserById(id)).ReturnsAsync(existingPlayer);

            _mockUserService.Setup(service => service.RemoveUser(existingPlayer)).Verifiable();

            // Act
            var result = await _userController.DeletePlayer(id);

            // Assert
            Assert.IsType<OkObjectResult>(result);
           
        }


    }
}