namespace Blog.Models;

/// <summary>Which of Digital Extremes' tables a source came out of.</summary>
public enum DropCategory
{
    /// <summary>A node on the star chart: <c>Mercury/Apollodorus (Survival)</c>.</summary>
    Mission,

    /// <summary>A quest or key mission, run from the codex rather than the star chart.</summary>
    Key,

    /// <summary>Arbitrations, Kuva Siphons, Void Storms: activities without a fixed node.</summary>
    Dynamic,

    /// <summary>The daily sortie.</summary>
    Sortie,

    /// <summary>An open-world bounty stage.</summary>
    Bounty,

    /// <summary>Something you kill, or open: an enemy, a container, a crewship.</summary>
    Enemy
}

/// <summary>One place an item drops, and how likely it is there.</summary>
/// <param name="Category">The kind of activity this is.</param>
/// <param name="Location">The node, bounty, activity or enemy.</param>
/// <param name="Context">Which rotation or stage of it, when the location has more than one.</param>
/// <param name="Rarity">DE's own word for the chance: <c>Rare</c>, <c>Uncommon</c>, and so on.</param>
/// <param name="Chance">
/// Percent per roll. For enemies, the source's drop chance multiplied by the item's share of that
/// drop: a 100% share of a 3% table is a 3% kill.
/// </param>
public sealed record DropSource(
    DropCategory Category,
    string Location,
    string? Context,
    string Rarity,
    double Chance);

/// <summary>
/// One line of a relic's reward table. Only Intact and Radiant are kept; Exceptional and Flawless
/// sit between them.
/// </summary>
public sealed record RelicLine(string Relic, string Item, string Rarity, double Intact, double Radiant);

/// <summary>Everything the drop tables say about one item.</summary>
public sealed class ItemDrops
{
    public required string Name { get; init; }

    /// <summary>Where it drops directly, best chance first.</summary>
    public required IReadOnlyList<DropSource> Sources { get; init; }

    /// <summary>The relics that can contain it, best intact chance first. Empty for most items.</summary>
    public required IReadOnlyList<RelicLine> InRelics { get; init; }

    /// <summary>What this item contains, when it is itself a relic. Empty otherwise.</summary>
    public required IReadOnlyList<RelicLine> Contents { get; init; }

    public bool FromRelics => InRelics.Count > 0;

    public bool IsRelic => Contents.Count > 0;
}

/// <summary>A parsed copy of the drop tables, indexed for lookup by item name.</summary>
public sealed class DropTables
{
    public required string LastUpdate { get; init; }

    public required DateTimeOffset FetchedAt { get; init; }

    /// <summary>Every item, by name, case-insensitively.</summary>
    public required IReadOnlyDictionary<string, ItemDrops> Items { get; init; }

    /// <summary>Every item name, sorted.</summary>
    public required IReadOnlyList<string> Names { get; init; }

    public ItemDrops? Find(string? name) =>
        name is not null && Items.TryGetValue(name, out var item) ? item : null;

    /// <summary>Where an item drops. Empty for a vaulted relic.</summary>
    public IReadOnlyList<DropSource> SourcesFor(string itemName) => Find(itemName)?.Sources ?? [];

    /// <summary>
    /// Item names matching <paramref name="query"/>, most relevant first: exact name, then prefix,
    /// then substring, then names containing every word of it. The last rule matches
    /// "nikana blueprint" to "Nikana Prime Blueprint".
    /// </summary>
    public IReadOnlyList<string> Search(string query, int limit)
    {
        query = query.Trim();
        if (query.Length == 0) return [];

        var words = query.Split(' ', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);

        return Names
            .Select(name => (name, rank: Rank(name, query, words)))
            .Where(match => match.rank < int.MaxValue)
            .OrderBy(match => match.rank)
            .ThenBy(match => match.name.Length)
            .ThenBy(match => match.name, StringComparer.OrdinalIgnoreCase)
            .Take(limit)
            .Select(match => match.name)
            .ToArray();
    }

    private static int Rank(string name, string query, string[] words)
    {
        if (name.Equals(query, StringComparison.OrdinalIgnoreCase)) return 0;
        if (name.StartsWith(query, StringComparison.OrdinalIgnoreCase)) return 1;
        if (name.Contains(query, StringComparison.OrdinalIgnoreCase)) return 2;

        foreach (var word in words)
        {
            if (!name.Contains(word, StringComparison.OrdinalIgnoreCase)) return int.MaxValue;
        }

        return 3;
    }
}

/// <summary>The drop tables, or the reason there aren't any.</summary>
public sealed record DropTableStatus(DropTables? Tables, string? Error)
{
    public static DropTableStatus Ready(DropTables tables) => new(tables, null);

    public static DropTableStatus Failed(string error, DropTables? stale = null) => new(stale, error);
}