HTTP & files

namespace Rask.Site.Features;

// Illustrates the HttpClient registration pattern shown beside the live result. In each host's
// Program.cs the HttpClient is registered as a singleton pointed at the app's OWN origin, so
// relative fetches (e.g. "data/posts-1.json") resolve to the static files the app serves itself
// and the showcase stays self-contained and offline-safe. The base address differs per host —
// on WASM it is WasmHostBuilder.BaseAddress (the page origin, carrying any sub-path), read
// lazily inside the factory so it fires after the JS module imports; on the Server host it is
// the server's own origin. This component builds the same configured client and shows it.
public sealed partial class HttpRegisterDemo : Component
{
    // The factory the host registers: configure HttpClient to resolve relative URLs against the
    // app's own origin. Pass the origin in lazily (on WASM: () => WasmHostBuilder.BaseAddress).
    private static HttpClient CreateClient(Func<string> baseAddress) =>
        new() { BaseAddress = new Uri(baseAddress()) };

    protected override Component? Render() =>
        Ui.Card.Muted[
                Div.Class("text-sm text-zinc-500 dark:text-white/70 uppercase mb-1")["Configured HttpClient"],
                P.Class("mb-0 text-sm")[
                    "BaseAddress: ", Code[CreateClient(() => "https://localhost/").BaseAddress!.ToString()],
                    " — relative fetches resolve against the app's own origin."
                ]
            ];
}

using System.Net.Http.Json;
using System.Text.Json.Serialization;

namespace Rask.Site.Features;

// HttpClient and TimeProvider are registered as services (AddExampleServices) and injected through the
// primary constructor. Mount runs once on first render; the framework's async lifecycle handler
// triggers a re-render when the awaited task completes. Component.CancellationToken cancels on
// unmount — navigate away mid-fetch and the in-flight request aborts.
public sealed partial class HttpFetchDemo(HttpClient http, TimeProvider time) : Component
{
    private const int MaxTransientRetries = 3;
    private static readonly TimeSpan RetryDelay = 150.Milliseconds;

    // A fetch that never settles is the one failure the retry loop below could not see. Without a
    // per-attempt deadline the await simply never returns: no exception, no retry, and the spinner
    // stays up for ever — which is precisely the outcome the retries were written to prevent.
    private static readonly TimeSpan AttemptTimeout = 5.Seconds;

    private string? _error;
    private Post? _post;

    protected override async Task OnMount()
    {
        for (var attempt = 0; attempt <= MaxTransientRetries; attempt++)
        {
            // Every wait in this loop reads the injected clock rather than the wall clock: the system clock
            // in the app, and in a test a clock the test advances itself instead of waiting the delays out.
            using var timeout = new CancellationTokenSource(AttemptTimeout, time);
            using var deadline = CancellationTokenSource.CreateLinkedTokenSource(CancellationToken, timeout.Token);

            try
            {
                _post = await http.GetFromJsonAsync("data/posts-1.json", HttpJsonContext.Default.Post,
                    deadline.Token);
                return;
            }
            // Navigating away unmounts the page and cancels the token — the page is gone, nothing to show.
            // Distinguished from the deadline below by asking the COMPONENT's token, since a linked
            // source reports both the same way.
            catch (OperationCanceledException) when (CancellationToken.IsCancellationRequested) { return; }
            // The attempt itself ran out of time: a fetch that never settled. Retried like any other
            // transient transport failure.
            catch (OperationCanceledException) when (attempt < MaxTransientRetries)
            {
                try { await Task.Delay(RetryDelay, time, CancellationToken); }
                catch (OperationCanceledException) { return; }
            }
            // Still not settling after every retry. Says so, rather than reporting the framework's
            // "A task was canceled." — which tells a reader nothing about what was being waited on.
            catch (OperationCanceledException)
            {
                _error = $"The request did not complete within {AttemptTimeout.TotalSeconds:0}s.";
                return;
            }
            // On WASM a hard browser refresh kills the in-flight fetch outside the AbortController, so it
            // surfaces as an HttpRequestException with no StatusCode ("TypeError: Load failed") rather than
            // an OperationCanceledException. The same null-status failure also fires transiently on the
            // freshly-booted page when its first fetch races the discarded page's network teardown — so retry
            // a few times and the page self-heals instead of hanging on the spinner forever.
            catch (HttpRequestException ex) when (ex.StatusCode is null && attempt < MaxTransientRetries)
            {
                try { await Task.Delay(RetryDelay, time, CancellationToken); }
                catch (OperationCanceledException) { return; }
            }
            // A real HTTP-status failure, or a transport failure that never recovers, surfaces the error banner.
            catch (Exception ex)
            {
                _error = ex.Message;
                return;
            }
        }
    }

    protected override Component? Render()
    {
        if (_error is not null)
        {
            return Ui.Callout.Danger.Icon(Ui.IconName.XCircle).Role("alert").Heading("Error: ").Text(_error);
        }

        if (_post is null)
        {
            // Flux's loading icon spins; the words beside it are what a screen reader hears.
            return Ui.Text.Role("status").Class("flex items-center gap-2")[
                Ui.Icon.Name(Ui.IconName.Loading).Variant(Ui.IconVariant.Mini),
                "Loading…"
            ];
        }

        // An <article> around Flux's card: this is a self-contained syndicated item, and the element is the
        // semantics.
        return Article[
            Ui.Card[
                Ui.Text.Class("mb-1 uppercase")[$"Post #{_post.Id}"],
                Ui.Heading.Level(3)[_post.Title],
                Ui.Text.Class("mt-2")[_post.Body]
            ]
        ];
    }

    public sealed record Post(
        [property: JsonPropertyName("id")] int Id,
        [property: JsonPropertyName("title")] string Title,
        [property: JsonPropertyName("body")] string Body);
}

using System.Globalization;
using Rask.Core.Forms;

namespace Rask.Site.Features;

// A self-contained file-picker demo. A file Ui.Input's OnFiles wires the picker to a typed handler; IRaskFile carries the metadata while the handler is on the stack. The mutating
// handler lives in this component so its field updates re-render the right tree.
public sealed partial class UploadDemo : Component
{
    private string? _contentType;
    private DateTimeOffset _modified;
    private string? _name;
    private long _size;

    private void OnFiles(IReadOnlyList<IRaskFile> files)
    {
        if (files.Count == 0)
        {
            _name = null;
            return;
        }

        var file = files[0];
        _name = file.Name;
        _size = file.Size;
        _contentType = file.ContentType;
        _modified = file.LastModified;
    }

    protected override Component? Render() =>
        Div[
            Ui.Input.Of<string>()
                .Type(InputType.File)
                .Label("File")
                .Id("upload-input")
                .Class("mb-3")
                .OnFiles(OnFiles),
            _name is null
                ? Div.Class("text-zinc-500 dark:text-white/70 text-sm")["No file selected yet."]
                : Dl.Class("grid grid-cols-12 gap-4 text-sm mb-0")[
                    Dt.Class("col-span-4 text-zinc-500 dark:text-white/70")["Name"],
                    Dd.Class("col-span-8 text-break").Data(Meta("name"))[_name],
                    Dt.Class("col-span-4 text-zinc-500 dark:text-white/70")["Size"],
                    Dd.Class("col-span-8").Data(Meta("size"))[_size.ToString("N0", CultureInfo.InvariantCulture),
                        " bytes"],
                    Dt.Class("col-span-4 text-zinc-500 dark:text-white/70")["Type"],
                    Dd.Class("col-span-8").Data(Meta("type"))[_contentType ?? string.Empty],
                    Dt.Class("col-span-4 text-zinc-500 dark:text-white/70")["Modified"],
                    Dd.Class("col-span-8 mb-0").Data(Meta("modified"))[
                        _modified.ToString("u", CultureInfo.InvariantCulture)]
                ]
        ];

    private static new AttrBag Meta(string field) => new("rask-meta", field);
}

using System.Globalization;
using System.Text;

namespace Rask.Site.Features;

// Download.File stages bytes on the active session — served from /_rask/download/{sid}/{token}
// on the server, pulled by JS from the .NET side by token on WASM. It must be called from an event handler,
// so the state and the handler live together in this self-contained component.
public sealed partial class DownloadDemo : Component
{
    private int _reportCount;

    private void DownloadReport()
    {
        _reportCount++;
        var report =
            $"Rask download demo\nGenerated at {DateTimeOffset.UtcNow.ToString("u", CultureInfo.InvariantCulture)}\nCount: {_reportCount}\n";
        Download.File("report.txt", Encoding.UTF8.GetBytes(report), "text/plain");
    }

    protected override Component? Render() =>
        Div[
            Ui.Button.Primary.Icon(Ui.IconName.DocumentText).Id("download-report").OnClick(DownloadReport)["Download report"],
            Div
                .Class("text-sm text-zinc-500 dark:text-white/70 mt-2")
                .Data("rask-report-count", "true")[
                $"Generated {_reportCount} time(s)."
            ]
        ];
}