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

namespace Haoliang.Tests;

public class AuthServiceTests
{
    private readonly Mock<IUserRepository> _mockUserRepository;
    private readonly Mock<ICacheService> _mockCacheService;
    private readonly AuthService _authService;

    public AuthServiceTests()
    {
        _mockUserRepository = new Mock<IUserRepository>();
        _mockCacheService = new Mock<ICacheService>();
        _authService = new AuthService(_mockUserRepository.Object, _mockCacheService.Object);
    }

    [Fact]
    public async Task LoginAsync_ReturnsSuccess_WhenCredentialsValid()
    {
        var request = new LoginRequest { Username = "admin", Password = "password" };
        var user = new User 
        { 
            Id = 1, 
            Username = "admin", 
            RealName = "Administrator",
            Role = new Role { RoleName = "Admin", Permissions = new List<string> { "read", "write" } }
        };
        _mockUserRepository.Setup(r => r.AuthenticateAsync("admin", "password")).ReturnsAsync(user);

        var result = await _authService.LoginAsync(request);

        result.Success.Should().BeTrue();
        result.User.Should().NotBeNull();
        result.User!.Username.Should().Be("admin");
        result.Permissions.Should().Contain("read");
    }

    [Fact]
    public async Task LoginAsync_ReturnsFailure_WhenCredentialsInvalid()
    {
        var request = new LoginRequest { Username = "admin", Password = "wrongpassword" };
        _mockUserRepository.Setup(r => r.AuthenticateAsync("admin", "wrongpassword")).ReturnsAsync((User?)null);

        var result = await _authService.LoginAsync(request);

        result.Success.Should().BeFalse();
        result.Message.Should().Be("用户名或密码错误");
    }

    [Fact]
    public async Task LogoutAsync_ReturnsTrue()
    {
        var result = await _authService.LogoutAsync(1);

        result.Should().BeTrue();
    }

    [Fact]
    public async Task RefreshTokenAsync_ReturnsNull()
    {
        var result = await _authService.RefreshTokenAsync("someRefreshToken");

        result.Should().BeNull();
    }

    [Fact]
    public async Task UsernameExistsAsync_ReturnsTrue_WhenExists()
    {
        _mockUserRepository.Setup(r => r.UsernameExistsAsync("admin")).ReturnsAsync(true);

        var result = await _authService.UsernameExistsAsync("admin");

        result.Should().BeTrue();
    }

    [Fact]
    public async Task UsernameExistsAsync_ReturnsFalse_WhenNotExists()
    {
        _mockUserRepository.Setup(r => r.UsernameExistsAsync("nonexistent")).ReturnsAsync(false);

        var result = await _authService.UsernameExistsAsync("nonexistent");

        result.Should().BeFalse();
    }

    [Fact]
    public async Task EmailExistsAsync_ReturnsTrue_WhenExists()
    {
        _mockUserRepository.Setup(r => r.EmailExistsAsync("admin@example.com")).ReturnsAsync(true);

        var result = await _authService.EmailExistsAsync("admin@example.com");

        result.Should().BeTrue();
    }

    [Fact]
    public async Task EmailExistsAsync_ReturnsFalse_WhenNotExists()
    {
        _mockUserRepository.Setup(r => r.EmailExistsAsync("nonexistent@example.com")).ReturnsAsync(false);

        var result = await _authService.EmailExistsAsync("nonexistent@example.com");

        result.Should().BeFalse();
    }

    [Fact]
    public async Task GetUserByIdAsync_ReturnsUser_WhenExists()
    {
        var user = new User { Id = 1, Username = "admin", RealName = "Administrator" };
        _mockUserRepository.Setup(r => r.GetByIdAsync(1)).ReturnsAsync(user);

        var result = await _authService.GetUserByIdAsync(1);

        result.Should().NotBeNull();
        result!.Id.Should().Be(1);
        result.Username.Should().Be("admin");
    }

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

        var result = await _authService.GetUserByIdAsync(999);

        result.Should().BeNull();
    }
}