@using ZB.MOM.WW.ScadaBridge.CentralUI.Services
@using ZB.MOM.WW.ScadaBridge.Commons.Messages.Management
@inject IServiceProvider MutationServices
@page "/notifications/lists"
@using ZB.MOM.WW.ScadaBridge.Security
@using ZB.MOM.WW.ScadaBridge.Commons.Entities.Notifications
@using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Repositories
@using ZB.MOM.WW.ScadaBridge.Commons.Types.Enums
@attribute [Authorize(Policy = AuthorizationPolicies.RequireDesign)]
@inject INotificationRepository NotificationRepository
@inject NavigationManager NavigationManager
@inject IDialogService Dialog

<div class="container-fluid mt-3">
    <ToastNotification @ref="_toast" />

    <div class="page-head justify-content-between">
        <h1 class="mb-0">Notification Lists</h1>
        <button class="btn btn-primary btn-sm"
                @onclick='() => NavigationManager.NavigateTo("/notifications/lists/create")'>
            Add Notification List
        </button>
    </div>

    @if (_loading)
    {
        <LoadingSpinner IsLoading="true" />
    }
    else if (_errorMessage != null)
    {
        <div class="alert alert-danger">@_errorMessage</div>
    }
    else if (_lists.Count == 0)
    {
        <div class="card">
            <div class="card-body text-center text-muted py-5">
                <div class="fs-5 mb-2">No notification lists</div>
                <button class="btn btn-primary btn-sm"
                        @onclick='() => NavigationManager.NavigateTo("/notifications/lists/create")'>
                    Add your first notification list
                </button>
            </div>
        </div>
    }
    else
    {
        <div class="table-responsive" role="region" aria-label="Notification lists" tabindex="0">
            <table class="table table-sm table-hover align-middle">
                <thead>
                    <tr>
                        <th>Name</th>
                        <th>Type</th>
                        <th>Recipients</th>
                        <th class="text-end">Actions</th>
                    </tr>
                </thead>
                <tbody>
                    @foreach (var list in _lists)
                    {
                        var recipients = _recipients.GetValueOrDefault(list.Id)
                            ?? (IReadOnlyList<NotificationRecipient>)Array.Empty<NotificationRecipient>();
                        <tr @key="list.Id">
                            <td><span class="cell-clip" title="@list.Name">@list.Name</span></td>
                            <td>@list.Type</td>
                            <td>
                                @if (recipients.Count == 0)
                                {
                                    <span class="text-muted small fst-italic">No recipients</span>
                                }
                                else
                                {
                                    @foreach (var r in recipients.Take(MaxVisibleRecipients))
                                    {
                                        @* Type-aware contact: SMS recipients carry a PhoneNumber and a null
                                           EmailAddress, so an email-shaped badge would render "Name <>". Fall
                                           back to whichever contact field is populated. The two identifiers
                                           are separated inside the chip — name, then contact in a lighter
                                           weight — rather than fused into one "Name <contact>" run. *@
                                        var contact = list.Type == NotificationType.Sms
                                            ? r.PhoneNumber
                                            : r.EmailAddress;
                                        <span class="badge bg-secondary-subtle text-secondary-emphasis me-1 mb-1"
                                              title="@r.Name — @contact">@r.Name<span class="fw-normal opacity-75 ms-1">@contact</span></span>
                                    }
                                    @if (recipients.Count > MaxVisibleRecipients)
                                    {
                                        @* Long lists roll up rather than filling the cell with chips.
                                           The remainder stays readable on the tooltip, and the full set
                                           is always available on the list's Edit page. *@
                                        <span class="badge bg-body-secondary text-body-secondary border"
                                              title="@RemainingRecipientsTitle(list, recipients)">
                                            +@(recipients.Count - MaxVisibleRecipients) more
                                        </span>
                                    }
                                }
                            </td>
                            <td class="text-end">
                                <div class="btn-group btn-group-sm" role="group">
                                    <button class="btn btn-outline-primary"
                                            @onclick='() => NavigationManager.NavigateTo($"/notifications/lists/{list.Id}/edit")'>
                                        Edit
                                    </button>
                                    <button class="btn btn-outline-danger"
                                            @onclick="() => DeleteList(list)">
                                        Delete
                                    </button>
                                </div>
                            </td>
                        </tr>
                    }
                </tbody>
            </table>
        </div>
    }
</div>

@code {
    /// <summary>
    /// Recipient chips rendered inline before the "+N more" roll-up. A list may
    /// hold dozens of recipients and the cell is uncapped, so the grid would
    /// otherwise render one chip per recipient into a single row.
    /// </summary>
    private const int MaxVisibleRecipients = 5;

    private bool _loading = true;
    private string? _errorMessage;
    private List<NotificationList> _lists = new();
    private readonly Dictionary<int, IReadOnlyList<NotificationRecipient>> _recipients = new();
    private ToastNotification _toast = default!;

    protected override async Task OnInitializedAsync() => await LoadAsync();

    private async Task LoadAsync()
    {
        _loading = true;
        _errorMessage = null;
        try
        {
            _lists = (await NotificationRepository.GetAllNotificationListsAsync()).ToList();
            _recipients.Clear();
            foreach (var list in _lists)
            {
                _recipients[list.Id] = await NotificationRepository.GetRecipientsByListIdAsync(list.Id);
            }
        }
        catch (Exception ex)
        {
            _errorMessage = $"Failed to load notification lists: {ex.Message}";
        }
        _loading = false;
    }

    /// <summary>
    /// Tooltip for the "+N more" roll-up chip: the recipients that were not given
    /// a chip of their own, using the same type-aware contact field as the chips.
    /// </summary>
    private static string RemainingRecipientsTitle(
        NotificationList list, IReadOnlyList<NotificationRecipient> recipients) =>
        string.Join(", ", recipients
            .Skip(MaxVisibleRecipients)
            .Select(r => $"{r.Name} — {(list.Type == NotificationType.Sms ? r.PhoneNumber : r.EmailAddress)}"));

    private async Task DeleteList(NotificationList list)
    {
        if (!await Dialog.ConfirmAsync("Delete", $"Delete notification list '{list.Name}'?", danger: true))
        {
            return;
        }
        try
        {
            await MutationServices.ExecuteConfigurationAsync(new DeleteNotificationListCommand(list.Id));
            _toast.ShowSuccess("Deleted.");
            await LoadAsync();
        }
        catch (Exception ex)
        {
            _toast.ShowError($"Failed to delete notification list: {ex.Message}");
        }
    }
}