using System.Net;
using System.Text;
using BigRegister.Api.Data;
using BigRegister.Api.Zgw;

namespace BigRegister.Tests;

/// <summary>
/// Exercises the OpenZaak read source against a stub HttpMessageHandler (no live server, no
/// mocking library) — the guarantee that it follows ZGW pagination, resolves + caches
/// zaaktype labels, and always sends a Bearer token.
/// </summary>
public class OpenZaakZaakSourceTests
{
  private const string ZrcBase = "https://oz.example/zaken/api/v1";
  private const string ZtBase = "https://oz.example/catalogi/api/v1";

  private static string Page1 => $$"""
    { "count": 2, "next": "{{ZrcBase}}/zaken?page=2", "results": [
      { "url": "{{ZrcBase}}/zaken/uuid-1", "identificatie": "ZAAK-1",
        "zaaktype": "{{ZtBase}}/zaaktypen/zt-1", "startdatum": "2026-03-01",
        "einddatum": null, "registratiedatum": "2026-03-01" } ] }
    """;

  private static string Page2 => $$"""
    { "count": 2, "next": null, "results": [
      { "url": "{{ZrcBase}}/zaken/uuid-2", "identificatie": "ZAAK-2",
        "zaaktype": "{{ZtBase}}/zaaktypen/zt-1", "startdatum": "2026-01-01",
        "einddatum": "2026-02-01", "registratiedatum": "2026-01-01" } ] }
    """;

  private const string Zaaktype = """{ "omschrijving": "Herregistratie arts" }""";

  [Fact]
  public void Follows_pagination_caches_zaaktype_and_sends_bearer_token()
  {
    var handler = new StubHandler(url => url switch
    {
      _ when url == $"{ZrcBase}/zaken" => Page1,
      _ when url == $"{ZrcBase}/zaken?page=2" => Page2,
      _ when url == $"{ZtBase}/zaaktypen/zt-1" => Zaaktype,
      _ => throw new InvalidOperationException($"unexpected ZGW GET {url}"),
    });

    var options = new ZgwOptions { ZrcBaseUrl = ZrcBase, ZtcBaseUrl = ZtBase, ClientId = "c", Secret = "s" };
    var source = new OpenZaakZaakSource(new HttpClient(handler), new ZgwTokenProvider(options), options);

    var cases = source.ListCases(DateTimeOffset.UtcNow);

    // Both pages accumulated.
    Assert.Equal(2, cases.Count);
    Assert.Equal(new[] { "uuid-1", "uuid-2" }, cases.Select(c => c.Id));
    Assert.All(cases, c => Assert.Equal("Herregistratie arts", c.Type));
    Assert.Equal("InBehandeling", cases[0].Status.Tag);   // open
    Assert.Equal("Goedgekeurd", cases[1].Status.Tag);     // closed

    // Zaaktype resolved once despite two zaken sharing it (cache).
    Assert.Single(handler.Requests, r => r.Contains("zaaktypen"));
    // Every outbound request carried a Bearer token.
    Assert.All(handler.AuthSchemes, s => Assert.Equal("Bearer", s));
  }

  [Fact]
  public void CreateZaak_posts_zaak_status_and_rol_and_maps_the_result_back()
  {
    const string zaaktypeUrl = $"{ZtBase}/zaaktypen/zt-registratie";
    var handler = new StubHandler(url => url switch
    {
      _ when url == $"{ZrcBase}/zaken" => $$"""
        { "url": "{{ZrcBase}}/zaken/uuid-new", "identificatie": "BIG-2026-000123",
          "zaaktype": "{{zaaktypeUrl}}", "startdatum": "2026-07-28",
          "einddatum": null, "registratiedatum": "2026-07-28" }
        """,
      _ when url.StartsWith($"{ZtBase}/statustypen") => """
        { "count": 1, "next": null,
          "results": [ { "url": "https://oz.example/catalogi/api/v1/statustypen/st-1", "volgnummer": 1 } ] }
        """,
      _ when url.StartsWith($"{ZtBase}/roltypen") => """
        { "count": 1, "next": null,
          "results": [ { "url": "https://oz.example/catalogi/api/v1/roltypen/rt-initiator" } ] }
        """,
      _ when url == $"{ZrcBase}/statussen" => "{}",
      _ when url == $"{ZrcBase}/rollen" => "{}",
      _ => throw new InvalidOperationException($"unexpected ZGW call {url}"),
    });

    var options = new ZgwOptions
    {
      ZrcBaseUrl = ZrcBase,
      ZtcBaseUrl = ZtBase,
      ClientId = "c",
      Secret = "s",
      Bronorganisatie = "123443210",
      VerantwoordelijkeOrganisatie = "123443210",
      ZaaktypeUrls = new() { ["registratie"] = zaaktypeUrl },
    };
    var source = new OpenZaakZaakSource(new HttpClient(handler), new ZgwTokenProvider(options), options);
    var aanvraag = new Aanvraag
    {
      Id = "a1",
      Type = "registratie",
      Owner = "111222333",
      Referentie = "BIG-2026-000123",
    };

    var (referentie, status) = source.CreateZaak(aanvraag, new DateTimeOffset(2026, 7, 28, 12, 0, 0, TimeSpan.Zero));

    Assert.Equal("BIG-2026-000123", referentie);
    Assert.Equal("InBehandeling", status.Tag);
    Assert.Equal("BIG-2026-000123", status.Referentie);

    string BodyOf(string url) => handler.Bodies[handler.Requests.LastIndexOf(url)];

    // Zaak: mapped zaaktype + configured RSINs + the local reference as identificatie.
    var zaakBody = BodyOf($"{ZrcBase}/zaken");
    Assert.Contains(zaaktypeUrl, zaakBody);
    Assert.Contains("123443210", zaakBody);
    Assert.Contains("BIG-2026-000123", zaakBody);

    // Status: points at the created zaak's URL and the resolved statustype.
    var statusBody = BodyOf($"{ZrcBase}/statussen");
    Assert.Contains($"{ZrcBase}/zaken/uuid-new", statusBody);
    Assert.Contains("statustypen/st-1", statusBody);

    // Rol: points at the created zaak, the resolved initiator roltype, and the BSN.
    var rolBody = BodyOf($"{ZrcBase}/rollen");
    Assert.Contains($"{ZrcBase}/zaken/uuid-new", rolBody);
    Assert.Contains("roltypen/rt-initiator", rolBody);
    Assert.Contains("111222333", rolBody);
  }

  [Fact]
  public void CreateZaak_throws_when_the_aanvraag_type_has_no_configured_zaaktype()
  {
    var options = new ZgwOptions { ZrcBaseUrl = ZrcBase, ZtcBaseUrl = ZtBase, ClientId = "c", Secret = "s" };
    var handler = new StubHandler(url => throw new InvalidOperationException($"no HTTP call expected, got {url}"));
    var source = new OpenZaakZaakSource(new HttpClient(handler), new ZgwTokenProvider(options), options);
    var aanvraag = new Aanvraag { Id = "a1", Type = "unknown-type", Owner = "111222333", Referentie = "BIG-2026-000123" };

    Assert.Throws<InvalidOperationException>(() => source.CreateZaak(aanvraag, DateTimeOffset.UtcNow));
  }

  private sealed class StubHandler(Func<string, string> respond) : HttpMessageHandler
  {
    public List<string> Requests { get; } = new();
    public List<string?> AuthSchemes { get; } = new();
    public List<string> Bodies { get; } = new();

    protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
    {
      var url = request.RequestUri!.ToString();
      Requests.Add(url);
      AuthSchemes.Add(request.Headers.Authorization?.Scheme);
      Bodies.Add(request.Content?.ReadAsStringAsync(cancellationToken).GetAwaiter().GetResult() ?? "");
      return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
      {
        Content = new StringContent(respond(url), Encoding.UTF8, "application/json"),
      });
    }
  }
}