@page "/consumables"
@using MeterVault.App.Components.Pages.Specialized
@using MeterVault.Core.Analysis
@implements IDisposable
@inject NavigationManager Nav
@inject InstanceClock Clock
@inject ConsumableService ConsumablesSvc
@inject ILogger<Consumables> Logger

@* Tanks & consumables (brief §7.5, D-54): the shared header, toolbar and missing-data semantics around every tank's
   specialised measures. Each tank keeps its state now — the last dipstick as measured, the contents estimated from it,
   the forecast as a projection — apart from the selected period, which has its own usage, deliveries, burner runtime,
   cost and, for a period that is over, the contents at its end. *@

<PageHeader Title="@S.Nav_Consumables" Description="@S.Consumables_Description">
    <Breadcrumbs>
        <AnalysisBreadcrumbs Query="_query" Current="@S.Nav_Consumables" />
    </Breadcrumbs>
</PageHeader>

@if (_query is not null)
{
    <PeriodToolbar Query="_query" Period="_state.Value?.Analysis.Period" Plan="_state.Value?.Analysis.Plan" Defaults="Defaults"
                   QueryChanged="OnQueryChanged" ExportHref="@_state.Value?.ExportHref" Class="mb-4" />
}

<LoadPanel State="_state" OnRetry="RetryAsync" Context="view">
    @* A consumable meter without a tank has no capacity or calibration, so it cannot be summarised — but it must not just
       be missing from the page, with nothing saying where it went. *@
    @foreach (var meter in view.Analysis.Unconfigured)
    {
        <MudAlert Severity="Severity.Warning" Class="mb-3">
            @Loc.F(S.Consumables_TankNotConfigured, meter.Name)
            <MudButton Size="Size.Small" Variant="Variant.Text" Color="Color.Warning" Class="ml-2"
                       Href="@MeterLinks.Detail(meter.MeterId, action: MeterLinks.ActionEdit)">@S.Consumables_SetUpTank</MudButton>
        </MudAlert>
    }

    @if (view.Analysis.Tanks.Count == 0 && view.Analysis.Unconfigured.Count == 0)
    {
        <div class="mv-empty" role="status">
            <MudIcon Icon="@Icons.Material.Outlined.PropaneTank" Class="mv-empty__icon" aria-hidden="true" />
            <div class="mv-empty__body">
                <MudText Typo="Typo.subtitle1">@S.Consumables_NoTanksTitle</MudText>
                <MudText Typo="Typo.body2" Class="mv-muted">@Loc.F(S.Consumables_NoTanksHelp, MeterMode.ConsumableBalance.Display())</MudText>
                <div class="d-flex flex-wrap mt-2" style="gap:.5rem">
                    <MudButton Variant="Variant.Outlined" Color="Color.Primary" Size="Size.Small" Href="/meters">@S.Nav_Meters</MudButton>
                    <MudButton Variant="Variant.Text" Color="Color.Primary" Size="Size.Small" Href="/import">@S.Nav_Import</MudButton>
                </div>
            </div>
        </div>
    }
    else if (!view.Analysis.IsRefused)
    {
        @foreach (var tank in view.Tanks)
        {
            <TankSection @key="tank.Tank.MeterId" View="tank" Query="view.Query" Period="view.Analysis.Period"
                         Problems="ProblemsOf(view.Analysis, tank.Tank)" Currency="@view.Analysis.Currency" OnRefresh="RetryAsync" />
        }
    }
</LoadPanel>

@code {
    private static readonly AnalysisDefaults Defaults = AnalysisDefaults.History;

    private readonly LoadSequencer _loads = new();
    private readonly LoadState<ConsumablesPageView> _state = new();
    private AnalysisQuery? _query;

    /// <summary>One committed result: the query it answers, the read model, every tank's series and the export link.</summary>
    private sealed record ConsumablesPageView(AnalysisQuery Query, ConsumableAnalysis Analysis, IReadOnlyList<TankView> Tanks, string? ExportHref);

    protected override void OnInitialized() => Nav.LocationChanged += OnLocationChanged;

    protected override Task OnParametersSetAsync() => ReloadIfChangedAsync();

    private void OnLocationChanged(object? sender, LocationChangedEventArgs e) => _ = InvokeAsync(ReloadIfChangedAsync);

    private async Task ReloadIfChangedAsync()
    {
        var query = AnalysisQuery.Parse(Nav.Uri, Defaults);
        if (query == _query)
        {
            return;
        }

        _query = query;
        await LoadAsync(query);
        StateHasChanged();
    }

    private Task RetryAsync() => _query is null ? Task.CompletedTask : LoadAsync(_query);

    private Task LoadAsync(AnalysisQuery query) => _loads.RunAsync(_state, async token =>
    {
        // "Now" is read once per load (D-01); "all" spans what the tanks have data for (D-19).
        var now = Clock.Now;
        var availability = query.Period == PeriodPreset.AllHistory ? await ConsumablesSvc.GetAvailabilityAsync(now, token) : null;
        var period = query.Resolve(now, ConsumablesSvc.Zone, availability);
        var analysis = await ConsumablesSvc.GetAsync(new ConsumableRequest(period) { Bucket = query.Bucket, Comparison = query.Comparison }, token);
        var tanks = analysis.Tanks.Select(t => TankView.Build(t, analysis.Quantities, query, analysis.Currency)).ToList();

        // The CSV export of what the tables show: every tank's usage (D-55), within the chart's series limit.
        var ids = analysis.Tanks.Select(t => t.MeterId).ToList();
        var export = ids.Count is > 0 and <= MeterVault.Infrastructure.Analysis.AnalysisLimits.MaxSeries
            ? AnalysisLinks.Export(query.WithScope(QueryScope.ForMeters(ids)).WithMetric(AnalysisMetric.Consumption))
            : null;
        return new ConsumablesPageView(query, analysis, tanks, export);
    }, Logger);

    private void OnQueryChanged(AnalysisQuery query) => AnalysisNavigation.Replace(Nav, query, Defaults);

    /// <summary>The reader's problems about one tank and the burners it feeds.</summary>
    private static IReadOnlyList<MeterVault.Infrastructure.Analysis.AnalysisProblem> ProblemsOf(ConsumableAnalysis analysis, TankAnalysis tank)
    {
        var ids = tank.Runtime.Select(r => r.MeterId).OfType<int>().Append(tank.MeterId).ToHashSet();
        var problems = (analysis.Quantities?.Problems ?? []).Concat(tank.Cost?.QuantityProblems ?? []);
        return [.. problems.Where(p => p.MeterId is { } id ? ids.Contains(id) : p.MeterIds.Any(ids.Contains))];
    }

    public void Dispose()
    {
        Nav.LocationChanged -= OnLocationChanged;
        _loads.Dispose();
    }
}