@page "/import"
@inject MeterVault.Infrastructure.Import.ReferenceDataImporter ReferenceImporter
@inject MeterVault.Infrastructure.Import.CsvImporter CsvImporter
@inject MeterVault.Infrastructure.Import.ImportService ImportService
@inject Microsoft.EntityFrameworkCore.IDbContextFactory<MeterVault.Infrastructure.Persistence.MeterVaultDbContext> DbFactory
@inject IDialogService Dialogs
@inject ISnackbar Snackbar
@using MeterVault.Infrastructure.Import
@using MeterVault.Infrastructure.Persistence
@using Microsoft.EntityFrameworkCore

<PageTitle>MeterVault — @S.Nav_Import</PageTitle>

<MudText Typo="Typo.h4" Class="mb-4">@S.Nav_Import</MudText>

<MudGrid>
    <MudItem xs="12" md="6">
        <MudPaper Class="pa-4" Elevation="2" Style="height:100%">
            <MudText Typo="Typo.h6">@S.Import_ReferenceDataset</MudText>
            <MudText Typo="Typo.body2" Color="Color.Secondary" Class="mb-3">
                @S.Import_ReferenceDatasetHelp
            </MudText>
            <MudButton Variant="Variant.Filled" Color="Color.Primary" StartIcon="@Icons.Material.Filled.CloudDownload"
                       OnClick="LoadReferenceAsync" Disabled="_loadingReference || _referenceLoaded">
                @(_referenceLoaded ? S.Import_ReferenceLoaded : S.Import_LoadReferenceData)
            </MudButton>
            @if (_loadingReference)
            {
                <MudProgressLinear Indeterminate="true" Color="Color.Primary" Class="mt-3" />
            }
        </MudPaper>
    </MudItem>

    <MudItem xs="12" md="6">
        <MudPaper Class="pa-4" Elevation="2" Style="height:100%">
            <div class="d-flex align-center justify-space-between">
                <MudText Typo="Typo.h6">@S.Import_YourOwnCsv</MudText>
                <MudButton Variant="Variant.Filled" Color="Color.Secondary" Href="/import/wizard"
                           StartIcon="@Icons.Material.Filled.AutoFixHigh">@S.Import_MappingWizard</MudButton>
            </div>
            <MudText Typo="Typo.body2" Color="Color.Secondary" Class="mb-3 mt-1">
                @S.Import_YourOwnCsvHelp
            </MudText>
            <MudSelect T="string" @bind-Value="_profileName" Label="@S.Import_ReferenceProfile" Dense="true" Class="mb-2">
                <MudSelectItem T="string" Value="@("Strom")">@S.Import_ProfileElectricity</MudSelectItem>
                <MudSelectItem T="string" Value="@("Wasser")">@S.Import_ProfileWater</MudSelectItem>
                <MudSelectItem T="string" Value="@("Heizöl")">@S.Import_ProfileHeatingOil</MudSelectItem>
                <MudSelectItem T="string" Value="@("Kosten")">@S.Import_ProfileCosts</MudSelectItem>
            </MudSelect>
            <MudButton HtmlTag="label" Variant="Variant.Outlined" StartIcon="@Icons.Material.Filled.UploadFile" for="csvUpload">
                @S.Import_DryRunReferenceSheet
            </MudButton>
            <InputFile id="csvUpload" OnChange="PreviewAsync" accept=".csv" style="display:none" />
        </MudPaper>
    </MudItem>

    @if (_preview is not null)
    {
        <MudItem xs="12">
            <MudPaper Class="pa-4" Elevation="2">
                <MudText Typo="Typo.h6" Class="mb-2">@S.Common_Preview</MudText>
                <div class="d-flex" style="gap:2rem; flex-wrap:wrap">
                    <MudText>@S.Common_ReadingsLabel <b>@_preview.Readings.Count</b></MudText>
                    <MudText>@S.Common_EventsLabel <b>@_preview.Events.Count</b></MudText>
                    <MudText>@S.Common_ManualCostsLabel <b>@_preview.ManualCosts.Count</b></MudText>
                    <MudText>@S.Common_SkippedRowsLabel <b>@_preview.SkippedRows</b></MudText>
                </div>
                @if (_preview.Warnings.Count > 0)
                {
                    <MudExpansionPanels Class="mt-3">
                        <MudExpansionPanel Text="@Loc.F(S.Import_WarningsCount, _preview.Warnings.Count)">
                            @foreach (var warning in _preview.Warnings.Take(50))
                            {
                                <MudText Typo="Typo.body2">@warning.Display()</MudText>
                            }
                        </MudExpansionPanel>
                    </MudExpansionPanels>
                }
            </MudPaper>
        </MudItem>
    }

    <MudItem xs="12">
        <MudPaper Class="pa-4" Elevation="2">
            <MudText Typo="Typo.h6" Class="mb-2">@S.Import_RecentImports</MudText>
            @if (_batches.Count == 0)
            {
                <MudText Typo="Typo.body2" Color="Color.Secondary">@S.Import_NoImportsYet</MudText>
            }
            else
            {
                <MudSimpleTable Dense="true" Hover="true">
                    <thead><tr><th>#</th><th>@S.Import_ColumnSource</th><th>@S.Import_ColumnWritesTo</th><th style="text-align:right">@S.Import_ColumnRows</th><th>@S.Import_ColumnImported</th><th>@S.Common_Status</th><th></th></tr></thead>
                    <tbody>
                        @foreach (var batch in _batches)
                        {
                            <tr>
                                <td>@batch.Id</td>
                                <td>@(batch.SourceName ?? "—")</td>
                                <td>
                                    @* What the batch wrote to, so an import can be checked where it landed — and a
                                       revert weighed against what it will take away. *@
                                    @if (_targets.TryGetValue(batch.Id, out var targets))
                                    {
                                        @foreach (var meter in targets.Meters)
                                        {
                                            <MudLink Href="@MeterLinks.Detail(meter.Id)" Class="mr-2">@meter.Name</MudLink>
                                        }
                                        @foreach (var category in targets.Categories)
                                        {
                                            <MudLink Href="/admin/categories" Class="mr-2" Color="Color.Secondary">@category</MudLink>
                                        }
                                    }
                                    else
                                    {
                                        <span>—</span>
                                    }
                                </td>
                                <td style="text-align:right">@batch.RowCount</td>
                                <td>@batch.CreatedAt.LocalDateTime.ToString("yyyy-MM-dd HH:mm")</td>
                                <td>
                                    @if (batch.RevertedAt is not null)
                                    {
                                        <MudChip T="string" Size="Size.Small" Color="Color.Default">@S.Import_StatusReverted</MudChip>
                                    }
                                    else
                                    {
                                        <MudChip T="string" Size="Size.Small" Color="Color.Success">@S.Import_StatusActive</MudChip>
                                    }
                                </td>
                                <td style="text-align:right">
                                    <MudButton Size="Size.Small" Variant="Variant.Outlined" Color="Color.Error"
                                               StartIcon="@Icons.Material.Filled.Undo"
                                               Disabled="@(batch.RevertedAt is not null || _reverting == batch.Id)"
                                               OnClick="@(() => RevertAsync(batch))">@S.Import_Revert</MudButton>
                                </td>
                            </tr>
                        }
                    </tbody>
                </MudSimpleTable>
            }
        </MudPaper>
    </MudItem>
</MudGrid>

@code {
    private bool _loadingReference;
    private bool _referenceLoaded;
    private string _profileName = "Strom";
    private StagedImport? _preview;
    private List<ImportBatch> _batches = [];
    private Dictionary<int, BatchTargets> _targets = [];
    private int? _reverting;

    protected override async Task OnInitializedAsync()
    {
        _referenceLoaded = await ReferenceImporter.IsLoadedAsync();
        await LoadBatchesAsync();
    }

    private async Task LoadBatchesAsync()
    {
        await using var db = await DbFactory.CreateDbContextAsync();
        _batches = await db.ImportBatches.AsNoTracking()
            .OrderByDescending(b => b.Id)
            .Take(25)
            .ToListAsync();
        _targets = await LoadTargetsAsync(db, [.. _batches.Where(b => b.RevertedAt is null).Select(b => b.Id)]);
    }

    /// <summary>
    /// The meters and cost categories each batch wrote rows for. Read from the rows themselves rather
    /// than the stored mapping, which the reference import does not have and which cannot say what a
    /// partly failed or reverted batch actually left behind.
    /// </summary>
    private static async Task<Dictionary<int, BatchTargets>> LoadTargetsAsync(MeterVaultDbContext db, List<int> batchIds)
    {
        if (batchIds.Count == 0)
        {
            return [];
        }

        var readingMeters = await db.Readings.AsNoTracking()
            .Where(r => r.ImportBatchId != null && batchIds.Contains(r.ImportBatchId.Value))
            .Select(r => new { Batch = r.ImportBatchId!.Value, r.MeterId })
            .Distinct()
            .ToListAsync();
        var eventMeters = await db.MeterEvents.AsNoTracking()
            .Where(e => e.ImportBatchId != null && batchIds.Contains(e.ImportBatchId.Value))
            .Select(e => new { Batch = e.ImportBatchId!.Value, e.MeterId })
            .Distinct()
            .ToListAsync();
        var costs = await db.ManualCosts.AsNoTracking()
            .Where(c => c.ImportBatchId != null && batchIds.Contains(c.ImportBatchId.Value))
            .Select(c => new { Batch = c.ImportBatchId!.Value, c.MeterId, c.CategoryId })
            .Distinct()
            .ToListAsync();

        var meterPairs = readingMeters.Select(r => (r.Batch, MeterId: (int?)r.MeterId))
            .Concat(eventMeters.Select(e => (e.Batch, MeterId: (int?)e.MeterId)))
            .Concat(costs.Select(c => (c.Batch, c.MeterId)))
            .Where(p => p.MeterId is not null)
            .Select(p => (p.Batch, MeterId: p.MeterId!.Value))
            .Distinct()
            .ToList();
        var categoryPairs = costs.Where(c => c.CategoryId is not null).Select(c => (c.Batch, CategoryId: c.CategoryId!.Value)).Distinct().ToList();

        var meterIds = meterPairs.Select(p => p.MeterId).Distinct().ToList();
        var categoryIds = categoryPairs.Select(p => p.CategoryId).Distinct().ToList();
        var meterNames = await db.Meters.AsNoTracking().Where(m => meterIds.Contains(m.Id))
            .ToDictionaryAsync(m => m.Id, m => m.Name);
        var categoryNames = await db.CostCategories.AsNoTracking().Where(c => categoryIds.Contains(c.Id))
            .ToDictionaryAsync(c => c.Id, c => c.Name);

        return batchIds
            .Select(id => (Id: id, Targets: new BatchTargets(
                [.. meterPairs.Where(p => p.Batch == id && meterNames.ContainsKey(p.MeterId))
                    .Select(p => new MeterTarget(p.MeterId, meterNames[p.MeterId]))
                    .OrderBy(m => m.Name, StringComparer.CurrentCulture)],
                [.. categoryPairs.Where(p => p.Batch == id && categoryNames.ContainsKey(p.CategoryId))
                    .Select(p => categoryNames[p.CategoryId])
                    .Order(StringComparer.CurrentCulture)])))
            .Where(t => t.Targets.Meters.Count > 0 || t.Targets.Categories.Count > 0)
            .ToDictionary(t => t.Id, t => t.Targets);
    }

    private sealed record MeterTarget(int Id, string Name);

    private sealed record BatchTargets(IReadOnlyList<MeterTarget> Meters, IReadOnlyList<string> Categories);

    private async Task RevertAsync(ImportBatch batch)
    {
        if (!await Confirm.ConfirmAsync(Dialogs, S.Import_RevertConfirmTitle,
                Loc.F(S.Import_RevertConfirmBody, batch.RowCount, batch.Id, batch.SourceName ?? S.Import_UnnamedSource),
                S.Import_Revert))
        {
            return;
        }

        _reverting = batch.Id;
        try
        {
            await ImportService.RevertAsync(batch.Id);
            Snackbar.Add(Loc.F(S.Import_BatchReverted, batch.Id), Severity.Success);
            await LoadBatchesAsync();
        }
        catch (Exception ex)
        {
            Snackbar.Add(Loc.F(S.Import_RevertFailed, ex.Message), Severity.Error);
        }
        finally
        {
            _reverting = null;
        }
    }

    private async Task LoadReferenceAsync()
    {
        _loadingReference = true;
        try
        {
            var dir = Path.Combine(AppContext.BaseDirectory, "sampledata");
            await ReferenceImporter.LoadAsync(dir);
            _referenceLoaded = true;
            Snackbar.Add(S.Import_ReferenceDataLoaded, Severity.Success);
            await LoadBatchesAsync();
        }
        catch (Exception ex)
        {
            Snackbar.Add(Loc.F(S.Import_Failed, ex.Message), Severity.Error);
        }
        finally
        {
            _loadingReference = false;
        }
    }

    private async Task PreviewAsync(InputFileChangeEventArgs args)
    {
        var file = args.File;
        if (file is null)
        {
            return;
        }

        var profile = SelectedProfile();
        using var reader = new StreamReader(file.OpenReadStream(maxAllowedSize: 5 * 1024 * 1024));
        var content = await reader.ReadToEndAsync();
        using var stringReader = new StringReader(content);
        _preview = CsvImporter.Stage(profile, stringReader);
    }

    private MappingProfile SelectedProfile() => _profileName switch
    {
        "Wasser" => ReferenceProfiles.Water(),
        "Heizöl" => ReferenceProfiles.HeatingOil(),
        "Kosten" => ReferenceProfiles.Costs(),
        _ => ReferenceProfiles.Electricity(),
    };
}