using System.Net;
using System.Net.Http.Json;
using System.Text.Json.Nodes;
using FluentResults;
using IdentityShroud.Core.Messages.Realm;
using IdentityShroud.Core.Model;
using IdentityShroud.Core.Services;
using IdentityShroud.Core.Tests.Fixtures;
using IdentityShroud.TestUtils.Asserts;
using Microsoft.AspNetCore.Mvc;
using NSubstitute.ClearExtensions;

namespace IdentityShroud.Api.Tests.Apis;

public class RealmApisTests(ApplicationFactory factory) : IClassFixture<ApplicationFactory>
{
    [Theory]
    [InlineData(null, null, null, false, "Name")]
    [InlineData(null, null, "Foo", true, "")]
    [InlineData(null, null, "", false, "Name")]
    [InlineData(null, "foo", "Foo", true, "")]
    [InlineData(null, "f/oo", "Foo", false, "Slug")]
    [InlineData(null, "", "Foo", false, "Slug")]
    [InlineData("0814934a-efe2-4784-ba84-a184c0b9de9e", "foo", "Foo", true, "")]
    [InlineData("00000000-0000-0000-0000-000000000000", "foo", "Foo", false, "Id")]
    public async Task Create(string? id, string? slug, string? name, bool succeeds, string fieldName)
    {
        var client = factory.CreateClient();

        factory.RealmService.ClearSubstitute();
        factory.RealmService.Create(Arg.Any<RealmCreateRequest>(), Arg.Any<CancellationToken>())
            .Returns(Result.Ok(new RealmCreateResponse(Guid.NewGuid(), "foo", "Foo")));

        Guid? inputId = id is null ? (Guid?)null : new Guid(id);
        var response = await client.PostAsync("/realms", JsonContent.Create(new
            {
                Id = inputId,
                Slug = slug,
                Name = name,
            }),
            TestContext.Current.CancellationToken);
#if DEBUG
        string contents = await response.Content.ReadAsStringAsync(TestContext.Current.CancellationToken);
#endif

        if (succeeds)
        {
            Assert.Equal(HttpStatusCode.Created, response.StatusCode);
            await factory.RealmService.Received(1).Create(
                Arg.Is<RealmCreateRequest>(r => r.Id == inputId && r.Slug == slug && r.Name == name),
                Arg.Any<CancellationToken>());
        }
        else
        {
            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
            var problemDetails =
                await response.Content.ReadFromJsonAsync<ValidationProblemDetails>(
                    TestContext.Current.CancellationToken);

            Assert.Contains(problemDetails!.Errors, e => e.Key == fieldName);
            await factory.RealmService.DidNotReceive().Create(
                Arg.Any<RealmCreateRequest>(),
                Arg.Any<CancellationToken>());
        }
    }

    [Fact]
    public async Task GetOpenIdConfiguration_Success()
    {
        // setup
        factory.RealmService.FindBySlug(Arg.Is<string>("foo"), Arg.Any<CancellationToken>())
            .Returns(new Realm());
        
        // act
        var client = factory.CreateClient();
        var response = await client.GetAsync("/realms/foo/.well-known/openid-configuration",
            TestContext.Current.CancellationToken);

        // verify
        var result = await response.Content.ReadFromJsonAsync<JsonObject>(TestContext.Current.CancellationToken);
        Assert.NotNull(result);
        JsonObjectAssert.Equal("http://localhost/realms/foo/openid-connect/auth", result, "authorization_endpoint");
        JsonObjectAssert.Equal("http://localhost/realms/foo", result, "issuer");
        JsonObjectAssert.Equal("http://localhost/realms/foo/openid-connect/token", result, "token_endpoint");
        JsonObjectAssert.Equal("http://localhost/realms/foo/openid-connect/jwks", result, "jwks_uri");
    }

    [Theory]
    [InlineData("")]
    [InlineData("bar")]
    public async Task GetOpenIdConfiguration_NotFound(string slug)
    {
        // act
        var client = factory.CreateClient();
        var response = await client.GetAsync("/realms/bar/.well-known/openid-configuration",
            TestContext.Current.CancellationToken);
        
        // verify
        Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
    }
}