@inject NavigationManager Nav

@* The meter's Analysis tab (brief §7.2): the shared period toolbar with CSV export, the period's quantity (normalized
   unit, D-20) and cost (with its rule named, or why there is none), the projection kept apart from the actual (D-09),
   the full-size chart with the comparison overlay, the accessible table, a click on a bucket drilling down (D-51), and
   what qualifies the figures: coverage, resolution, opening balance, rows after now, freshness, and the events and
   tariff changes inside the range. A virtual meter gets the same from its formula, with its sources' contributions. *@

<PeriodToolbar Query="Query" Period="Current?.Period" Plan="Current?.Quantities.Plan" Defaults="Defaults"
               QueryChanged="OnQueryChanged" ExportHref="@ExportHref"
               Metrics="Current?.Metrics" NaturalMetric="Current?.QuantityMetric" Class="mb-3" />

<LoadPanel State="State" OnRetry="OnRetry" Context="r">
    @if (r.MeterId == Detail.Id)
    {
        var s = r.Series;
        @if (s is null)
        {
            <MudAlert Severity="Severity.Warning" Dense="true">@Loc.F(S.MeterDetail_NotFound, Detail.Id)</MudAlert>
        }
        else if (r.Quantities.Refusal != AnalysisRefusal.None)
        {
            @* The toolbar above says why (too many points) and offers the coarser bucket. *@
        }
        else
        {
            <AttentionList Problems="ProblemsOf(r)" CostAttention="r.Cost?.Attention" Names="r.AttentionNames"
                           Query="Query" MaxItems="4" Class="mb-3" />

            @if (s.IsPending)
            {
                <PendingState OnRefresh="OnRetry" />
            }
            else if (s.Total.Status == BucketStatus.Invalid)
            {
                <MudAlert Severity="Severity.Error" Class="mb-3">
                    @Loc.F(S.MeterDetail_CalculationNotEvaluable, (s.Virtual?.Status ?? VirtualMeterStatus.Invalid).Display())
                    <div class="d-flex flex-wrap mt-2" style="gap:.5rem">
                        <MudButton Size="Size.Small" Variant="Variant.Outlined" StartIcon="@Icons.Material.Filled.Functions"
                                   OnClick="OnEdit">@S.MeterDetail_EditCalculation</MudButton>
                        <MudButton Size="Size.Small" Variant="Variant.Text"
                                   Href="@MeterLinks.Detail(Detail.Id, MeterLinks.TabCalculation, null, Query)">@S.MeterDetail_ShowCalculation</MudButton>
                    </div>
                </MudAlert>
            }
            else if (r.Quantities.NotYetOccurred || s.Total.Status == BucketStatus.Missing)
            {
                <EmptyPeriodState NotYetOccurred="r.Quantities.NotYetOccurred" Availability="s.Availability" LatestHref="@LatestHref(s)" Class="mb-3">
                    @if (s.Availability is null)
                    {
                        <MudText Typo="Typo.body2" Class="mv-muted">@NextStepText</MudText>
                        <div class="d-flex flex-wrap mt-2" style="gap:.5rem">
                            @if (MeterEventRules.TakesReadings(Detail.Mode))
                            {
                                <MudButton Size="Size.Small" Variant="Variant.Outlined" StartIcon="@Icons.Material.Filled.EditNote"
                                           OnClick="OnAddReading">@S.MeterDetail_AddFirstReading</MudButton>
                                <MudButton Size="Size.Small" Variant="Variant.Text" StartIcon="@Icons.Material.Filled.SettingsInputComponent"
                                           Href="@MeterLinks.Source(Detail.Id)">@S.MeterDetail_ConnectSource</MudButton>
                            }
                            else if (Detail.Mode == MeterMode.ConsumableBalance)
                            {
                                <MudButton Size="Size.Small" Variant="Variant.Outlined" StartIcon="@Icons.Material.Filled.Straighten"
                                           OnClick="@(() => OnRecordEvent.InvokeAsync(MeterEventType.TankLevel))">@S.MeterDetail_RecordTankLevel</MudButton>
                            }
                            else if (Detail.IsVirtual)
                            {
                                <MudButton Size="Size.Small" Variant="Variant.Text" StartIcon="@Icons.Material.Filled.Functions"
                                           Href="@MeterLinks.Detail(Detail.Id, MeterLinks.TabCalculation, null, Query)">@S.MeterDetail_ShowCalculation</MudButton>
                            }
                        </div>
                    }
                </EmptyPeriodState>
                @if (Detail.IsVirtual)
                {
                    <SeriesContributions Series="s" Query="Query" Class="mt-3" />
                }
            }
            else
            {
                <MudGrid Spacing="2" Class="mb-1">
                    <MudItem xs="12" sm="6" md="4">
                        <MetricCard Title="@s.Kind.Display()" Value="s.Total" Unit="@s.Unit" Caption="@Format.PeriodRange(r.Period)"
                                    Change="s.Comparison?.Change" Polarity="ChangePolarities.For(s.Kind)"
                                    ChangeCaption="@ComparisonCaption">
                            @if (r.Projection is { } projection)
                            {
                                <ProjectionNote Days="projection.Days" ValueText="@Format.Quantity(projection.Value, projection.Unit)" Class="mt-2" />
                            }
                        </MetricCard>
                    </MudItem>
                    @if (r.Cost is { } cost)
                    {
                        <MudItem xs="12" sm="6" md="4">
                            @if (r.IsCosted)
                            {
                                <MetricCard Title="@S.MeterDetail_CostTitle" Cost="cost.Total" Currency="@cost.Currency"
                                            Caption="@CostRuleText(cost)"
                                            Change="CostChanges.ForCard(r.CostChange)" Polarity="CostChanges.Polarity(r.CostChange)"
                                            ChangeCaption="@CostChanges.Caption(Query, r.CostChange)" />
                            }
                            else
                            {
                                <MudPaper Outlined="true" Elevation="0" Class="pa-4 mv-metric">
                                    <MudText Typo="Typo.overline" Class="mv-muted mv-metric__title">@S.MeterDetail_CostTitle</MudText>
                                    <div class="mv-metric__value-row">
                                        <span class="mv-metric__value mv-metric__value--words">@MeterCostRule.None.Display()</span>
                                    </div>
                                    <MudText Typo="Typo.caption" Class="mv-muted">@((cost.Meter?.NotCosted ?? MeterNotCostedReason.None).Display())</MudText>
                                </MudPaper>
                            }
                        </MudItem>
                    }
                </MudGrid>

                <ComparisonSummary Period="r.Period" Resolution="r.Quantities.Comparison?.Resolution" Matched="s.Comparison?.Matched" Class="mb-2" />

                @* A click leads somewhere or is not offered (D-51): the chart is clickable, the table has its drill column and
                   the hint shows only when some bucket opens something. *@
                var drills = r.Quantities.Plan.Buckets.Any(b => DrillHref(b, r, s) is not null);
                <MudPaper Outlined="true" Elevation="0" Class="pa-3 mb-3">
                    @if (drills)
                    {
                        <AnalysisChart Buckets="r.Quantities.Plan.Buckets" Series="r.Chart" ComparisonPairs="r.Quantities.Comparison?.Buckets"
                                       Title="@ChartTitle(r, s)" Height="340" OnBucketClick="b => Drill(b, r, s)"
                                       Resolution="s.Resolution" OnUseBucket="UseBucketAsync" />
                        <MudText Typo="Typo.caption" Class="mv-muted">@DrillHint(s)</MudText>
                    }
                    else
                    {
                        <AnalysisChart Buckets="r.Quantities.Plan.Buckets" Series="r.Chart" ComparisonPairs="r.Quantities.Comparison?.Buckets"
                                       Title="@ChartTitle(r, s)" Height="340" Resolution="s.Resolution" OnUseBucket="UseBucketAsync" />
                    }
                </MudPaper>

                <AnalysisTable Buckets="r.Quantities.Plan.Buckets" Series="r.Table" ComparisonPairs="r.Quantities.Comparison?.Buckets"
                               DrillHref="@(drills ? b => DrillHref(b, r, s) : null)" Caption="@ChartTitle(r, s)" />

                @if (Detail.IsVirtual)
                {
                    <MudText Typo="Typo.h6" Class="mt-5 mb-1">@S.MeterDetail_SourcesOfCalculation</MudText>
                    <SeriesContributions Series="s" Query="Query" />
                }
            }

            <MeterCoverageNote View="r" Detail="Detail" Query="Query" OnEdit="OnEdit" Class="mt-5" />
        }
    }
</LoadPanel>

@code {
    /// <summary>The meter.</summary>
    [Parameter, EditorRequired]
    public MeterDetailView Detail { get; set; } = null!;

    /// <summary>The page's analysis state.</summary>
    [Parameter, EditorRequired]
    public AnalysisQuery Query { get; set; } = null!;

    /// <summary>The page's analysis load (owned by the page, so switching tabs never reloads it, D-46).</summary>
    [Parameter, EditorRequired]
    public LoadState<MeterAnalysisView> State { get; set; } = null!;

    /// <summary>A toolbar choice: the page writes it into its address (replace).</summary>
    [Parameter]
    public EventCallback<AnalysisQuery> OnQueryChanged { get; set; }

    [Parameter]
    public EventCallback OnRetry { get; set; }

    [Parameter]
    public EventCallback OnAddReading { get; set; }

    [Parameter]
    public EventCallback<MeterEventType> OnRecordEvent { get; set; }

    /// <summary>Opens the shared meter editor (install date, calculation).</summary>
    [Parameter]
    public EventCallback OnEdit { get; set; }

    private AnalysisDefaults Defaults => MeterAnalysisLoader.DefaultsFor(Detail.Id);

    /// <summary>The committed value when it is this meter's.</summary>
    private MeterAnalysisView? Current => State.Value is { } value && value.MeterId == Detail.Id ? value : null;

    private string ExportHref => AnalysisLinks.Export(MeterAnalysisLoader.ForMeter(Query, Detail.Id));

    private string? ComparisonCaption => Query.Comparison.Kind == ComparisonKind.None ? null : Query.Comparison.Display();

    private string NextStepText => Detail.Mode switch
    {
        MeterMode.ConsumableBalance => S.MeterDetail_NextStepTank,
        MeterMode.Virtual => S.MeterDetail_NextStepVirtual,
        _ => S.MeterDetail_NextStepCounter,
    };

    /// <summary>
    /// The readers' problems for the attention list. Rows recorded after now are explained with their dates and amount in
    /// the coverage section below, so they are not listed twice.
    /// </summary>
    private static IEnumerable<AnalysisProblem> ProblemsOf(MeterAnalysisView view) =>
        view.Quantities.Problems.Concat(view.Cost?.QuantityProblems ?? [])
            .Where(p => p.Kind != AnalysisProblemKind.RecordedAfterNow);

    private string CostRuleText(Infrastructure.Costing.CostAnalysis cost) =>
        Loc.F(S.MeterDetail_CostRule, (cost.Meter?.Rule ?? MeterCostRule.None).Display());

    private static string ChartTitle(MeterAnalysisView view, AnalysisSeries series) =>
        view.ShowsCost
            ? Loc.F(S.MeterDetail_CostOf, AnalysisChartSeries.NameOf(series))
            : Loc.F(S.MeterDetail_ChartTitle, series.Kind.Display(), AnalysisChartSeries.NameOf(series));

    private string DrillHint(AnalysisSeries series) =>
        Detail.IsVirtual ? S.MeterDetail_DrillHintVirtual : S.MeterDetail_DrillHint;

    private string? LatestHref(AnalysisSeries series) =>
        AnalysisNavigation.LatestData(Query, series.Availability) is { } latest ? MeterLinks.Analysis(Detail.Id, latest) : null;

    /// <summary>
    /// Where a bucket leads (D-51, <see cref="MeterDrill"/>): the next finer size the data resolves; otherwise a physical
    /// meter's records of the bucket, or a virtual meter's own analysis over just that bucket, whose source contributions
    /// link on to each source's records — never a dead end.
    /// </summary>
    private string? DrillHref(AnalysisBucket bucket, MeterAnalysisView view, AnalysisSeries series) =>
        MeterDrill.Href(Detail.Id, Detail.IsVirtual, Query, view.Period, bucket, series.Resolution);

    /// <summary>A chart click drills down, pushing a history entry so Back returns to the range it came from (D-46).</summary>
    private void Drill(AnalysisBucket bucket, MeterAnalysisView view, AnalysisSeries series)
    {
        if (DrillHref(bucket, view, series) is { } href)
        {
            Nav.NavigateTo(href);
        }
    }

    /// <summary>The buckets are finer than the data: apply the interval that shows it (the page replaces its address).</summary>
    private Task UseBucketAsync(BucketSize size) => OnQueryChanged.InvokeAsync(Query.WithBucket(size));
}