namespace Blog.Models;

/// <summary>
/// A name, an address and a time — git's author and committer lines, flattened out of libgit2's
/// handles so a page can still read them after the repository has been closed.
/// </summary>
public sealed record GitSignature(string Name, string Email, DateTimeOffset When);

/// <summary>One repository under the repository root, as the index lists it.</summary>
/// <param name="Name">The directory name, which is also the route segment: <c>blog.git</c>.</param>
/// <param name="DisplayName">The same without the suffix, for headings: <c>blog</c>.</param>
/// <param name="Description">
/// The <c>description</c> file, unless it still holds the placeholder <c>git init</c> writes.
/// </param>
/// <param name="Owner"><c>gitweb.owner</c> from the repository config, which is what cgit reads.</param>
/// <param name="Head">The branch HEAD points at, or null when it is unborn.</param>
/// <param name="Tip">The commit on that branch, and when it landed.</param>
public sealed record GitRepoSummary(
    string Name,
    string DisplayName,
    string? Description,
    string? Owner,
    string? Head,
    GitCommitInfo? Tip);

/// <summary>A commit, with everything a page shows about it.</summary>
/// <param name="Refs">
/// The branch and tag names whose tips are this commit. Filled in on the log, where the badges
/// mark where each branch has got to; empty everywhere else.
/// </param>
public sealed record GitCommitInfo(
    string Sha,
    string Summary,
    string Body,
    GitSignature Author,
    GitSignature Committer,
    IReadOnlyList<string> Parents,
    IReadOnlyList<string> Refs)
{
    /// <summary>Enough of the hash to be unambiguous, and short enough to sit in a table.</summary>
    public string ShortSha => Sha.Length >= 10 ? Sha[..10] : Sha;

    /// <summary>A commit with two or more parents is diffed against the first, as git does.</summary>
    public bool IsMerge => Parents.Count > 1;
}

/// <summary>A page of history, and whether there is another one behind it.</summary>
public sealed record GitLogPage(IReadOnlyList<GitCommitInfo> Commits, bool HasMore);

/// <summary>What a tree entry is, as far as the listing cares.</summary>
public enum GitEntryKind
{
    Directory,
    File,

    /// <summary>Mode 100755. Worth marking: it is the difference between a script and a text file.</summary>
    Executable,

    Symlink,

    /// <summary>Another repository, pinned at a commit. There is nothing here to browse into.</summary>
    Submodule
}

/// <param name="Path">Full path from the repository root, which is what the tree links carry.</param>
public sealed record GitTreeEntry(string Name, string Path, GitEntryKind Kind, long Size, string Sha);

/// <param name="IsBinary">
/// Decided the way git decides it: a NUL byte anywhere in the first few kilobytes. Binary blobs
/// are linked to the raw endpoint instead of being printed.
/// </param>
/// <param name="Text">
/// The file, newlines normalised to <c>\n</c> and the final one removed, or null when there is
/// nothing to print. Whole rather than split into lines: the highlighter needs the whole of it to
/// see that a block comment or a fenced code block carries on past the end of a line.
/// </param>
public sealed record GitBlob(
    string Path,
    string Sha,
    long Size,
    bool IsBinary,
    bool TooLarge,
    string? Text);

/// <summary>
/// One path in one revision: a directory listing, or a file. Which of the two is set says which
/// the path turned out to be.
/// </summary>
/// <param name="Reference">The revision as it was asked for, for links that stay on this branch.</param>
public sealed record GitPathView(
    GitCommitInfo Commit,
    string Reference,
    string Path,
    IReadOnlyList<GitTreeEntry>? Entries,
    GitBlob? Blob);

public enum GitChange
{
    Added,
    Deleted,
    Modified,
    Renamed,
    Copied,
    TypeChanged
}

/// <param name="Origin">
/// <c>' '</c> context, <c>'+'</c> added, <c>'-'</c> removed, <c>'\'</c> for git's
/// "No newline at end of file" note.
/// </param>
public sealed record GitDiffLine(char Origin, int? OldNumber, int? NewNumber, string Text);

/// <param name="Header">The <c>@@ -a,b +c,d @@</c> line, section heading and all.</param>
public sealed record GitDiffHunk(string Header, IReadOnlyList<GitDiffLine> Lines);

/// <param name="Hunks">Empty for a binary file, and for one dropped to keep the page finite.</param>
public sealed record GitDiffFile(
    string Path,
    string? OldPath,
    GitChange Change,
    int Added,
    int Deleted,
    bool IsBinary,
    bool Skipped,
    IReadOnlyList<GitDiffHunk> Hunks);

/// <param name="Truncated">
/// Set when the diff ran past the line budget and the rest of the files kept their stats but lost
/// their hunks. A commit that vendors a 4 MB file should not render 4 MB of green.
/// </param>
public sealed record GitDiff(IReadOnlyList<GitDiffFile> Files, int Added, int Deleted, bool Truncated);

/// <summary>
/// One file's bytes at one revision, for the raw endpoint. <paramref name="IsBinary"/> decides
/// whether it is handed over as text or as a download.
/// </summary>
public sealed record GitRawBlob(byte[] Bytes, bool IsBinary, string Name);

/// <summary>A commit and the diff that goes with it — everything the commit page renders.</summary>
public sealed record GitCommitView(GitCommitInfo Commit, GitDiff Diff);

/// <summary>A branch or a tag, with the commit it points at.</summary>
/// <param name="Message">An annotated tag's own message. Null for branches and lightweight tags.</param>
public sealed record GitRef(
    string Name,
    bool IsTag,
    string Sha,
    GitCommitInfo? Tip,
    string? Message);

/// <summary>Every ref in a repository, branches and tags kept apart as the refs page shows them.</summary>
public sealed record GitRefsView(IReadOnlyList<GitRef> Branches, IReadOnlyList<GitRef> Tags);