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 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);
    }
}