@inherits RecordTabBase<EventRow>
@using Microsoft.Extensions.DependencyInjection
@using MeterVault.Infrastructure.Ingestion
@inject IServiceScopeFactory Scopes
@inject IDialogService DialogService
@inject ISnackbar Snackbar

@* A meter's events (brief §7.2, D-50): swaps and resets that keep a register's history continuous, a tank's levels and
   deliveries, notes. Recorded through MeterEventService (the dialog), deleted there too — an imported one only by
   reverting its import. Paged and filtered by the page period. *@

<div class="d-flex align-center justify-space-between flex-wrap mb-3" style="gap:.5rem">
    <MudText Typo="Typo.body2" Class="mv-muted">@EventsHint</MudText>
    <MudMenu Label="@S.MeterDetail_RecordEvent" Variant="Variant.Filled" Color="Color.Primary" Size="Size.Small"
             StartIcon="@Icons.Material.Filled.Add" EndIcon="@Icons.Material.Filled.KeyboardArrowDown" Dense="true">
        @foreach (var type in MeterEventRules.RecordableFor(Detail.Mode))
        {
            var chosen = type;
            <MudMenuItem Icon="@MeterEventText.Icon(chosen)" OnClick="@(() => OnRecordEvent.InvokeAsync(chosen))">@($"{chosen.Display()}…")</MudMenuItem>
        }
    </MudMenu>
</div>

<PeriodToolbar Query="Query" Period="Current?.Period" Defaults="Defaults" QueryChanged="OnQueryChanged"
               ShowBucket="false" ShowComparison="false" ShowsRecords="true" Class="mb-2" />

<LoadPanel State="State" OnRetry="LoadAsync" Context="view" PlaceholderHeight="160">
    @if (view.MeterId == Detail.Id)
    {
        @if (view.Page.Rows.Count == 0)
        {
            <MudText Typo="Typo.body2" Class="mv-muted">@(Detail.HasEvents ? S.MeterDetail_NoEventsInPeriod : S.MeterDetail_NoEvents)</MudText>
            @if (Detail.HasEvents && view.Range.IsBounded)
            {
                <MudButton Size="Size.Small" Variant="Variant.Text" Class="mt-1" OnClick="ShowAllAsync">@S.MeterDetail_ShowAllDates</MudButton>
            }
        }
        else
        {
            <MudText Typo="Typo.caption" Class="mv-muted">@Loc.F(S.MeterDetail_TimesIn, Periods.Zone.Id)</MudText>
            <div class="mv-table-scroll mt-1" role="region" aria-label="@S.MeterDetail_TabEvents" tabindex="0">
                <MudSimpleTable Dense="true" Hover="true">
                    <thead>
                        <tr>
                            <th scope="col">@S.MeterDetail_Time</th>
                            <th scope="col">@S.Common_Type</th>
                            <th scope="col" class="mv-num">@S.Common_Amount</th>
                            <th scope="col" class="mv-num">@S.MeterDetail_PrevNew</th>
                            <th scope="col">@S.MeterDetail_Notes</th>
                            <th scope="col"><span class="mv-sr-only">@S.Common_Actions</span></th>
                        </tr>
                    </thead>
                    <tbody>
                        @foreach (var e in view.Page.Rows)
                        {
                            <tr>
                                <td style="white-space:nowrap">
                                    @Local(e.Time)
                                    @if (IsAfterNow(e.Time))
                                    {
                                        <AfterNowChip />
                                    }
                                </td>
                                <td style="white-space:nowrap">
                                    <MudIcon Icon="@MeterEventText.Icon(e.Type)" Size="Size.Small" Class="mr-1" Style="vertical-align:middle" aria-hidden="true" />@e.Type.Display()
                                </td>
                                <td class="mv-num">@(e.Amount is { } a ? $"{Format.Number(a, 2)} {e.Unit}" : Format.Unknown)</td>
                                <td class="mv-num" style="white-space:nowrap">@PrevNewText(e)</td>
                                <td>@e.Notes</td>
                                <td style="text-align:right">
                                    @if (e.ImportBatchId is not null)
                                    {
                                        <MudTooltip Text="@S.MeterDetail_ImportedEventHint">
                                            <MudChip T="string" Size="Size.Small" Variant="Variant.Outlined" Href="/import">@S.MeterDetail_Imported</MudChip>
                                        </MudTooltip>
                                    }
                                    else
                                    {
                                        <MudTooltip Text="@S.MeterDetail_DeleteEvent">
                                            <MudIconButton Icon="@Icons.Material.Filled.Delete" Size="Size.Small" Color="Color.Error"
                                                           OnClick="@(() => DeleteAsync(e))" aria-label="@S.MeterDetail_DeleteEvent" />
                                        </MudTooltip>
                                    }
                                </td>
                            </tr>
                        }
                    </tbody>
                </MudSimpleTable>
            </div>
            <RecordPagerBar Pager="Pager" Count="view.Page.Rows.Count" Total="view.Page.Total" TotalIsCapped="view.Page.TotalIsCapped"
                            HasOlder="view.Page.Next is not null" OnNewest="NewestAsync" OnNewer="NewerAsync" OnOlder="OlderAsync" />
        }
    }
</LoadPanel>

@code {
    /// <summary>Opens the event dialog for a type (the page owns it).</summary>
    [Parameter]
    public EventCallback<MeterEventType> OnRecordEvent { get; set; }

    private string EventsHint => Detail.Mode switch
    {
        MeterMode.ConsumableBalance => S.MeterDetail_EventsHintTank,
        MeterMode.CumulativeCounter or MeterMode.GenerationCounter or MeterMode.RuntimeCounter => S.MeterDetail_EventsHintRegister,
        _ => S.MeterDetail_EventsHintNote,
    };

    protected override Task<RecordPage<EventRow>> FetchAsync(int meterId, RecordRange range, RecordCursor? cursor, CancellationToken cancellationToken) =>
        Details.GetEventsAsync(meterId, range, cursor, cancellationToken);

    private static string PrevNewText(EventRow e) => (e.PrevValue, e.NewValue) switch
    {
        (null, null) => Format.Unknown,
        ({ } prev, var next) => $"{Format.Number(prev, 2)} → {(next is { } n ? Format.Number(n, 2) : Format.Unknown)}",
        (null, { } next) => $"→ {Format.Number(next, 2)}",
    };

    private async Task DeleteAsync(EventRow meterEvent)
    {
        var message = MeterEventRules.IsRegisterBoundary(meterEvent.Type)
            ? Loc.F(S.MeterDetail_DeleteBoundaryConfirm, meterEvent.Type.Display(), Local(meterEvent.Time))
            : Loc.F(S.MeterDetail_DeleteEventConfirm, meterEvent.Type.Display(), Local(meterEvent.Time));
        if (!await Confirm.DeleteAsync(DialogService, S.MeterDetail_DeleteEvent, message))
        {
            return;
        }

        try
        {
            await using var scope = Scopes.CreateAsyncScope();
            var result = await scope.ServiceProvider.GetRequiredService<MeterEventService>().DeleteEventAsync(Detail.Id, meterEvent.Id);
            Snackbar.Add(result.Succeeded ? S.MeterDetail_EventDeleted : MeterEventText.Problem(result.Problem),
                result.Succeeded ? Severity.Success : Severity.Error);
        }
        catch (Exception ex) when (ex is not OperationCanceledException)
        {
            // The service's transaction has rolled back; report rather than end the circuit.
            LoggerFactory.CreateLogger<MeterEventsTab>().LogError(ex, "Deleting an event on meter {MeterId} failed", Detail.Id);
            Snackbar.Add(S.MeterEvent_ActionFailed, Severity.Error);
        }

        await OnChanged.InvokeAsync();
    }
}