using System.Collections.Generic;

namespace LaDOSE.Entity
{
    /// <summary>
    /// Aggregate over the persisted <see cref="Set"/> rows of one or more Events.
    /// Not an entity: it is never mapped by EF, it is computed in memory by
    /// StatisticsService and mapped to MatchStatsDTO by AutoMapper (same pattern as
    /// <see cref="Challonge.TournamentsResult"/>).
    /// Property names must stay identical to the DTO's, the mapping is by convention.
    /// </summary>
    public class MatchStats
    {
        /// <summary>How much of the requested scope actually has set data behind it.</summary>
        public MatchCoverage Coverage { get; set; } = new MatchCoverage();

        public List<PlayerMatchStats> Players { get; set; } = new List<PlayerMatchStats>();

        public List<HeadToHead> HeadToHead { get; set; } = new List<HeadToHead>();
    }

    /// <summary>
    /// Set coverage is sparse: Challonge-imported events have no sets at all, and events
    /// imported before SmashProvider.GetSets existed were never backfilled. These counters
    /// let a caller say "12 of 40 brackets have match data" instead of implying completeness.
    /// </summary>
    public class MatchCoverage
    {
        /// <summary>Requested event ids that actually exist.</summary>
        public int Events { get; set; }

        /// <summary>Tournaments (brackets) belonging to those events.</summary>
        public int Brackets { get; set; }

        /// <summary>Of those brackets, how many have at least one set row.</summary>
        public int BracketsWithSets { get; set; }

        /// <summary>Total set rows in scope, including the ones skipped as unusable.</summary>
        public int Sets { get; set; }

        /// <summary>Sets with a determinable winner (unequal scores, two distinct real players).</summary>
        public int DecidedSets { get; set; }
    }

    public class PlayerMatchStats
    {
        public int PlayerId { get; set; }

        /// <summary>Gamertag, falling back to Name, else "#&lt;id&gt;".</summary>
        public string Player { get; set; }

        /// <summary>Decided sets only. Always equals Wins + Losses.</summary>
        public int Sets { get; set; }

        public int Wins { get; set; }
        public int Losses { get; set; }
        public int GamesWon { get; set; }
        public int GamesLost { get; set; }
    }

    /// <summary>
    /// One row per unordered pair of players with at least one decided set.
    /// A is always the lower PlayerId so WinsA / WinsB are unambiguous.
    /// </summary>
    public class HeadToHead
    {
        public int PlayerAId { get; set; }
        public string PlayerA { get; set; }
        public int PlayerBId { get; set; }
        public string PlayerB { get; set; }
        public int WinsA { get; set; }
        public int WinsB { get; set; }
    }
}