@page "/git/{Repository}/commit/{Sha}"
@inherits GitPage

<PageTitle>@Title — git</PageTitle>

<GitBar Repository="@Repository" Reference="@Reference" Tab="log"
        Path="@(new[] { new GitBar.Crumb(Short, null) })"/>

<main class="git-main">
    @if (View is not { } view)
    {
        <section class="block">
            <p class="empty">No commit @Sha in @Repository.</p>
        </section>
    }
    else
    {
        <section class="block">
            <h2 class="block-head">
                <span class="subject">@view.Commit.Summary</span>
                <span class="block-note">
                    @foreach (var name in view.Commit.Refs)
                    {
                        <span class="ref">@name</span>
                    }
                </span>
            </h2>

            <div class="block-body">
                @if (view.Commit.Body is { Length: > 0 } body)
                {
                    <p class="message">@body</p>
                }

                <dl class="pairs">
                    <dt>author</dt>
                    <dd>
                        @view.Commit.Author.Name <span class="dim">&lt;@view.Commit.Author.Email&gt;</span>
                        <span class="dim">· @Exact(view.Commit.Author.When)</span>
                    </dd>

                    @if (Differs(view.Commit))
                    {
                        <dt>committer</dt>
                        <dd>
                            @view.Commit.Committer.Name <span class="dim">&lt;@view.Commit.Committer.Email&gt;</span>
                            <span class="dim">· @Exact(view.Commit.Committer.When)</span>
                        </dd>
                    }

                    <dt>commit</dt>
                    <dd class="sha copyable">@view.Commit.Sha</dd>

                    @if (view.Commit.Parents.Count > 0)
                    {
                        <dt>parent@(view.Commit.Parents.Count == 1 ? "" : "s")</dt>
                        <dd>
                            @foreach (var parent in view.Commit.Parents)
                            {
                                <a class="sha" href="@CommitLink(parent)">@Shorten(parent)</a>
                                <text> </text>
                            }
                        </dd>
                    }

                    <dt>tree</dt>
                    <dd><a href="@TreeLink("", view.Commit.Sha)">browse at this commit</a></dd>
                </dl>
            </div>
        </section>

        <section class="block">
            <h2 class="block-head">
                <span>@Changed(view.Diff)</span>
                <span class="block-note stat">
                    <span class="plus">+@view.Diff.Added</span>
                    <span class="minus">-@view.Diff.Deleted</span>
                </span>
            </h2>

            @if (view.Diff.Files.Count == 0)
            {
                <p class="empty">
                    @(view.Commit.IsMerge
                        ? "Nothing changed against the first parent — the other side brought it all."
                        : "No changes.")
                </p>
            }
            else
            {
                <div class="scroll">
                    <table>
                        <tbody>
                        @for (var index = 0; index < view.Diff.Files.Count; index++)
                        {
                            var file = view.Diff.Files[index];
                            <tr>
                                <td class="wide"><a href="#@Anchor(index)">@file.Path</a></td>
                                <td class="dim">@ChangeLabel(file.Change)</td>
                                <td class="num stat">
                                    <span class="plus">+@file.Added</span>
                                    <span class="minus">-@file.Deleted</span>
                                </td>
                            </tr>
                        }
                        </tbody>
                    </table>
                </div>
            }

            @if (view.Diff.Truncated)
            {
                <p class="empty">
                    This diff is longer than one page will show. The files below it keep their
                    counts; read them at
                    <a href="@TreeLink("", view.Commit.Sha)">this commit's tree</a> instead.
                </p>
            }
        </section>

        @for (var index = 0; index < view.Diff.Files.Count; index++)
        {
            var file = view.Diff.Files[index];
            var grammar = Highlighted ? SyntaxHighlighter.GrammarFor(file.Path) : null;

            <section class="block diff-file" id="@Anchor(index)">
                <h2 class="block-head">
                    <span>
                        @if (file.OldPath is { } old)
                        {
                            <span class="dim">@old → </span>
                        }
                        <a href="@TreeLink(file.Path, view.Commit.Sha)">@file.Path</a>
                    </span>
                    <span class="block-note stat">
                        <span class="plus">+@file.Added</span>
                        <span class="minus">-@file.Deleted</span>
                    </span>
                </h2>

                @if (file.IsBinary)
                {
                    <p class="empty">
                        Binary file.
                        <a href="@RawLink(file.Path, view.Commit.Sha)">Download it</a> as it was here.
                    </p>
                }
                else if (file.Skipped)
                {
                    <p class="empty">Too far down a long diff to render. @file.Added added, @file.Deleted removed.</p>
                }
                else if (file.Hunks.Count == 0)
                {
                    <p class="empty">@(ChangeLabel(file.Change) is { Length: > 0 } label ? label : "No textual change") — no lines changed.</p>
                }
                else
                {
                    <div class="scroll">
                        <table class="code-table diff">
                            <tbody>
                            @foreach (var hunk in file.Hunks)
                            {
                                var tokens = Highlight(hunk, grammar);

                                <tr class="hunk">
                                    <td colspan="3">@hunk.Header</td>
                                </tr>

                                @for (var row = 0; row < hunk.Lines.Count; row++)
                                {
                                    var line = hunk.Lines[row];

                                    @if (line.Origin == '\\')
                                    {
                                        <tr class="note">
                                            <td colspan="3">@line.Text</td>
                                        </tr>
                                    }
                                    else
                                    {
                                        <tr class="@Row(line.Origin)">
                                            <td class="ln">@line.OldNumber</td>
                                            <td class="ln">@line.NewNumber</td>
                                            <td class="code"><GitCode Tokens="@(tokens[row])" Sign="@line.Origin"/></td>
                                        </tr>
                                    }
                                }
                            }
                            </tbody>
                        </table>
                    </div>
                }
            </section>
        }
    }
</main>

@code {
    /// <summary>
    /// A diff longer than this is shown without highlighting. Every token in a highlighted line
    /// becomes a span, which is several times the length of the line itself, and a diff of
    /// machine-generated markup is almost entirely tokens — the commit that vendored the Warframe
    /// drop tables turned a 0.5 MB page into a 2.3 MB one. Nobody is reading a diff that size
    /// line by line, so it keeps its numbers and loses its spans.
    /// </summary>
    private const int MaxHighlightCharacters = 60_000;

    [Parameter]
    public string Sha { get; set; } = "";

    private GitCommitView? View { get; set; }

    /// <summary>Whether this diff is small enough to be worth marking up. See above.</summary>
    private bool Highlighted { get; set; }

    private string Short => Shorten(View?.Commit.Sha ?? Sha);

    private string Title => View is { } view ? $"{view.Commit.Summary} · {Repository}" : Repository;

    protected override void OnParametersSet()
    {
        View = Service.GetCommit(Repository, Sha);

        if (View is null)
        {
            NotFound();
            return;
        }

        Highlighted = View.Diff.Files
            .Sum(file => file.Hunks.Sum(hunk => hunk.Lines.Sum(line => line.Text.Length)))
            <= MaxHighlightCharacters;
    }

    private static string Shorten(string sha) => sha.Length >= 10 ? sha[..10] : sha;

    /// <summary>A committer line worth printing is one that says something the author's didn't.</summary>
    private static bool Differs(GitCommitInfo commit) =>
        commit.Committer.Email != commit.Author.Email || commit.Committer.When != commit.Author.When;

    private static string Changed(GitDiff diff) =>
        diff.Files.Count == 1 ? "1 file changed" : $"{diff.Files.Count} files changed";

    private static string Anchor(int index) => $"f{index}";

    /// <summary>Tokens for every line of a hunk, in the order the hunk lists them.</summary>
    /// <remarks>
    /// A diff line on its own is not enough to highlight with. A block comment or a template
    /// literal that opened three lines above it would go unnoticed, and the prose inside it would
    /// come back out as keywords.
    ///
    /// A hunk is enough, because a hunk is two contiguous runs of text: the lines the new file has
    /// (context and added) and the lines the old file had (context and removed). Each side is
    /// highlighted whole and each line takes its share back. Context lines belong to both, so the
    /// new side runs second and wins — the text is the same either way.
    ///
    /// A comment that opened before the hunk began is still lost. Git did not send those lines,
    /// so there is nothing here that could know about it.
    /// </remarks>
    private static IReadOnlyList<IReadOnlyList<SyntaxToken>> Highlight(GitDiffHunk hunk, SyntaxGrammar? grammar)
    {
        var tokens = new IReadOnlyList<SyntaxToken>[hunk.Lines.Count];
        Array.Fill(tokens, []);

        Side('-');
        Side('+');

        return tokens;

        void Side(char origin)
        {
            var rows = Enumerable.Range(0, hunk.Lines.Count)
                .Where(row => hunk.Lines[row].Origin == origin || hunk.Lines[row].Origin == ' ')
                .ToArray();

            var lines = SyntaxHighlighter.Highlight(
                string.Join('\n', rows.Select(row => hunk.Lines[row].Text)),
                grammar);

            for (var row = 0; row < rows.Length && row < lines.Count; row++) tokens[rows[row]] = lines[row];
        }
    }

    private static string Row(char origin) => origin switch
    {
        '+' => "add",
        '-' => "del",
        _ => "ctx"
    };
}