using GameAuthApi.Controllers;
using GameAuthApi.Models;
using GameAuthApi.Services;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.IdentityModel.Tokens;
using System.IdentityModel.Tokens.Jwt;
using System.Text;

public class AuthControllerTests
{
    private static IConfiguration GetConfig()
    {
        var inMemory = new Dictionary<string, string>
        {
            {"Jwt:Key", "testkeytestkeytestkey"},
            {"Jwt:Issuer", "issuer"},
            {"MongoDB:ConnectionString", "mongodb://localhost"},
            {"MongoDB:DatabaseName", "test"}
        };
        return new ConfigurationBuilder().AddInMemoryCollection(inMemory!).Build();
    }

    [Fact]
    public async Task Register_UserExists_ReturnsBadRequest()
    {
        var mockUser = new Mock<UserService>(GetConfig());
        mockUser.Setup(u => u.GetByUsernameAsync("exists")).ReturnsAsync(new User());
        var mockBlacklist = new Mock<BlacklistService>(GetConfig());
        var controller = new AuthController(mockUser.Object, GetConfig(), mockBlacklist.Object);

        var result = await controller.Register(new RegisterRequest { Username = "exists", Password = "p" });

        Assert.IsType<BadRequestObjectResult>(result);
    }

    [Fact]
    public async Task Login_InvalidPassword_ReturnsUnauthorized()
    {
        var user = new User { Username = "user", PasswordHash = BCrypt.Net.BCrypt.HashPassword("other") };
        var mockUser = new Mock<UserService>(GetConfig());
        mockUser.Setup(u => u.GetByUsernameAsync("user")).ReturnsAsync(user);
        var controller = new AuthController(mockUser.Object, GetConfig(), new Mock<BlacklistService>(GetConfig()).Object);

        var result = await controller.Login(new LoginRequest { Username = "user", Password = "bad" });

        Assert.IsType<UnauthorizedResult>(result);
    }

    [Fact]
    public async Task Login_EmailIdentifier_ReturnsTokens()
    {
        var config = new ConfigurationBuilder().AddInMemoryCollection(new Dictionary<string, string?>
        {
            ["Jwt:Key"] = "abcdefghijklmnopqrstuvwxyz123456",
            ["Jwt:Issuer"] = "issuer",
            ["MongoDB:ConnectionString"] = "mongodb://localhost",
            ["MongoDB:DatabaseName"] = "test"
        }).Build();
        var user = new User
        {
            Id = "507f1f77bcf86cd799439011", Username = "student", Email = "student@example.com",
            PasswordHash = BCrypt.Net.BCrypt.HashPassword("password123"), Role = "USER"
        };
        var users = new Mock<UserService>(config);
        users.Setup(x => x.GetByLoginAsync("student@example.com")).ReturnsAsync(user);
        users.Setup(x => x.UpdateAsync(user)).Returns(Task.CompletedTask);
        var controller = new AuthController(users.Object, config, new Mock<BlacklistService>(config).Object);

        var result = await controller.Login(new LoginRequest { Username = "student@example.com", Password = "password123" });

        Assert.IsType<OkObjectResult>(result);
        Assert.False(string.IsNullOrWhiteSpace(user.RefreshToken));
    }

    [Fact]
    public async Task Register_DuplicateEmail_ReturnsBadRequest()
    {
        var config = GetConfig();
        var users = new Mock<UserService>(config);
        users.Setup(x => x.GetByLoginAsync("new_user")).ReturnsAsync((User?)null);
        users.Setup(x => x.GetByLoginAsync("used@example.com")).ReturnsAsync(new User());
        var controller = new AuthController(users.Object, config, new Mock<BlacklistService>(config).Object);

        var result = await controller.Register(new RegisterRequest
        {
            Username = "new_user", Email = "used@example.com", Password = "password123"
        });

        Assert.IsType<BadRequestObjectResult>(result);
    }

    [Fact]
    public async Task Refresh_InvalidToken_ReturnsUnauthorized()
    {
        var user = new User { Username = "user", RefreshToken = "r", RefreshTokenExpiry = DateTime.UtcNow.AddMinutes(-1) };
        var mockUser = new Mock<UserService>(GetConfig());
        mockUser.Setup(u => u.GetByUsernameAsync("user")).ReturnsAsync(user);
        var controller = new AuthController(mockUser.Object, GetConfig(), new Mock<BlacklistService>(GetConfig()).Object);

        var result = await controller.Refresh(new AuthController.RefreshRequest { Username = "user", RefreshToken = "bad" });

        Assert.IsType<UnauthorizedObjectResult>(result);
    }

    [Fact]
    public async Task Logout_BlacklistsToken()
    {
        var mockUser = new Mock<UserService>(GetConfig());
        var blacklist = new Mock<BlacklistService>(GetConfig());
        blacklist.Setup(b => b.AddToBlacklistAsync(It.IsAny<string>(), It.IsAny<DateTime>())).Returns(Task.CompletedTask).Verifiable();
        var controller = new AuthController(mockUser.Object, GetConfig(), blacklist.Object);
        controller.ControllerContext = new ControllerContext
        {
            HttpContext = new DefaultHttpContext()
        };
        var tokenHandler = new JwtSecurityTokenHandler();
        var keyString = "abcdefghijklmnopqrstuvwxyz123456";
        var key = Encoding.UTF8.GetBytes(keyString);
        var token = tokenHandler.WriteToken(new JwtSecurityToken(
            "issuer", "issuer", null,
            expires: DateTime.UtcNow.AddMinutes(1),
            signingCredentials: new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256)));
        controller.Request.Headers["Authorization"] = $"Bearer {token}";

        var result = await controller.Logout();

        Assert.IsType<OkObjectResult>(result);
        blacklist.Verify();
    }

    [Fact]
    public async Task ChangeUserRole_InvalidRole_ReturnsBadRequest()
    {
        var svc = new Mock<UserService>(GetConfig());
        var controller = new AuthController(svc.Object, GetConfig(), new Mock<BlacklistService>(GetConfig()).Object);
        var result = await controller.ChangeUserRole(new ChangeRoleRequest { Username="u", NewRole="BAD" });
        Assert.IsType<BadRequestObjectResult>(result);
    }

    [Fact]
    public async Task GetAllUsers_ReturnsOk()
    {
        var users = new List<User>();
        var svc = new Mock<UserService>(GetConfig());
        svc.Setup(s => s.GetAllAsync()).ReturnsAsync(users);
        var controller = new AuthController(svc.Object, GetConfig(), new Mock<BlacklistService>(GetConfig()).Object);

        var result = await controller.GetAllUsers();

        var ok = Assert.IsType<OkObjectResult>(result);
        Assert.Equal(users, ok.Value);
    }
}