using System.Net;
using System.Text.Json;
using Microsoft.Extensions.Logging.Abstractions;
using NSubstitute;

namespace ScadaLink.NotificationService.Tests;

/// <summary>
/// Tests for OAuth2 token flow — token acquisition, caching, and credential parsing.
/// </summary>
public class OAuth2TokenServiceTests
{
    private static HttpClient CreateMockHttpClient(HttpStatusCode statusCode, string responseJson)
    {
        var handler = new MockHttpMessageHandler(statusCode, responseJson);
        return new HttpClient(handler);
    }

    private static IHttpClientFactory CreateMockFactory(HttpClient client)
    {
        var factory = Substitute.For<IHttpClientFactory>();
        factory.CreateClient(Arg.Any<string>()).Returns(client);
        return factory;
    }

    [Fact]
    public async Task GetTokenAsync_ReturnsAccessToken_FromTokenEndpoint()
    {
        var tokenResponse = JsonSerializer.Serialize(new
        {
            access_token = "mock-access-token-12345",
            expires_in = 3600,
            token_type = "Bearer"
        });

        var client = CreateMockHttpClient(HttpStatusCode.OK, tokenResponse);
        var factory = CreateMockFactory(client);
        var service = new OAuth2TokenService(factory, NullLogger<OAuth2TokenService>.Instance);

        var token = await service.GetTokenAsync("tenant123:client456:secret789");

        Assert.Equal("mock-access-token-12345", token);
    }

    [Fact]
    public async Task GetTokenAsync_CachesToken_OnSubsequentCalls()
    {
        var tokenResponse = JsonSerializer.Serialize(new
        {
            access_token = "cached-token",
            expires_in = 3600,
            token_type = "Bearer"
        });

        var handler = new CountingHttpMessageHandler(HttpStatusCode.OK, tokenResponse);
        var client = new HttpClient(handler);
        var factory = CreateMockFactory(client);
        var service = new OAuth2TokenService(factory, NullLogger<OAuth2TokenService>.Instance);

        var token1 = await service.GetTokenAsync("tenant:client:secret");
        var token2 = await service.GetTokenAsync("tenant:client:secret");

        Assert.Equal("cached-token", token1);
        Assert.Equal("cached-token", token2);
        Assert.Equal(1, handler.CallCount); // Only one HTTP call should be made
    }

    [Fact]
    public async Task GetTokenAsync_InvalidCredentialFormat_ThrowsInvalidOperationException()
    {
        var client = CreateMockHttpClient(HttpStatusCode.OK, "{}");
        var factory = CreateMockFactory(client);
        var service = new OAuth2TokenService(factory, NullLogger<OAuth2TokenService>.Instance);

        await Assert.ThrowsAsync<InvalidOperationException>(
            () => service.GetTokenAsync("invalid-no-colons"));
    }

    [Fact]
    public async Task GetTokenAsync_HttpFailure_ThrowsHttpRequestException()
    {
        var client = CreateMockHttpClient(HttpStatusCode.Unauthorized, "Unauthorized");
        var factory = CreateMockFactory(client);
        var service = new OAuth2TokenService(factory, NullLogger<OAuth2TokenService>.Instance);

        await Assert.ThrowsAsync<HttpRequestException>(
            () => service.GetTokenAsync("tenant:client:secret"));
    }

    /// <summary>
    /// Simple mock HTTP handler that returns a fixed response.
    /// </summary>
    private class MockHttpMessageHandler : HttpMessageHandler
    {
        private readonly HttpStatusCode _statusCode;
        private readonly string _responseContent;

        public MockHttpMessageHandler(HttpStatusCode statusCode, string responseContent)
        {
            _statusCode = statusCode;
            _responseContent = responseContent;
        }

        protected override Task<HttpResponseMessage> SendAsync(
            HttpRequestMessage request, CancellationToken cancellationToken)
        {
            return Task.FromResult(new HttpResponseMessage(_statusCode)
            {
                Content = new StringContent(_responseContent)
            });
        }
    }

    /// <summary>
    /// Mock HTTP handler that counts invocations.
    /// </summary>
    private class CountingHttpMessageHandler : HttpMessageHandler
    {
        private readonly HttpStatusCode _statusCode;
        private readonly string _responseContent;
        public int CallCount { get; private set; }

        public CountingHttpMessageHandler(HttpStatusCode statusCode, string responseContent)
        {
            _statusCode = statusCode;
            _responseContent = responseContent;
        }

        protected override Task<HttpResponseMessage> SendAsync(
            HttpRequestMessage request, CancellationToken cancellationToken)
        {
            CallCount++;
            return Task.FromResult(new HttpResponseMessage(_statusCode)
            {
                Content = new StringContent(_responseContent)
            });
        }
    }
}