chapter-organizer/WebApp/Components/Features/Print/PagePrinter.razor

@page "/print"
@attribute [Authorize]
@implements IAsyncDisposable
@using Core.Printing
@using Core.Services
@inject INotesService NotesService
@inject INoteNamingService NoteNamingService
@inject INotePrintService NotePrintService
@inject IPrintPresetService PrintPresetService
@inject IConfiguration Configuration
@inject ISnackbar Snackbar
@inject IDialogService DialogService
@inject IJSRuntime JSRuntime
@inject ClipboardService ClipboardService

<div class="no-print">
    <PageHeader Title="Page printer"
                Description="Merge a markdown note onto students, teams, or events and print one page per match."
                Icon="@Icons.Material.Filled.Print" />

    <MudPaper Elevation="2" Class="pa-3 pa-md-6 mb-4">
        @if (_isLoading)
        {
            <MudProgressLinear Color="Color.Primary" Indeterminate="true" Class="mb-4" />
        }

        <MudGrid>
            <MudItem xs="12" md="4">
                <MudSelect T="int?"
                           Label="Print preset"
                           Value="_selectedPresetId"
                           ValueChanged="OnPresetSelected"
                           Clearable="true"
                           Variant="Variant.Outlined">
                    @foreach (var preset in _presets)
                    {
                        <MudSelectItem T="int?" Value="@preset.Id">@preset.Name</MudSelectItem>
                    }
                </MudSelect>
            </MudItem>
            <MudItem xs="12" md="3">
                <MudTextField @bind-Value="_saveAsName"
                              Label="Save as name"
                              Variant="Variant.Outlined"
                              Immediate="true" />
            </MudItem>
            <MudItem xs="12" md="5" Class="d-flex align-center gap-2 flex-wrap">
                <MudButton Variant="Variant.Outlined"
                           StartIcon="@Icons.Material.Filled.Save"
                           OnClick="SaveAsPreset"
                           Disabled="@(_isBusy || !CanSaveAs)">
                    Save as
                </MudButton>
                <MudButton Variant="Variant.Outlined"
                           OnClick="UpdatePreset"
                           Disabled="@(_isBusy || !_selectedPresetId.HasValue || !CanPreview)">
                    Update
                </MudButton>
                <MudButton Variant="Variant.Outlined"
                           Color="Color.Error"
                           OnClick="DeletePreset"
                           Disabled="@(_isBusy || !_selectedPresetId.HasValue)">
                    Delete
                </MudButton>
            </MudItem>

            <MudItem xs="12" md="4">
                <MudSelect T="PrintEntityType"
                           Label="Entity"
                           Value="_entityType"
                           ValueChanged="OnEntityTypeChanged"
                           Variant="Variant.Outlined">
                    <MudSelectItem Value="PrintEntityType.Student">Students</MudSelectItem>
                    <MudSelectItem Value="PrintEntityType.Team">Teams</MudSelectItem>
                    <MudSelectItem Value="PrintEntityType.Event">Events</MudSelectItem>
                </MudSelect>
            </MudItem>
            <MudItem xs="12" md="8">
                @if (_templateNotes.Count == 0)
                {
                    <MudAlert Severity="Severity.Info">
                        Create a standalone note on <MudLink Href="/notes">Notes</MudLink> to use as a template.
                    </MudAlert>
                }
                else
                {
                    <MudSelect T="int?"
                               Label="Template note"
                               Value="_selectedNoteId"
                               ValueChanged="OnNoteSelected"
                               Variant="Variant.Outlined">
                        @foreach (var note in _templateNotes)
                        {
                            <MudSelectItem T="int?" Value="@note.Id">@note.Title</MudSelectItem>
                        }
                    </MudSelect>
                }
            </MudItem>

            @if (_templateWarning is not null)
            {
                <MudItem xs="12">
                    <MudAlert Severity="Severity.Warning">@_templateWarning</MudAlert>
                </MudItem>
            }

            @if (_entityType == PrintEntityType.Student)
            {
                <MudItem xs="12" sm="4" md="3">
                    <MudNumericField T="int?"
                                     Label="Grade"
                                     Value="_grade"
                                     ValueChanged="OnGradeChanged"
                                     Variant="Variant.Outlined"
                                     Min="5"
                                     Max="12"
                                     Clearable="true" />
                </MudItem>
                <MudItem xs="12" sm="4" md="3">
                    <MudNumericField T="int?"
                                     Label="TSA year"
                                     Value="_tsaYear"
                                     ValueChanged="OnTsaYearChanged"
                                     Variant="Variant.Outlined"
                                     Min="1"
                                     Max="12"
                                     Clearable="true" />
                </MudItem>
                <MudItem xs="12" sm="4" md="3">
                    <MudSelect T="string"
                               Label="Officer"
                               Value="@_officerChoice"
                               ValueChanged="OnOfficerChanged"
                               Variant="Variant.Outlined">
                        <MudSelectItem Value="@("any")">Any</MudSelectItem>
                        <MudSelectItem Value="@("yes")">Officers only</MudSelectItem>
                        <MudSelectItem Value="@("no")">Non-officers only</MudSelectItem>
                    </MudSelect>
                </MudItem>
            }
            else if (_entityType == PrintEntityType.Team)
            {
                <MudItem xs="12" md="4">
                    <MudTextField T="string"
                                  Value="@_teamIdentifierContains"
                                  ValueChanged="OnTeamIdentifierChanged"
                                  Label="Identifier contains"
                                  Variant="Variant.Outlined"
                                  Immediate="true" />
                </MudItem>
            }
            else
            {
                <MudItem xs="12" sm="4">
                    <MudTextField T="string"
                                  Value="@_eventNameContains"
                                  ValueChanged="OnEventNameChanged"
                                  Label="Name contains"
                                  Variant="Variant.Outlined"
                                  Immediate="true" />
                </MudItem>
                <MudItem xs="12" sm="4">
                    <MudSelect T="EventFormat?"
                               Label="Event format"
                               Value="_eventFormat"
                               ValueChanged="OnEventFormatChanged"
                               Variant="Variant.Outlined"
                               Clearable="true">
                        @foreach (var format in Enum.GetValues<EventFormat>())
                        {
                            <MudSelectItem T="EventFormat?" Value="@format">@format</MudSelectItem>
                        }
                    </MudSelect>
                </MudItem>
                <MudItem xs="12" sm="4">
                    <MudSelect T="string"
                               Label="Regional"
                               Value="@_regionalChoice"
                               ValueChanged="OnRegionalChanged"
                               Variant="Variant.Outlined">
                        <MudSelectItem Value="@("any")">Any</MudSelectItem>
                        <MudSelectItem Value="@("yes")">Regional only</MudSelectItem>
                        <MudSelectItem Value="@("no")">Non-regional only</MudSelectItem>
                    </MudSelect>
                </MudItem>
            }

            <MudItem xs="12">
                <MudStack Row="true" Spacing="2" AlignItems="AlignItems.Center" Class="flex-wrap">
                    <MudButton Variant="Variant.Filled"
                               Color="Color.Primary"
                               StartIcon="@Icons.Material.Filled.Visibility"
                               OnClick="Preview"
                               Disabled="@(_isBusy || !CanPreview)">
                        Preview
                    </MudButton>
                    <MudButton Variant="Variant.Outlined"
                               StartIcon="@Icons.Material.Filled.Print"
                               OnClick="Print"
                               Disabled="@(_isBusy || _previewStale || _pages.Count == 0)">
                        Print
                    </MudButton>
                    <MudCheckBox T="bool"
                                 Value="@_newPagePerRecord"
                                 ValueChanged="OnNewPagePerRecordChanged"
                                 Label="New page per record"
                                 Dense="true" />
                    <MudNumericField T="int"
                                     Label="Font size (pt)"
                                     Value="_fontSizePt"
                                     ValueChanged="OnFontSizeChanged"
                                     Variant="Variant.Outlined"
                                     Margin="Margin.Dense"
                                     Min="PrintPresetFilters.MinFontSizePt"
                                     Max="PrintPresetFilters.MaxFontSizePt"
                                     Style="max-width: 8rem;" />
                    <MudNumericField T="int"
                                     Label="Answer lines"
                                     Value="_answerSpaceLines"
                                     ValueChanged="OnAnswerSpaceLinesChanged"
                                     Variant="Variant.Outlined"
                                     Margin="Margin.Dense"
                                     Min="PrintPresetFilters.MinAnswerSpaceLines"
                                     Max="PrintPresetFilters.MaxAnswerSpaceLines"
                                     Style="max-width: 8rem;" />
                    @if (!_previewStale && _pages.Count > 0)
                    {
                        <MudText Typo="Typo.body2">@_pages.Count page@(_pages.Count == 1 ? "" : "s")</MudText>
                    }
                    else if (!_previewStale && _didPreview)
                    {
                        <MudText Typo="Typo.body2">No matches</MudText>
                    }
                </MudStack>
            </MudItem>

            <MudItem xs="12">
                <MudText Typo="Typo.caption" Class="mud-text-secondary mb-1">Tokens (click to copy)</MudText>
                @foreach (var group in TokenGroups)
                {
                    <MudText Typo="Typo.caption" Class="mud-text-secondary">@group.Label</MudText>
                    <div class="mb-2">
                        @foreach (var token in group.Tokens)
                        {
                            <MudChip T="string" Size="Size.Small" OnClick="() => CopyToken(token)" Class="ma-1">@FormatToken(token)</MudChip>
                        }
                    </div>
                }
            </MudItem>
        </MudGrid>
    </MudPaper>
</div>

@if (_didPreview && _pages.Count == 0 && !_previewStale)
{
    <MudText Class="no-print mud-text-secondary">No matching records for these filters.</MudText>
}
else
{
    @for (var i = 0; i < _pages.Count; i++)
    {
        var page = _pages[i];
        var isLast = i == _pages.Count - 1;
        var pageClass = _newPagePerRecord && !isLast
            ? "note-print-page pagebreak"
            : "note-print-page";
        <MudContainer Class="@pageClass" Style="@PrintPageStyle">
            <div class="markdown-content">
                @((MarkupString)page.Html)
            </div>
        </MudContainer>
    }
}

@code {
    private CancellationTokenSource? _cancellationTokenSource;
    private bool _isDisposed;
    private bool _isLoading = true;
    private bool _isBusy;
    private bool _previewStale = true;
    private bool _didPreview;

    private List<Note> _templateNotes = [];
    private List<PrintPreset> _presets = [];
    private List<string> _importedTokenNames = [];
    private IReadOnlyList<NotePrintPage> _pages = [];

    private int? _selectedPresetId;
    private int? _selectedNoteId;
    private string _saveAsName = string.Empty;
    private string? _templateWarning;
    private PrintEntityType _entityType = PrintEntityType.Student;
    private int? _grade;
    private int? _tsaYear;
    private string _officerChoice = "any";
    private string? _teamIdentifierContains;
    private string? _eventNameContains;
    private EventFormat? _eventFormat;
    private string _regionalChoice = "any";
    private bool _newPagePerRecord = true;
    private int _fontSizePt = PrintPresetFilters.DefaultFontSizePt;
    private int _answerSpaceLines = PrintPresetFilters.DefaultAnswerSpaceLines;

    private static string FormatToken(string token) => "{{" + token + "}}";

    private string PrintPageStyle =>
        $"--print-font-size:{_fontSizePt}pt;--print-answer-lines:{_answerSpaceLines};";

    private IEnumerable<(string Label, IReadOnlyList<string> Tokens)> TokenGroups
    {
        get
        {
            yield return ("Layout", PrintFieldCatalog.Layout);
            yield return ("Chapter", PrintFieldCatalog.Chapter);
            yield return (_entityType.ToString(), PrintFieldCatalog.EntityTokens(_entityType));
            if (_entityType == PrintEntityType.Student && _importedTokenNames.Count > 0)
                yield return ("Additional fields", _importedTokenNames);
        }
    }

    private bool CanPreview =>
        _selectedNoteId.HasValue
        && SelectedTemplateNote is { Content: not null } note
        && !string.IsNullOrWhiteSpace(note.Content)
        && !note.IsDeleted
        && _templateWarning is null;

    private bool CanSaveAs =>
        CanPreview && !string.IsNullOrWhiteSpace(_saveAsName);

    private Note? SelectedTemplateNote =>
        _templateNotes.FirstOrDefault(n => n.Id == _selectedNoteId);

    protected override void OnInitialized()
    {
        _cancellationTokenSource = new CancellationTokenSource();
    }

    protected override async Task OnInitializedAsync()
    {
        await LoadAsync();
    }

    private async Task LoadAsync()
    {
        if (_isDisposed)
            return;

        _isLoading = true;
        try
        {
            var token = _cancellationTokenSource?.Token ?? CancellationToken.None;

            var notes = await NotesService.GetNotesAsync();
            _templateNotes =
            [
                .. notes.Where(n => !NoteNamingService.IsPageNote(n.Title))
                    .OrderBy(n => n.Title)
            ];

            await RefreshImportedTokenNamesAsync(token);
            _presets = [.. await PrintPresetService.GetAllAsync(token)];
        }
        catch (TaskCanceledException)
        {
        }
        catch (JSDisconnectedException)
        {
        }
        finally
        {
            if (!_isDisposed)
                _isLoading = false;
        }
    }

    private void MarkStale()
    {
        _previewStale = true;
        _pages = [];
    }

    private void OnEntityTypeChanged(PrintEntityType value)
    {
        _entityType = value;
        _templateWarning = null;
        MarkStale();
    }

    private void OnNoteSelected(int? value)
    {
        _selectedNoteId = value;
        _templateWarning = null;
        MarkStale();
    }

    private void OnGradeChanged(int? value)
    {
        _grade = value;
        MarkStale();
    }

    private void OnTsaYearChanged(int? value)
    {
        _tsaYear = value;
        MarkStale();
    }

    private void OnOfficerChanged(string value)
    {
        _officerChoice = value;
        MarkStale();
    }

    private void OnTeamIdentifierChanged(string? value)
    {
        _teamIdentifierContains = value;
        MarkStale();
    }

    private void OnEventNameChanged(string? value)
    {
        _eventNameContains = value;
        MarkStale();
    }

    private void OnEventFormatChanged(EventFormat? value)
    {
        _eventFormat = value;
        MarkStale();
    }

    private void OnRegionalChanged(string value)
    {
        _regionalChoice = value;
        MarkStale();
    }

    private void OnNewPagePerRecordChanged(bool value)
    {
        _newPagePerRecord = value;
    }

    private void OnFontSizeChanged(int value)
    {
        _fontSizePt = Math.Clamp(value, PrintPresetFilters.MinFontSizePt, PrintPresetFilters.MaxFontSizePt);
    }

    private void OnAnswerSpaceLinesChanged(int value)
    {
        _answerSpaceLines = Math.Clamp(value, PrintPresetFilters.MinAnswerSpaceLines, PrintPresetFilters.MaxAnswerSpaceLines);
    }

    private async Task RefreshImportedTokenNamesAsync(CancellationToken token)
    {
        var indexFields = WebApp.Models.ChapterSettings.ReadIndexNoteFields(Configuration);
        var discovered = await NotesService.GetImportedFieldNamesAsync(token);
        _importedTokenNames =
        [
            .. indexFields
                .Concat(discovered)
                .Distinct(StringComparer.OrdinalIgnoreCase)
                .OrderBy(n => n, StringComparer.OrdinalIgnoreCase)
        ];
    }

    private async Task OnPresetSelected(int? id)
    {
        _selectedPresetId = id;
        if (!id.HasValue)
        {
            MarkStale();
            return;
        }

        var preset = _presets.FirstOrDefault(p => p.Id == id.Value);
        if (preset is null)
            return;

        ApplyPreset(preset);
        MarkStale();
        await Task.CompletedTask;
    }

    private void ApplyPreset(PrintPreset preset)
    {
        _saveAsName = preset.Name;
        _entityType = preset.EntityType;
        var filters = PrintPresetFilters.FromJson(preset.FiltersJson);
        _grade = filters.Grade;
        _tsaYear = filters.TsaYear;
        _officerChoice = PrintPresetFilters.ToTriState(filters.IsOfficer);
        _teamIdentifierContains = filters.TeamIdentifierContains;
        _eventNameContains = filters.EventNameContains;
        _eventFormat = filters.EventFormat;
        _regionalChoice = PrintPresetFilters.ToTriState(filters.RegionalOnly);
        _newPagePerRecord = filters.NewPagePerRecord;
        _fontSizePt = filters.FontSizePt;
        _answerSpaceLines = filters.AnswerSpaceLines;

        var note = _templateNotes.FirstOrDefault(n => n.Id == preset.NoteId);
        if (note is null || note.IsDeleted || string.IsNullOrWhiteSpace(note.Content))
        {
            _selectedNoteId = null;
            _templateWarning = "This preset's template note is missing or empty. Choose another note.";
        }
        else
        {
            _selectedNoteId = note.Id;
            _templateWarning = null;
        }
    }

    private PrintPresetFilters BuildFilters() =>
        new()
        {
            Grade = _entityType == PrintEntityType.Student ? _grade : null,
            TsaYear = _entityType == PrintEntityType.Student ? _tsaYear : null,
            IsOfficer = _entityType == PrintEntityType.Student ? PrintPresetFilters.FromTriState(_officerChoice) : null,
            TeamIdentifierContains = _entityType == PrintEntityType.Team ? _teamIdentifierContains : null,
            EventNameContains = _entityType == PrintEntityType.Event ? _eventNameContains : null,
            EventFormat = _entityType == PrintEntityType.Event ? _eventFormat : null,
            RegionalOnly = _entityType == PrintEntityType.Event ? PrintPresetFilters.FromTriState(_regionalChoice) : null,
            NewPagePerRecord = _newPagePerRecord,
            FontSizePt = _fontSizePt,
            AnswerSpaceLines = _answerSpaceLines
        };

    private async Task Preview()
    {
        if (_isDisposed || !CanPreview)
            return;

        _isBusy = true;
        try
        {
            var token = _cancellationTokenSource?.Token ?? CancellationToken.None;
            await RefreshImportedTokenNamesAsync(token);

            var note = SelectedTemplateNote!;
            _pages = await NotePrintService.PreviewAsync(
                new NotePrintRequest
                {
                    EntityType = _entityType,
                    TemplateMarkdown = note.Content ?? string.Empty,
                    Filters = BuildFilters(),
                    ImportedFieldCatalog = _importedTokenNames
                },
                token);

            _previewStale = false;
            _didPreview = true;

            if (_pages.Count > 75 && !_isDisposed)
            {
                Snackbar.Add(
                    $"This preview has {_pages.Count} pages. Printing a large set can be slow.",
                    Severity.Warning);
            }
        }
        catch (TaskCanceledException)
        {
        }
        catch (JSDisconnectedException)
        {
        }
        catch (Exception ex)
        {
            if (!_isDisposed)
                Snackbar.Add($"Preview failed: {ex.Message}", Severity.Error);
        }
        finally
        {
            if (!_isDisposed)
                _isBusy = false;
        }
    }

    private async Task Print()
    {
        if (_isDisposed || _previewStale || _pages.Count == 0)
            return;

        try
        {
            await JSRuntime.InvokeVoidAsync("window.print");
        }
        catch (JSDisconnectedException)
        {
        }
        catch (TaskCanceledException)
        {
        }
    }

    private async Task CopyToken(string token)
    {
        if (_isDisposed)
            return;

        try
        {
            await ClipboardService.WriteTextAsync($"{{{{{token}}}}}");
            if (!_isDisposed)
                Snackbar.Add($"Copied {FormatToken(token)}", Severity.Info);
        }
        catch (JSDisconnectedException)
        {
        }
        catch (TaskCanceledException)
        {
        }
        catch (Exception ex)
        {
            if (!_isDisposed)
                Snackbar.Add($"Could not copy: {ex.Message}", Severity.Error);
        }
    }

    private async Task SaveAsPreset()
    {
        if (_isDisposed || !CanSaveAs || !_selectedNoteId.HasValue)
            return;

        _isBusy = true;
        try
        {
            var token = _cancellationTokenSource?.Token ?? CancellationToken.None;
            var name = _saveAsName.Trim();
            if (await PrintPresetService.NameExistsAsync(name, null, token))
            {
                Snackbar.Add($"A print preset named '{name}' already exists.", Severity.Warning);
                return;
            }

            var created = await PrintPresetService.CreateAsync(
                new PrintPreset
                {
                    Name = name,
                    NoteId = _selectedNoteId.Value,
                    EntityType = _entityType,
                    FiltersJson = BuildFilters().ToJson()
                },
                token);

            _presets = [.. await PrintPresetService.GetAllAsync(token)];
            _selectedPresetId = created.Id;
            if (!_isDisposed)
                Snackbar.Add($"Saved print preset '{name}'.", Severity.Success);
        }
        catch (TaskCanceledException)
        {
        }
        catch (JSDisconnectedException)
        {
        }
        catch (Exception ex)
        {
            if (!_isDisposed)
                Snackbar.Add($"Could not save: {ex.Message}", Severity.Error);
        }
        finally
        {
            if (!_isDisposed)
                _isBusy = false;
        }
    }

    private async Task UpdatePreset()
    {
        if (_isDisposed || !_selectedPresetId.HasValue || !_selectedNoteId.HasValue || !CanPreview)
            return;

        _isBusy = true;
        try
        {
            var token = _cancellationTokenSource?.Token ?? CancellationToken.None;
            var existing = _presets.FirstOrDefault(p => p.Id == _selectedPresetId.Value);
            if (existing is null)
                return;

            await PrintPresetService.UpdateAsync(
                new PrintPreset
                {
                    Id = existing.Id,
                    Name = existing.Name,
                    NoteId = _selectedNoteId.Value,
                    EntityType = _entityType,
                    FiltersJson = BuildFilters().ToJson()
                },
                token);

            _presets = [.. await PrintPresetService.GetAllAsync(token)];
            if (!_isDisposed)
                Snackbar.Add($"Updated print preset '{existing.Name}'.", Severity.Success);
        }
        catch (TaskCanceledException)
        {
        }
        catch (JSDisconnectedException)
        {
        }
        catch (Exception ex)
        {
            if (!_isDisposed)
                Snackbar.Add($"Could not update: {ex.Message}", Severity.Error);
        }
        finally
        {
            if (!_isDisposed)
                _isBusy = false;
        }
    }

    private async Task DeletePreset()
    {
        if (_isDisposed || !_selectedPresetId.HasValue)
            return;

        var existing = _presets.FirstOrDefault(p => p.Id == _selectedPresetId.Value);
        if (existing is null)
            return;

        var confirmed = await DialogService.ShowMessageBox(
            "Delete print preset",
            (MarkupString)$"Delete <b>{existing.Name}</b>? This cannot be undone.",
            yesText: "Delete",
            cancelText: "Cancel");

        if (confirmed != true || _isDisposed)
            return;

        _isBusy = true;
        try
        {
            var token = _cancellationTokenSource?.Token ?? CancellationToken.None;
            await PrintPresetService.DeleteAsync(existing.Id, token);
            _presets = [.. await PrintPresetService.GetAllAsync(token)];
            _selectedPresetId = null;
            if (!_isDisposed)
                Snackbar.Add($"Deleted print preset '{existing.Name}'.", Severity.Info);
        }
        catch (TaskCanceledException)
        {
        }
        catch (JSDisconnectedException)
        {
        }
        catch (Exception ex)
        {
            if (!_isDisposed)
                Snackbar.Add($"Could not delete: {ex.Message}", Severity.Error);
        }
        finally
        {
            if (!_isDisposed)
                _isBusy = false;
        }
    }

    public async ValueTask DisposeAsync()
    {
        if (!_isDisposed)
        {
            _isDisposed = true;
            _cancellationTokenSource?.Cancel();
            _cancellationTokenSource?.Dispose();
            _cancellationTokenSource = null;
        }

        await ValueTask.CompletedTask;
    }
}