using MeterVault.App;
using MeterVault.Infrastructure.Costing;
using MeterVault.Infrastructure.Dashboard;
using MeterVault.Infrastructure.Import;
using MeterVault.Infrastructure.Persistence;
using Microsoft.AspNetCore.Localization;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;

namespace MeterVault.Integration.Tests;

/// <summary>
/// End-to-end M5 check: load the reference dataset, then confirm the dashboard and admin pages
/// render (server prerender) without error and show real data. Cleans up the shared container.
/// </summary>
[Collection("Timescale")]
public sealed class DashboardRenderTests(TimescaleFixture fx)
{
    [Fact]
    public async Task Pages_render_with_reference_data()
    {
        using var factory = new MeterVaultAppFactory(fx.ConnectionString);

        using (var scope = factory.Services.CreateScope())
        {
            var importer = scope.ServiceProvider.GetRequiredService<ReferenceDataImporter>();
            await importer.LoadAsync(Path.Combine(AppContext.BaseDirectory, "fixtures"));
        }

        try
        {
            // The import created the reference meters and their normalized consumption.
            await using (var db = fx.CreateContext())
            {
                Assert.Contains(await db.Meters.Select(m => m.Name).ToListAsync(), n => n == "Zähler Haus");
                Assert.True(await db.Meters.CountAsync() >= 8);
                Assert.True(await db.Consumption.AnyAsync());

                // Regression (audit): Wasser is metered (water tariff), the Kosten Wasser column is
                // NOT imported, so the category is not double-counted — Dez 2022 = 14 m³ × 5 € = 70 €.
                // The app's own service: it reads in the zone the import normalized in (a bare
                // `new CostService(fx)` reads UTC, the normalizer's default without options).
                var wasser = await db.CostCategories.FirstAsync(c => c.Name == "Wasser");
                using var costScope = factory.Services.CreateScope();
                var rollup = await costScope.ServiceProvider.GetRequiredService<CostService>().GetCategoryCostsAsync(
                    wasser.Id,
                    new DateTimeOffset(2022, 12, 1, 0, 0, 0, TimeSpan.Zero),
                    new DateTimeOffset(2023, 1, 1, 0, 0, 0, TimeSpan.Zero));
                Assert.Equal(70d, rollup.Sum(r => r.Cost), 1);

                // Summe Solar is seeded with its calculation written down (D-28): Solar 1 + Solar 2, generation in kWh,
                // not costed (generation is never billed, A-15). Its links stay flow topology.
                var byName = await db.Meters.ToDictionaryAsync(m => m.Name);
                var summe = MeterVault.Core.Analysis.Virtual.VirtualDefinitionJson.Read(byName["Summe Solar"].Meta);
                Assert.Equal(MeterVault.Core.Analysis.Virtual.VirtualDefinitionReadStatus.Present, summe.Status);
                Assert.Equal(
                    new[] { byName["Zähler Solar 1"].Id, byName["Zähler Solar 2"].Id }.Order(),
                    summe.Definition!.ReferencedMeterIds);
                Assert.True(summe.Definition.Formula!.IsPureSum);
                Assert.Equal(MeterVault.Core.Analysis.QuantityKind.Generation, summe.Definition.ResultKind);
                Assert.Equal("kWh", summe.Definition.ResultUnit);
                Assert.Equal(MeterVault.Core.Analysis.Virtual.VirtualCostRule.None, summe.Definition.CostRule);
            }

            // The startup conversion has nothing to do for the seeded Summe Solar (D-28).
            using (var scope = factory.Services.CreateScope())
            {
                await using var db = fx.CreateContext();
                var summeSolarId = await db.Meters.Where(m => m.Name == "Summe Solar").Select(m => m.Id).FirstAsync();
                var upgrade = await scope.ServiceProvider.GetRequiredService<MeterVault.Infrastructure.Analysis.VirtualDefinitionUpgrade>().RunAsync();
                Assert.DoesNotContain(summeSolarId, upgrade.Converted);
                Assert.DoesNotContain(upgrade.NeedsConfiguration, u => u.MeterId == summeSolarId);
            }

            // Panel read models compute real figures from the reference data (SDD §8.4–§8.6).
            int hausId;
            short electricityTypeId;
            using (var scope = factory.Services.CreateScope())
            {
                var services = scope.ServiceProvider;
                var wide = new DateOnly(1997, 1, 1);
                var toEnd = new DateOnly(2027, 1, 1);

                // The specialized views read the whole sheet (1997 – 2026) through the shared readers, in the app's zone.
                var solarService = services.GetRequiredService<SolarService>();
                var sheetYears = MeterVault.Core.Analysis.PeriodResolver.Resolve(
                    MeterVault.Core.Analysis.PeriodPreset.Custom, wide, toEnd.AddDays(-1), DateTimeOffset.UtcNow, solarService.Zone);
                var solar = Assert.Single((await solarService.GetAsync(new SolarRequest(sheetYears))).Sites);
                Assert.True(solar.Generation!.Total.Value > 0);
                // Haus (total consumption) and Netz (grid import) hold their roles, so self-consumption and savings resolve;
                // nobody exports, which the view names as a role to set up rather than a zero feed-in.
                Assert.True(solar.SelfConsumption!.Total.Value > 0);
                Assert.NotNull(solar.Savings!.Total.Cost);
                Assert.False(solar.RoleOf(MeterVault.Core.Analysis.Quantities.MeterRole.GridExport).IsSet);

                var consumables = await services.GetRequiredService<ConsumableService>().GetAsync(new ConsumableRequest(sheetYears));
                var oil = Assert.Single(consumables.Tanks);
                Assert.True(oil.EstimatedNow?.Volume > 0);
                Assert.NotNull(oil.LastDipstick);
                Assert.NotEmpty(oil.Deliveries);
                Assert.True(oil.Usage!.Total.Value > 0);

                await using var db = fx.CreateContext();
                hausId = await db.Meters.Where(m => m.Name == "Zähler Haus").Select(m => m.Id).FirstAsync();
                // The meter page's identity read carries no figures any more (they come from the analysis reader); its
                // record tabs page through the rows (D-50).
                var details = services.GetRequiredService<MeterDetailService>();
                var detail = await details.GetAsync(hausId);
                Assert.NotNull(detail);
                Assert.True(detail!.HasReadings);
                Assert.NotNull(detail.LastReading);
                Assert.Equal("kWh", detail.NormalizedUnit);
                Assert.True((await details.GetReadingsAsync(hausId, RecordRange.All)).Total > 0);
                Assert.True((await details.GetConsumptionAsync(hausId, RecordRange.All)).Total > 0);

                // Flow graph: the demo Haus → Auto chain yields a link + an "Other (Haus)" remainder.
                electricityTypeId = await db.EnergyTypes.Where(t => t.Key == "electricity").Select(t => t.Id).FirstAsync();
                var flow = await services.GetRequiredService<FlowService>()
                    .GetFlowAsync(electricityTypeId, new DateOnly(1997, 1, 1), new DateOnly(2027, 1, 1));
                Assert.True(flow.HasChain);
                Assert.Contains(flow.Nodes, n => n.IsOther);

                // Summe Solar is drawn from its formula: its incoming edges are its two sources, marked calculated, and
                // they add up to its own value (D-30).
                var summeId = await db.Meters.Where(m => m.Name == "Summe Solar").Select(m => m.Id).FirstAsync();
                var intoSumme = flow.Links.Where(l => l.To == $"m{summeId}").ToList();
                Assert.Equal(2, intoSumme.Count);
                Assert.All(intoSumme, l => Assert.True(l.IsCalculated));
                Assert.Equal(flow.Nodes.Single(n => n.MeterId == summeId).Value, intoSumme.Sum(l => l.Value), 6);
                Assert.Equal(MeterVault.Infrastructure.Analysis.SeriesBasis.Virtual, flow.MeterFor(summeId)!.Basis);
                Assert.Equal(await db.Meters.CountAsync(m => m.EnergyTypeId == electricityTypeId), flow.Meters.Count);
            }

            using var client = factory.CreateClient();

            var overview = await client.GetAsync(new Uri("/", UriKind.Relative));
            overview.EnsureSuccessStatusCode();
            var html = await overview.Content.ReadAsStringAsync();
            Assert.Contains("Overview", html, StringComparison.Ordinal);
            // The coverage summary names the latest month with data and what it rests on (D-19): the reference data ends
            // in May 2026, with meter data and manual costs alike. It is there whatever the clock says.
            Assert.Contains("Latest month with data: May 2026 (Meter data and manual costs)", html, StringComparison.Ordinal);

            // A fixed range renders the loaded panels (the default month to date depends on the clock; the frozen-clock
            // Overview tests cover it): the bill of 2025 is the sheet's, with the change table and the composition.
            var year = System.Net.WebUtility.HtmlDecode(await client.GetStringAsync(new Uri("/?from=2025-01-01&to=2025-12-31", UriKind.Relative)));
            Assert.Contains("Total cost", year, StringComparison.Ordinal);
            Assert.Matches(@"7,907\.6[3-6] €", year);
            Assert.Contains("Total (the bill)", year, StringComparison.Ordinal);
            Assert.Contains("Cost composition", year, StringComparison.Ordinal);

            // The navigation (D-48): Analysis, the per-type analysis group, the specialized views, data import and the
            // configuration group. The reference data has generation counters and a tank, so no setup hint shows.
            Assert.Contains("Analysis", html, StringComparison.Ordinal);
            Assert.Contains("Specialized views", html, StringComparison.Ordinal);
            Assert.Contains("Tanks &amp; consumables", html, StringComparison.Ordinal);
            Assert.Contains("Data import", html, StringComparison.Ordinal);
            Assert.Contains("Configuration", html, StringComparison.Ordinal);
            Assert.Contains($"href=\"/energy/{electricityTypeId}\"", html, StringComparison.Ordinal);
            Assert.DoesNotContain("No generation meter yet", html, StringComparison.Ordinal);
            Assert.DoesNotContain("No tank set up yet", html, StringComparison.Ordinal);
            // Dark unless the theme cookie says otherwise, and the toggle names what it does (D-49).
            Assert.Contains("aria-label=\"Light mode\"", html, StringComparison.Ordinal);
            using (var lightClient = factory.CreateClient())
            {
                lightClient.DefaultRequestHeaders.Add("Cookie", "mv-theme=light");
                var light = await lightClient.GetStringAsync(new Uri("/", UriKind.Relative));
                Assert.Contains("aria-label=\"Dark mode\"", light, StringComparison.Ordinal);
            }

            // Expanded navigation groups come from their cookie, and the group of the page shown is open whatever it
            // says (D-48): on /solar with only Configuration remembered, Specialized views opens too.
            using (var navClient = factory.CreateClient())
            {
                navClient.DefaultRequestHeaders.Add("Cookie", "mv-nav=config");
                var solarPage = await navClient.GetStringAsync(new Uri("/solar", UriKind.Relative));
                Assert.Equal("false", GroupExpanded(solarPage, "Energy types"));
                Assert.Equal("true", GroupExpanded(solarPage, "Specialized views"));
                Assert.Equal("true", GroupExpanded(solarPage, "Configuration"));
            }

            Assert.Equal("true", GroupExpanded(html, "Energy types"));
            Assert.Equal("false", GroupExpanded(html, "Configuration"));

            // The preference helper ships; the ApexCharts bundles 6.x no longer has are not referenced.
            var script = System.Text.RegularExpressions.Regex.Match(html, "<script src=\"(metervault[^\"]*[.]js)\"").Groups[1].Value;
            Assert.NotEmpty(script);
            Assert.Contains("setPreference", await client.GetStringAsync(new Uri("/" + script, UriKind.Relative)), StringComparison.Ordinal);
            Assert.DoesNotContain("apex-charts.min.js", html, StringComparison.Ordinal);

            // The configuration page for energy types says it edits definitions, not the analysis.
            var definitions = await client.GetStringAsync(new Uri("/admin/energy-types", UriKind.Relative));
            Assert.Contains("Energy type definitions", definitions, StringComparison.Ordinal);

            foreach (var path in new[]
            {
                "/meters", "/trends", "/solar", "/consumables", "/import",
                "/admin/tariffs", "/admin/energy-types", "/admin/categories",
                "/admin/connectors", "/admin/settings", $"/meters/{hausId}",
                $"/energy/{electricityTypeId}",
            })
            {
                var response = await client.GetAsync(new Uri(path, UriKind.Relative));
                response.EnsureSuccessStatusCode();
            }

            // The energy type page (brief §7.3): titled with the type's own name, one card per measure — never the old
            // "flow" title or a top-level throughput that added supply to use — the bill named by its basis, and the
            // Overview | History | Flow | Meters tabs; the Flow tab manages connections and has its table equivalent.
            // A fixed year of the reference data, so the cards render whatever today is.
            var energyPage = System.Net.WebUtility.HtmlDecode(await client.GetStringAsync(
                new Uri($"/energy/{electricityTypeId}?from=2025-01-01&to=2025-12-31", UriKind.Relative)));
            Assert.Contains(">Strom</h1>", energyPage, StringComparison.Ordinal);
            Assert.Contains("Total use", energyPage, StringComparison.Ordinal);
            Assert.Contains("Grid import", energyPage, StringComparison.Ordinal);
            Assert.Contains("Counted: Zähler Solar 1, Zähler Solar 2", energyPage, StringComparison.Ordinal);
            Assert.Contains("Billed by grid import (Zähler Netz)", energyPage, StringComparison.Ordinal);
            Assert.Contains("Meters (6)", energyPage, StringComparison.Ordinal);
            Assert.DoesNotContain("Strom flow", energyPage, StringComparison.Ordinal);
            Assert.DoesNotContain("Top-level throughput", energyPage, StringComparison.Ordinal);
            var flowTab = System.Net.WebUtility.HtmlDecode(await client.GetStringAsync(new Uri($"/energy/{electricityTypeId}?tab=flow&from=2025-01-01&to=2025-12-31", UriKind.Relative)));
            Assert.Contains("Manage connections", flowTab, StringComparison.Ordinal);
            Assert.Contains("The flow as a table", flowTab, StringComparison.Ordinal);
            Assert.Contains("Input of a calculated sum", flowTab, StringComparison.Ordinal);
            var metersTab = System.Net.WebUtility.HtmlDecode(await client.GetStringAsync(new Uri($"/energy/{electricityTypeId}?tab=meters&from=2025-01-01&to=2025-12-31", UriKind.Relative)));
            Assert.Contains("Breakdown of a counted meter", metersTab, StringComparison.Ordinal);
            // ...each meter link carrying the page's period into the meter's Analysis tab.
            Assert.Contains($"href=\"/meters/{hausId}?tab=analysis&from=2025-01-01&to=2025-12-31\"", metersTab, StringComparison.Ordinal);

            // The meter list shares the type tab's list: what each meter measured and how it counts, the calculated Summe
            // Solar marked as an analysis-only view, each name opening the meter's Analysis tab.
            var meterList = System.Net.WebUtility.HtmlDecode(await client.GetStringAsync(new Uri("/meters", UriKind.Relative)));
            Assert.Contains("Counts as", meterList, StringComparison.Ordinal);
            Assert.Contains("Analysis only", meterList, StringComparison.Ordinal);
            Assert.Contains($"href=\"/meters/{hausId}?tab=analysis\"", meterList, StringComparison.Ordinal);

            // Manual entry is reachable without an API key or a CSV: the Readings tab of a real
            // (non-virtual) meter offers it, prefilled with that meter's last register value.
            var meterPage = await (await client.GetAsync(new Uri($"/meters/{hausId}", UriKind.Relative)))
                .Content.ReadAsStringAsync();
            Assert.Contains("Add reading", meterPage, StringComparison.Ordinal);
            // ...and so is every other per-meter task, from the page header: recording a swap or
            // reset, and editing the meter itself.
            Assert.Contains("Record event", meterPage, StringComparison.Ordinal);
            Assert.Contains("Edit meter", meterPage, StringComparison.Ordinal);

            // The tab bar sits under the header, keyed tabs (D-47), with the analysis in the default tab: the quality
            // section only renders once the meter's analysis loaded (prerendered, D-46).
            Assert.Contains("Normalized data", meterPage, StringComparison.Ordinal);
            Assert.Contains("Data quality and coverage", meterPage, StringComparison.Ordinal);
            Assert.DoesNotContain("Meter register details", meterPage, StringComparison.Ordinal);

            // A deep link into a tab and an action renders — the action itself only opens once the
            // page is interactive, which a prerender request never is. The events tab it names is the one shown.
            var swapLink = await client.GetStringAsync(new Uri($"/meters/{hausId}?tab=events&action=swap", UriKind.Relative));
            Assert.Contains("Record a meter swap or a counter reset here", swapLink, StringComparison.Ordinal);

            // Old links keep working: the legacy consumption tab opens Normalized data.
            var legacyTab = await client.GetStringAsync(new Uri($"/meters/{hausId}?tab=consumption", UriKind.Relative));
            Assert.Contains("what charts, totals and costs are built from", legacyTab, StringComparison.Ordinal);

            // A virtual meter gets the same analysis from its formula (no register details, no readings), and its
            // Sources link opens the Calculation tab with the formula's meters by name.
            int summePageId;
            await using (var db = fx.CreateContext())
            {
                summePageId = await db.Meters.Where(m => m.Name == "Summe Solar").Select(m => m.Id).FirstAsync();
            }

            var virtualPage = System.Net.WebUtility.HtmlDecode(
                await client.GetStringAsync(new Uri($"/meters/{summePageId}", UriKind.Relative)));
            Assert.Contains("Data quality and coverage", virtualPage, StringComparison.Ordinal);
            Assert.Contains("Calculation", virtualPage, StringComparison.Ordinal);
            Assert.DoesNotContain("Add reading", virtualPage, StringComparison.Ordinal);
            var calculation = System.Net.WebUtility.HtmlDecode(
                await client.GetStringAsync(new Uri($"/meters/{summePageId}?tab=sources", UriKind.Relative)));
            Assert.Contains("Meters in the formula", calculation, StringComparison.Ordinal);
            Assert.Contains("Zähler Solar 1", calculation, StringComparison.Ordinal);
            Assert.Contains("Zähler Solar 2", calculation, StringComparison.Ordinal);

            // The way back from setting up a connector for a source: the connector page names the meter
            // and links to its source dialog, and lists which meters each connector serves.
            var connectorsForMeter = System.Net.WebUtility.HtmlDecode(await client.GetStringAsync(new Uri(
                MeterLinks.NewConnector(hausId, sourceId: null, MeterVault.Core.Domain.SourceType.HomeAssistant, MeterVault.Core.Domain.EndpointType.HomeAssistant),
                UriKind.Relative)));
            Assert.Contains("Back to 'Zähler Haus'", connectorsForMeter, StringComparison.Ordinal);
            Assert.Contains("Used by", connectorsForMeter, StringComparison.Ordinal);
            (await client.GetAsync(new Uri(MeterLinks.Source(hausId, sourceType: MeterVault.Core.Domain.SourceType.Mqtt, connectorId: 1), UriKind.Relative)))
                .EnsureSuccessStatusCode();

            // Each import batch links the meters it wrote to.
            var importPage = await client.GetStringAsync(new Uri("/import", UriKind.Relative));
            Assert.Contains($"href=\"/meters/{hausId}\"", importPage, StringComparison.Ordinal);

            // The Analysis page (/trends, brief §7.4) renders its figures in the prerender — it used to never leave the
            // spinner. The portfolio cost of 2025 is the sheet's Jahreskosten (D-44, 7.907,64 € ± 0,02 €), manual Heizung
            // costs included once; a category whose meters measure different things is explained, not charted as one
            // quantity; and two meters compare side by side.
            var trends = System.Net.WebUtility.HtmlDecode(
                await client.GetStringAsync(new Uri("/trends?from=2025-01-01&to=2025-12-31", UriKind.Relative)));
            Assert.Contains(">Analysis</h1>", trends, StringComparison.Ordinal);
            Assert.Contains("Total cost", trends, StringComparison.Ordinal);
            Assert.Contains("7,907.65", trends, StringComparison.Ordinal);
            Assert.Contains("Manual costs", trends, StringComparison.Ordinal);
            Assert.Contains("Values per period", trends, StringComparison.Ordinal);
            Assert.DoesNotContain("Total over range", trends, StringComparison.Ordinal);

            int stromCategoryId, netzId;
            await using (var db = fx.CreateContext())
            {
                stromCategoryId = await db.CostCategories.Where(c => c.Name == "Strom").Select(c => c.Id).FirstAsync();
                netzId = await db.Meters.Where(m => m.Name == "Zähler Netz").Select(m => m.Id).FirstAsync();
            }

            var mixedCategory = System.Net.WebUtility.HtmlDecode(await client.GetStringAsync(
                new Uri($"/trends?scope=category&id={stromCategoryId}&metric=consumption", UriKind.Relative)));
            Assert.Contains("measure different things", mixedCategory, StringComparison.Ordinal);
            Assert.DoesNotContain("Values per period", mixedCategory, StringComparison.Ordinal);

            var meterComparison = System.Net.WebUtility.HtmlDecode(await client.GetStringAsync(
                new Uri($"/trends?scope=meters&ids={hausId},{netzId}&from=2025-01-01&to=2025-12-31", UriKind.Relative)));
            Assert.Contains("Zähler Haus", meterComparison, StringComparison.Ordinal);
            Assert.Contains("Zähler Netz", meterComparison, StringComparison.Ordinal);
            Assert.Contains("Values per period", meterComparison, StringComparison.Ordinal);

            // A tank's page leads with the entry that drives it (a tank level), not a reading nothing reads.
            int tankId;
            await using (var db = fx.CreateContext())
            {
                tankId = await db.Meters.Where(m => m.Mode == MeterVault.Core.Domain.MeterMode.ConsumableBalance).Select(m => m.Id).FirstAsync();
            }

            var tankPage = await client.GetStringAsync(new Uri($"/meters/{tankId}", UriKind.Relative));
            Assert.Contains("Record tank level", tankPage, StringComparison.Ordinal);
            var consumablesPage = await client.GetStringAsync(new Uri("/consumables", UriKind.Relative));
            Assert.Contains($"/meters/{tankId}?tab=events&amp;action=delivery", consumablesPage, StringComparison.Ordinal);
            // The tank's state now stays apart from the selected period (D-54): the last dipstick as measured, the contents
            // estimated from it, and a forecast that is a projection or says why there is none.
            Assert.Contains("Last dipstick", consumablesPage, StringComparison.Ordinal);
            Assert.Contains("Estimated now (incl. deliveries since)", consumablesPage, StringComparison.Ordinal);
            Assert.Contains("Selected period", consumablesPage, StringComparison.Ordinal);

            // A year of the sheet on Solar: the figures with their units, and a setup card for the one role nobody holds
            // (grid export) that names it in words — never the raw role tokens of the old hint.
            var solarYear = System.Net.WebUtility.HtmlDecode(
                await client.GetStringAsync(new Uri("/solar?from=2025-01-01&to=2025-12-31", UriKind.Relative)));
            Assert.Contains("Self-consumption", solarYear, StringComparison.Ordinal);
            Assert.Contains("kWh", solarYear, StringComparison.Ordinal);
            Assert.Contains("Grid export: no meter yet", solarYear, StringComparison.Ordinal);
            Assert.Contains($"/meters/{hausId}?tab=analysis", solarYear, StringComparison.Ordinal);
            Assert.DoesNotContain("total_load", solarYear, StringComparison.Ordinal);
            Assert.DoesNotContain("grid_import", solarYear, StringComparison.Ordinal);

            // The same pages in German (SDD §12, M7). Real data rather than an empty instance, so
            // this covers the labels that only exist once rows have rendered — the branch a
            // smoke test against a bare database silently skips.
            using var germanClient = factory.CreateClient();
            germanClient.DefaultRequestHeaders.Add(
                "Cookie",
                CookieRequestCultureProvider.DefaultCookieName
                + "="
                + Uri.EscapeDataString(CookieRequestCultureProvider.MakeCookieValue(new RequestCulture("de"))));

            // Decoded, because Blazor entity-encodes non-ASCII: "Übersicht" ships as "&#xDC;bersicht".
            var germanOverview = System.Net.WebUtility.HtmlDecode(
                await germanClient.GetStringAsync(new Uri("/", UriKind.Relative)));
            Assert.Contains("lang=\"de\"", germanOverview, StringComparison.Ordinal);
            Assert.Contains("Übersicht", germanOverview, StringComparison.Ordinal);
            Assert.Contains("Spezialansichten", germanOverview, StringComparison.Ordinal);
            Assert.Contains("Konfiguration", germanOverview, StringComparison.Ordinal);
            Assert.Contains("Datenimport", germanOverview, StringComparison.Ordinal);
            Assert.Contains("Letzter Monat mit Daten: Mai 2026", germanOverview, StringComparison.Ordinal);
            Assert.DoesNotContain("Latest month with data", germanOverview, StringComparison.Ordinal);
            Assert.DoesNotContain("Total cost", germanOverview, StringComparison.Ordinal);

            // MudBlazor's own accessible names speak German too (brief §8): a nav group's toggle, not "Toggle …".
            Assert.Contains("aria-label=\"Energiearten ein- oder ausklappen\"", germanOverview, StringComparison.Ordinal);
            Assert.DoesNotContain("aria-label=\"Toggle ", germanOverview, StringComparison.Ordinal);

            // The Analysis page in German: the same 2025 bill, in German words and number format.
            var germanTrends = System.Net.WebUtility.HtmlDecode(
                await germanClient.GetStringAsync(new Uri("/trends?from=2025-01-01&to=2025-12-31", UriKind.Relative)));
            Assert.Contains("Gesamtkosten", germanTrends, StringComparison.Ordinal);
            Assert.Contains("7.907,65", germanTrends, StringComparison.Ordinal);
            Assert.Contains("Manuelle Kosten", germanTrends, StringComparison.Ordinal);
            Assert.DoesNotContain("Total cost", germanTrends, StringComparison.Ordinal);

            // Meter names are user data: they stay exactly as imported, in either language. The
            // meter list is where they render — the overview shows cost categories, not meters.
            var germanMeters = System.Net.WebUtility.HtmlDecode(
                await germanClient.GetStringAsync(new Uri("/meters", UriKind.Relative)));
            Assert.Contains("Zähler Haus", germanMeters, StringComparison.Ordinal);
            // ...while the meter's mode, which is an enum and not user data, is translated.
            Assert.Contains("Zählerstand (kumulativ)", germanMeters, StringComparison.Ordinal);
            Assert.DoesNotContain("CumulativeCounter", germanMeters, StringComparison.Ordinal);
            Assert.Contains("Zählt als", germanMeters, StringComparison.Ordinal);

            // The energy type page in German: the measures and tabs are worded, the type's name is not.
            var germanEnergy = System.Net.WebUtility.HtmlDecode(
                await germanClient.GetStringAsync(new Uri($"/energy/{electricityTypeId}?from=2025-01-01&to=2025-12-31", UriKind.Relative)));
            Assert.Contains(">Strom</h1>", germanEnergy, StringComparison.Ordinal);
            Assert.Contains("Gesamtverbrauch", germanEnergy, StringComparison.Ordinal);
            Assert.Contains("Netzbezug", germanEnergy, StringComparison.Ordinal);
            Assert.Contains("Abrechnung nach Netzbezug", germanEnergy, StringComparison.Ordinal);
            Assert.DoesNotContain("Total use", germanEnergy, StringComparison.Ordinal);

            foreach (var path in new[]
            {
                "/meters", "/trends", "/solar", "/consumables", "/import",
                "/admin/tariffs", "/admin/energy-types", "/admin/categories",
                "/admin/connectors", "/admin/settings", $"/meters/{hausId}",
                $"/energy/{electricityTypeId}",
            })
            {
                var response = await germanClient.GetAsync(new Uri(path, UriKind.Relative));
                response.EnsureSuccessStatusCode();
            }

            // The specialized views in German: the roles and figures in words, the tank's two parts labelled.
            var germanSolar = System.Net.WebUtility.HtmlDecode(
                await germanClient.GetStringAsync(new Uri("/solar?from=2025-01-01&to=2025-12-31", UriKind.Relative)));
            Assert.Contains("Eigenverbrauch", germanSolar, StringComparison.Ordinal);
            Assert.Contains("Netzeinspeisung: noch kein Zähler", germanSolar, StringComparison.Ordinal);
            var germanConsumables = System.Net.WebUtility.HtmlDecode(
                await germanClient.GetStringAsync(new Uri("/consumables", UriKind.Relative)));
            Assert.Contains("Letzte Peilung", germanConsumables, StringComparison.Ordinal);
            Assert.Contains("Gewählter Zeitraum", germanConsumables, StringComparison.Ordinal);
        }
        finally
        {
            await using var db = fx.CreateContext();
            await ClearDataAsync(db);
        }
    }

    /// <summary>The <c>aria-expanded</c> of a navigation group's toggle in rendered HTML.</summary>
    private static string GroupExpanded(string html, string group) =>
        System.Text.RegularExpressions.Regex.Match(
            html, "aria-expanded=\"(true|false)\" aria-label=\"Toggle " + System.Text.RegularExpressions.Regex.Escape(group) + "\"").Groups[1].Value;

    private static async Task ClearDataAsync(MeterVaultDbContext db)
    {
        await db.MeterLinks.ExecuteDeleteAsync();
        await db.Consumption.ExecuteDeleteAsync();
        await db.Readings.ExecuteDeleteAsync();
        await db.MeterEvents.ExecuteDeleteAsync();
        await db.ManualCosts.ExecuteDeleteAsync();
        await db.CostCategoryMembers.ExecuteDeleteAsync();
        await db.Tariffs.ExecuteDeleteAsync();
        await db.Tanks.ExecuteDeleteAsync();
        await db.MeterSources.ExecuteDeleteAsync();
        await db.Meters.ExecuteDeleteAsync();
        await db.ImportBatches.ExecuteDeleteAsync();
    }
}