using System.ComponentModel;

namespace Blog.Models;

/// <summary>
/// What <c>Rvrb.Stats.snapshot/0</c> answers with: the rvrb bot's room as it is right now, and
/// what it has played since the plays table started filling up. Decoded from the Erlang term in
/// <see cref="Services.RvrbSnapshotReader"/>.
/// </summary>
public sealed record RvrbSnapshot(
    DateTimeOffset GeneratedAt,
    RvrbLive? Live,
    RvrbTotals Totals,
    IReadOnlyList<RvrbDay> PlaysPerDay,
    IReadOnlyList<RvrbDj> TopDjs,
    IReadOnlyList<RvrbTrack> TopTracks,
    IReadOnlyList<RvrbArtist> TopArtists,
    IReadOnlyList<RvrbPlay> RecentPlays);

/// <summary>
/// The room as the bot's websocket currently sees it. Null in a snapshot means the bot is not
/// connected to RVRB — the historic half is still there, since it only needs the database.
/// </summary>
public sealed record RvrbLive(
    string? ChannelId,
    RvrbCurrentTrack? CurrentTrack,
    int Dopes,
    int Stars,
    bool AutoDoped,
    bool AutoStarred,
    int QueuedTracks,
    int KnownBots,
    IReadOnlyList<RvrbDjSlot> Djs,
    TimeSpan Lap);

/// <summary>The track playing right now.</summary>
public sealed record RvrbCurrentTrack(
    string? SpotifyTrackId,
    string? Name,
    IReadOnlyList<string> ArtistNames,
    TimeSpan? Duration,
    string? AlbumArt,
    TimeSpan? Elapsed,
    TimeSpan? Remaining)
{
    /// <summary>
    /// How far through the track we are, 0 to 1, or null when either half of that is unknown —
    /// a track that arrived without a duration, or one already playing when the bot connected.
    /// </summary>
    public double? Progress => Duration is { TotalMilliseconds: > 0 } total && Elapsed is { } elapsed
        ? Math.Clamp(elapsed.TotalMilliseconds / total.TotalMilliseconds, 0, 1)
        : null;
}

/// <summary>One slot in the DJ queue, with the wait until that DJ next plays.</summary>
public sealed record RvrbDjSlot(
    string RvrbId,
    string? Name,
    TimeSpan AverageTrack,
    int PlayCount,
    bool Measured,
    bool Current,
    TimeSpan Wait);

/// <summary>Room-wide counts.</summary>
public sealed record RvrbTotals(
    long Plays,
    long Votes,
    long Dopes,
    long Stars,
    long Users,
    long Djs,
    long Tracks,
    long Artists,
    DateTimeOffset? FirstPlayAt,
    DateTimeOffset? LastPlayAt);

/// <summary>Plays on one day. Days nothing was played on are present, with a count of zero.</summary>
public sealed record RvrbDay(DateOnly Date, int Plays);

/// <summary>A DJ on the leaderboard, and what their plays earned.</summary>
public sealed record RvrbDj(string Name, string? UserName, int Plays, int Dopes, int Stars, int Score);

/// <summary>A track on the leaderboard.</summary>
public sealed record RvrbTrack(
    string TrackName,
    IReadOnlyList<string> ArtistNames,
    int Plays,
    int Dopes,
    int Stars,
    int Score);

/// <summary>An artist on the leaderboard.</summary>
public sealed record RvrbArtist(string ArtistName, int Plays, int Dopes, int Stars, int Score);

/// <summary>One played track in the recent history.</summary>
public sealed record RvrbPlay(
    DateTimeOffset PlayedAt,
    string? Dj,
    string TrackName,
    IReadOnlyList<string> ArtistNames,
    TimeSpan? Duration,
    int Dopes,
    int Stars,
    int Score);

/// <summary>
/// The result of asking the bot for a snapshot: either one, or why there isn't one. A bot that is
/// down is the normal thing a status page is there to report, so it is a value here rather than an
/// exception the page has to catch.
/// </summary>
// Nothing here is ever mutated after it is built, and saying so is what lets HybridCache hand the
// same instance to every request instead of serializing a copy per reader.
[ImmutableObject(true)]
public sealed record RvrbStatus(DateTimeOffset FetchedAt, RvrbSnapshot? Snapshot, string? Error)
{
    public static RvrbStatus Reachable(RvrbSnapshot snapshot) =>
        new(DateTimeOffset.UtcNow, snapshot, null);

    public static RvrbStatus Unreachable(string error) => new(DateTimeOffset.UtcNow, null, error);
}