using Xunit;
using Moq;
using FluentAssertions;
using Haoliang.Core.Services;
using Haoliang.Models.User;
using Haoliang.Data.Repositories;

namespace Haoliang.Tests;

public class UserServiceTests
{
    private readonly Mock<IUserRepository> _mockUserRepository;
    private readonly UserService _userService;

    public UserServiceTests()
    {
        _mockUserRepository = new Mock<IUserRepository>();
        _userService = new UserService(_mockUserRepository.Object);
    }

    [Fact]
    public async Task CreateUserAsync_SetsCreatedAtAndUpdatedAt()
    {
        var user = new User { Username = "newuser", RealName = "New User", Email = "new@example.com" };
        _mockUserRepository.Setup(r => r.AddAsync(It.IsAny<User>())).Returns(Task.CompletedTask);
        _mockUserRepository.Setup(r => r.SaveAsync()).ReturnsAsync(1);

        var beforeCreate = DateTime.Now;
        var result = await _userService.CreateUserAsync(user);
        var afterCreate = DateTime.Now;

        result.CreatedAt.Should().BeOnOrAfter(beforeCreate);
        result.CreatedAt.Should().BeOnOrBefore(afterCreate);
    }

    [Fact]
    public async Task GetUserByIdAsync_ReturnsUserViewModel_WhenExists()
    {
        var user = new User 
        { 
            Id = 1, 
            Username = "admin", 
            RealName = "Administrator",
            Email = "admin@example.com",
            Role = new Role { RoleName = "Admin" }
        };
        _mockUserRepository.Setup(r => r.GetByIdAsync(1)).ReturnsAsync(user);

        var result = await _userService.GetUserByIdAsync(1);

        result.Should().NotBeNull();
        result!.Username.Should().Be("admin");
        result.RealName.Should().Be("Administrator");
    }

    [Fact]
    public async Task GetUserByIdAsync_ReturnsNull_WhenNotExists()
    {
        _mockUserRepository.Setup(r => r.GetByIdAsync(999)).ReturnsAsync((User?)null);

        var result = await _userService.GetUserByIdAsync(999);

        result.Should().BeNull();
    }

    [Fact]
    public async Task GetAllUsersAsync_ReturnsAllUsers()
    {
        var users = new List<User>
        {
            new User { Id = 1, Username = "user1", RealName = "User 1" },
            new User { Id = 2, Username = "user2", RealName = "User 2" }
        };
        _mockUserRepository.Setup(r => r.GetAllAsync()).ReturnsAsync(users);

        var result = await _userService.GetAllUsersAsync();

        result.Should().HaveCount(2);
    }

    [Fact]
    public async Task UpdateUserAsync_UpdatesUser_WhenExists()
    {
        var existing = new User 
        { 
            Id = 1, 
            Username = "admin", 
            RealName = "Original Name",
            Email = "original@example.com"
        };
        var updateData = new User 
        { 
            RealName = "Updated Name",
            Email = "updated@example.com",
            Department = "IT",
            RoleId = 2
        };
        
        _mockUserRepository.Setup(r => r.GetByIdAsync(1)).ReturnsAsync(existing);
        _mockUserRepository.Setup(r => r.Update(It.IsAny<User>())).Verifiable();
        _mockUserRepository.Setup(r => r.SaveAsync()).ReturnsAsync(1);

        var result = await _userService.UpdateUserAsync(1, updateData);

        result.Should().NotBeNull();
        result!.RealName.Should().Be("Updated Name");
        result.Email.Should().Be("updated@example.com");
    }

    [Fact]
    public async Task UpdateUserAsync_ReturnsNull_WhenNotExists()
    {
        _mockUserRepository.Setup(r => r.GetByIdAsync(999)).ReturnsAsync((User?)null);

        var result = await _userService.UpdateUserAsync(999, new User());

        result.Should().BeNull();
    }

    [Fact]
    public async Task ActivateUserAsync_ReturnsTrue_WhenUserExists()
    {
        var user = new User { Id = 1, IsActive = false };
        _mockUserRepository.Setup(r => r.GetByIdAsync(1)).ReturnsAsync(user);
        _mockUserRepository.Setup(r => r.Update(It.IsAny<User>())).Verifiable();
        _mockUserRepository.Setup(r => r.SaveAsync()).ReturnsAsync(1);

        var result = await _userService.ActivateUserAsync(1);

        result.Should().BeTrue();
    }

    [Fact]
    public async Task ActivateUserAsync_ReturnsFalse_WhenUserNotExists()
    {
        _mockUserRepository.Setup(r => r.GetByIdAsync(999)).ReturnsAsync((User?)null);

        var result = await _userService.ActivateUserAsync(999);

        result.Should().BeFalse();
    }

    [Fact]
    public async Task DeactivateUserAsync_ReturnsTrue_WhenUserExists()
    {
        var user = new User { Id = 1, IsActive = true };
        _mockUserRepository.Setup(r => r.GetByIdAsync(1)).ReturnsAsync(user);
        _mockUserRepository.Setup(r => r.Update(It.IsAny<User>())).Verifiable();
        _mockUserRepository.Setup(r => r.SaveAsync()).ReturnsAsync(1);

        var result = await _userService.DeactivateUserAsync(1);

        result.Should().BeTrue();
    }

    [Fact]
    public async Task DeactivateUserAsync_ReturnsFalse_WhenUserNotExists()
    {
        _mockUserRepository.Setup(r => r.GetByIdAsync(999)).ReturnsAsync((User?)null);

        var result = await _userService.DeactivateUserAsync(999);

        result.Should().BeFalse();
    }

    [Fact]
    public async Task ChangePasswordAsync_CallsRepository()
    {
        _mockUserRepository.Setup(r => r.ChangePasswordAsync(1, "old", "new")).ReturnsAsync(true);

        var result = await _userService.ChangePasswordAsync(1, "old", "new");

        result.Should().BeTrue();
        _mockUserRepository.Verify(r => r.ChangePasswordAsync(1, "old", "new"), Times.Once);
    }
}