using System.Security.Claims;
using Bunit;
using Microsoft.AspNetCore.Components.Authorization;
using Microsoft.Extensions.DependencyInjection;
using NSubstitute;
using ZB.MOM.WW.ScadaBridge.CentralUI.Components.Shared;
using ZB.MOM.WW.ScadaBridge.CentralUI.Services;
using ZB.MOM.WW.ScadaBridge.Commons.Entities.Schemas;
using ZB.MOM.WW.ScadaBridge.Security;
using SchemaLibraryPage = ZB.MOM.WW.ScadaBridge.CentralUI.Components.Pages.Design.SchemaLibrary;

namespace ZB.MOM.WW.ScadaBridge.CentralUI.Tests.Design;

/// <summary>
/// bUnit tests for the Schema Library page. The page lists the reusable named
/// JSON-Schema library entries, authors create/edit via the shared <c>SchemaBuilder</c>
/// component, and deletes with a confirm — every mutation dispatched through
/// <see cref="ISchemaLibraryService"/> (the guard-running ManagementActor path), never a
/// direct repo write. The service is substituted so the tests capture the dispatched
/// commands and simulate success / guard-error responses without a real ManagementActor.
/// </summary>
public class SchemaLibraryPageTests : BunitContext
{
    private readonly ISchemaLibraryService _service = Substitute.For<ISchemaLibraryService>();

    /// <summary>Initializes the test context with a substituted schema library service and an auto-confirming dialog service.</summary>
    public SchemaLibraryPageTests()
    {
        Services.AddSingleton(_service);
        Services.AddSingleton<IDialogService>(new AlwaysConfirmDialogService());
        AddTestAuth();

        // Default: empty library. Tests that need rows override this.
        _service.ListAsync(Arg.Any<CancellationToken>())
            .Returns(Task.FromResult<IReadOnlyList<SharedSchema>>(new List<SharedSchema>()));
    }

    private void AddTestAuth()
    {
        var claims = new[]
        {
            new Claim(JwtTokenService.UsernameClaimType, "tester"),
            new Claim(JwtTokenService.RoleClaimType, "Designer"),
        };
        var user = new ClaimsPrincipal(new ClaimsIdentity(claims, "TestAuth"));
        Services.AddSingleton<AuthenticationStateProvider>(new TestAuthStateProvider(user));
        Services.AddAuthorizationCore();
        Services.AddTestConfigurationMutations();
    }

    private void SeedSchemas(params SharedSchema[] schemas) =>
        _service.ListAsync(Arg.Any<CancellationToken>())
            .Returns(Task.FromResult<IReadOnlyList<SharedSchema>>(schemas.ToList()));

    /// <summary>Verifies that the page renders the empty state when there are no schemas.</summary>
    [Fact]
    public void Renders_EmptyState_WhenNoSchemas()
    {
        var cut = Render<SchemaLibraryPage>();

        cut.WaitForAssertion(() =>
            Assert.Contains("No library schemas defined", cut.Markup));
    }

    /// <summary>Verifies that existing schemas are listed together with their library reference.</summary>
    [Fact]
    public void Lists_ExistingSchemas_WithLibReference()
    {
        SeedSchemas(
            new SharedSchema { Id = 1, Name = "Address", Scope = "global", SchemaJson = "{\"type\":\"object\"}" },
            new SharedSchema { Id = 2, Name = "GeoPoint", SchemaJson = "{\"type\":\"object\"}" });

        var cut = Render<SchemaLibraryPage>();

        cut.WaitForAssertion(() =>
        {
            Assert.Contains("Address", cut.Markup);
            Assert.Contains("GeoPoint", cut.Markup);
            // The list surfaces the lib:Name reference designers paste into a $ref.
            Assert.Contains("lib:Address", cut.Markup);
        });
    }

    /// <summary>Verifies that choosing New Schema opens the editor with the schema builder.</summary>
    [Fact]
    public void NewSchema_OpensEditor_WithSchemaBuilder()
    {
        var cut = Render<SchemaLibraryPage>();
        cut.WaitForState(() => cut.Markup.Contains("No library schemas defined"));

        cut.FindAll("button").First(b => b.TextContent.Contains("New Schema")).Click();

        // The editor card mounts with a name field and the SchemaBuilder component.
        Assert.Contains("New Schema", cut.Markup);
        Assert.NotEmpty(cut.FindAll("input")); // name / scope inputs
        Assert.NotNull(cut.FindComponent<SchemaBuilder>());
    }

    /// <summary>Verifies that creating a schema dispatches a create command carrying the name and schema.</summary>
    [Fact]
    public void Create_DispatchesCreateCommand_WithNameAndSchema()
    {
        _service.CreateAsync(Arg.Any<string>(), Arg.Any<string?>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
            .Returns(Task.FromResult(SchemaLibraryActionResult.Ok()));

        var cut = Render<SchemaLibraryPage>();
        cut.WaitForState(() => cut.Markup.Contains("No library schemas defined"));

        cut.FindAll("button").First(b => b.TextContent.Contains("New Schema")).Click();

        // Type a name and save (the SchemaBuilder seeds a default object schema).
        cut.FindAll("input").First().Change("Address");
        cut.FindAll("button").First(b => b.TextContent.Trim() == "Save").Click();

        cut.WaitForAssertion(() =>
            _service.Received(1).CreateAsync(
                "Address", Arg.Any<string?>(), Arg.Any<string>(), Arg.Any<CancellationToken>()));
    }

    /// <summary>Verifies that a guard error from a create is shown inline and the editor stays open.</summary>
    [Fact]
    public void Create_GuardError_IsShownInline_AndEditorStaysOpen()
    {
        _service.CreateAsync(Arg.Any<string>(), Arg.Any<string?>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
            .Returns(Task.FromResult(SchemaLibraryActionResult.Fail("A schema named 'Address' already exists.")));

        var cut = Render<SchemaLibraryPage>();
        cut.WaitForState(() => cut.Markup.Contains("No library schemas defined"));

        cut.FindAll("button").First(b => b.TextContent.Contains("New Schema")).Click();
        cut.FindAll("input").First().Change("Address");
        cut.FindAll("button").First(b => b.TextContent.Trim() == "Save").Click();

        cut.WaitForAssertion(() =>
        {
            Assert.Contains("already exists", cut.Markup);
            // Editor stays open (Save button still present) on a guard error.
            Assert.Contains(cut.FindAll("button"), b => b.TextContent.Trim() == "Save");
        });
    }

    /// <summary>Verifies that saving with an empty name dispatches no command.</summary>
    [Fact]
    public void EmptyName_DoesNotDispatch()
    {
        var cut = Render<SchemaLibraryPage>();
        cut.WaitForState(() => cut.Markup.Contains("No library schemas defined"));

        cut.FindAll("button").First(b => b.TextContent.Contains("New Schema")).Click();
        // Leave name blank and save.
        cut.FindAll("button").First(b => b.TextContent.Trim() == "Save").Click();

        cut.WaitForAssertion(() => Assert.Contains("name is required", cut.Markup));
        _service.DidNotReceive().CreateAsync(
            Arg.Any<string>(), Arg.Any<string?>(), Arg.Any<string>(), Arg.Any<CancellationToken>());
    }

    /// <summary>Verifies that deleting a schema confirms first, dispatches a delete command and reloads the list.</summary>
    [Fact]
    public void Delete_ConfirmsThenDispatchesDeleteCommand_AndReloads()
    {
        SeedSchemas(new SharedSchema { Id = 7, Name = "Address", SchemaJson = "{\"type\":\"object\"}" });
        _service.DeleteAsync(Arg.Any<int>(), Arg.Any<CancellationToken>())
            .Returns(Task.FromResult(SchemaLibraryActionResult.Ok()));

        var cut = Render<SchemaLibraryPage>();
        cut.WaitForState(() => cut.Markup.Contains("Address"));

        cut.FindAll("tbody tr button").First(b => b.TextContent.Contains("Delete")).Click();

        cut.WaitForAssertion(() =>
        {
            _service.Received(1).DeleteAsync(7, Arg.Any<CancellationToken>());
            // Reload re-invokes the list query (once on init, once after delete).
            _service.Received(2).ListAsync(Arg.Any<CancellationToken>());
        });
    }

    /// <summary>Verifies that editing a schema opens the editor and dispatches an update command.</summary>
    [Fact]
    public void Edit_OpensEditor_AndDispatchesUpdateCommand()
    {
        SeedSchemas(new SharedSchema { Id = 9, Name = "Address", Scope = "us", SchemaJson = "{\"type\":\"object\"}" });
        _service.UpdateAsync(Arg.Any<int>(), Arg.Any<string>(), Arg.Any<string?>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
            .Returns(Task.FromResult(SchemaLibraryActionResult.Ok()));

        var cut = Render<SchemaLibraryPage>();
        cut.WaitForState(() => cut.Markup.Contains("Address"));

        cut.FindAll("tbody tr button").First(b => b.TextContent.Contains("Edit")).Click();
        Assert.Contains("Edit Schema: Address", cut.Markup);

        cut.FindAll("button").First(b => b.TextContent.Trim() == "Save").Click();

        cut.WaitForAssertion(() =>
            _service.Received(1).UpdateAsync(
                9, "Address", Arg.Any<string?>(), Arg.Any<string>(), Arg.Any<CancellationToken>()));
    }

    /// <summary>Verifies that row actions are disabled while the editor is open so the row under edit cannot be deleted.</summary>
    [Fact]
    public void Editing_DisablesRowActions_SoTheRowUnderEditCannotBeDeleted()
    {
        // While the edit form is open the list still shows the row, but its
        // Edit/Delete actions must be disabled so the row under edit (or a sibling)
        // can't be deleted out from under the form.
        SeedSchemas(new SharedSchema { Id = 9, Name = "Address", Scope = "us", SchemaJson = "{\"type\":\"object\"}" });

        var cut = Render<SchemaLibraryPage>();
        cut.WaitForState(() => cut.Markup.Contains("Address"));

        cut.FindAll("tbody tr button").First(b => b.TextContent.Contains("Edit")).Click();
        Assert.Contains("Edit Schema: Address", cut.Markup);

        // Every row action button is now disabled while the editor is open.
        var rowButtons = cut.FindAll("tbody tr button");
        Assert.NotEmpty(rowButtons);
        Assert.All(rowButtons, b => Assert.True(b.HasAttribute("disabled")));
    }

    /// <summary>A dialog service that auto-confirms, so the delete path runs end-to-end.</summary>
    private sealed class AlwaysConfirmDialogService : IDialogService
    {
        /// <inheritdoc />
        public Task<bool> ConfirmAsync(string title, string message, bool danger = false, string? confirmLabel = null)
            => Task.FromResult(true);

        // Register row 75 added a DialogSeverity overload. This stub auto-confirms
        // regardless of severity — it exists to let action paths run end to end, not to
        // assert anything about styling.
        /// <inheritdoc />
        public Task<bool> ConfirmAsync(string title, string message, DialogSeverity severity, string? confirmLabel = null)
            => Task.FromResult(true);

        /// <inheritdoc />
        public Task<string?> PromptAsync(
            string title, string label, string initialValue = "", string? placeholder = null)
            => Task.FromResult<string?>(null);

        /// <summary>Returns the default result without showing a dialog.</summary>
        /// <typeparam name="TResult">The type of result the dialog would produce.</typeparam>
        /// <param name="title">The dialog title.</param>
        /// <param name="body">The dialog body fragment.</param>
        /// <param name="size">The optional dialog size.</param>
        /// <returns>A task whose result is the default value of <typeparamref name="TResult"/>.</returns>
        public Task<TResult?> ShowAsync<TResult>(
            string title,
            Microsoft.AspNetCore.Components.RenderFragment<DialogContext<TResult>> body,
            string? size = null)
            => Task.FromResult<TResult?>(default);
    }
}