@page "/git/{Repository}/tree"
@page "/git/{Repository}/tree/{*Path}"
@inherits GitPage

<PageTitle>@Title — git</PageTitle>

<GitBar Repository="@Repository" Reference="@At" Tab="tree" Path="@Crumbs"/>

<main class="git-main">
    @if (View is not { } view)
    {
        <section class="block">
            <p class="empty">
                @(Empty
                    ? $"Nothing has been pushed to {Repository} yet."
                    : $"No revision called {Reference ?? "HEAD"} in {Repository}.")
            </p>
        </section>
    }
    else if (view.Entries is { } entries)
    {
        <section class="block tree">
            <h2 class="block-head">
                <span>@(Path is { Length: > 0 } ? Path : "/")</span>
                <span class="block-note">
                    @Counted(entries) at
                    <a class="sha" href="@CommitLink(view.Commit.Sha)">@view.Commit.ShortSha</a>
                </span>
            </h2>

            <div class="scroll">
                <table>
                    <thead>
                    <tr>
                        <th>mode</th>
                        <th class="wide">name</th>
                        <th class="num">size</th>
                    </tr>
                    </thead>
                    <tbody>
                    @if (Parent is { } parent)
                    {
                        <tr>
                            <td class="mode"></td>
                            <td class="wide"><a href="@TreeLink(parent, At)">..</a></td>
                            <td class="num"></td>
                        </tr>
                    }
                    @foreach (var entry in entries)
                    {
                        <tr class="@(entry.Kind == GitEntryKind.Directory ? "dir" : null)">
                            <td class="mode dim">@Mode(entry.Kind)</td>
                            <td class="wide">
                                @if (entry.Kind == GitEntryKind.Submodule)
                                {
                                    @entry.Name
                                    <span class="ref">@entry.Sha[..10]</span>
                                }
                                else
                                {
                                    <a href="@TreeLink(entry.Path, At)">@entry.Name</a>
                                }
                            </td>
                            <td class="num dim">@(entry.Kind == GitEntryKind.Directory ? "" : Size(entry.Size))</td>
                        </tr>
                    }
                    </tbody>
                </table>
            </div>
        </section>
    }
    else if (view.Blob is { } blob)
    {
        <section class="block">
            <h2 class="block-head">
                <span>@blob.Path</span>
                <span class="block-note">
                    @Size(blob.Size)@(Code.Count > 0 ? $" · {Counted(Code.Count, "line")}" : "")
                    · <a href="@RawLink(blob.Path, At)">raw</a>
                    · <a href="@LogLink(At, blob.Path)">history</a>
                </span>
            </h2>

            @if (blob.IsBinary)
            {
                <p class="empty">
                    Binary file. <a href="@RawLink(blob.Path, At)">Download it</a> to look inside.
                </p>
            }
            else if (blob.TooLarge)
            {
                <p class="empty">
                    Too large to print here. <a href="@RawLink(blob.Path, At)">Read it raw</a>.
                </p>
            }
            else if (Code.Count == 0)
            {
                <p class="empty">Empty file.</p>
            }
            else
            {
                @* Every line is addressable: #L42 scrolls to it and marks it, so a line of code
                   can be linked to from anywhere. *@
                <div class="scroll">
                    <table class="code-table">
                        <tbody>
                        @for (var number = 1; number <= Code.Count; number++)
                        {
                            <tr id="L@(number)">
                                <td class="ln"><a href="#L@(number)">@number</a></td>
                                <td class="code"><GitCode Tokens="@Code[number - 1]"/></td>
                            </tr>
                        }
                        </tbody>
                    </table>
                </div>
            }
        </section>
    }
    else
    {
        <section class="block">
            <p class="empty">Nothing browsable at @Path in @view.Reference.</p>
        </section>
    }
</main>

@code {
    /// <summary>The path inside the repository, straight off the catch-all route segment.</summary>
    [Parameter]
    public string? Path { get; set; }

    private GitPathView? View { get; set; }

    /// <summary>
    /// The revision every link on this page stays on: what was asked for, or the branch the
    /// repository's HEAD is on. Following a tree into a directory should not silently move you.
    /// </summary>
    private string? At => Reference ?? View?.Reference;

    private string Title =>
        Path is { Length: > 0 } path ? $"{path} · {Repository}" : $"{Repository} tree";

    private IReadOnlyList<GitBar.Crumb> Crumbs { get; set; } = [];

    /// <summary>Set when the repository is real but has nothing in it yet.</summary>
    private bool Empty { get; set; }

    /// <summary>The file being shown, one list of tokens per line. Empty unless this is a blob.</summary>
    private IReadOnlyList<IReadOnlyList<SyntaxToken>> Code { get; set; } = [];

    /// <summary>The directory above, or null at the root.</summary>
    private string? Parent
    {
        get
        {
            if (Path is not { Length: > 0 } path) return null;
            var cut = path.LastIndexOf('/');
            return cut < 0 ? "" : path[..cut];
        }
    }

    protected override void OnParametersSet()
    {
        Path = Path?.Trim('/');
        View = Service.GetPath(Repository, Reference, Path);

        if (View is null)
        {
            // Nothing resolved, which is two different things. A repository that has refs was
            // reached by a bad revision; one with none is a repository nobody has pushed to, and
            // its tree tab should say so rather than answer 404.
            Empty = Service.GetRefs(Repository) is { Branches.Count: 0 };
            if (!Empty) NotFound();
        }
        else if (View.Entries is null && View.Blob is null)
        {
            NotFound();
        }

        Code = View?.Blob is { Text: { } text } blob
            ? SyntaxHighlighter.Highlight(text, SyntaxHighlighter.GrammarFor(blob.Path))
            : [];

        Crumbs = BuildCrumbs();
    }

    /// <summary>
    /// One step per path segment, the last of them the page you are on. The bar already holds the
    /// repository, so this starts inside it.
    /// </summary>
    private IReadOnlyList<GitBar.Crumb> BuildCrumbs()
    {
        if (Path is not { Length: > 0 } path) return [];

        var segments = path.Split('/');
        var crumbs = new List<GitBar.Crumb>(segments.Length);
        var walked = "";

        foreach (var segment in segments)
        {
            walked = walked.Length == 0 ? segment : $"{walked}/{segment}";
            crumbs.Add(new GitBar.Crumb(segment, walked == path ? null : TreeLink(walked, At)));
        }

        return crumbs;
    }

    private static string Counted(IReadOnlyList<GitTreeEntry> entries) => Counted(entries.Count, "entry", "entries");

    private static string Counted(int n, string one, string? many = null) =>
        n == 1 ? $"1 {one}" : $"{n} {many ?? one + "s"}";
}