public StreakDto GetStreak()
        {
            var result = new StreakDto();

            try
            {
                var lastEpisode = _fallGuysContext.Episodes
                                  .OrderBy(e => e.Created)
                                  .LastOrDefault();
                if (lastEpisode == null)
                {
                    result.Winning = true;
                    result.Streak  = 0;
                }
                else if (lastEpisode.Crowns > 0)
                {
                    result.Winning = true;
                    var maxLossCreated = _fallGuysContext.Episodes
                                         .Where(e => e.Crowns == 0)
                                         .GroupBy(e => e.Crowns)
                                         .Select(s => s.Max(e => e.Created))
                                         .FirstOrDefault();

                    result.Streak = _fallGuysContext.Episodes
                                    .Where(e => e.Created > maxLossCreated)
                                    .GroupBy(e => e.Crowns)
                                    .Select(s => s.Count())
                                    .FirstOrDefault();
                }
                else
                {
                    result.Winning = false;
                    var maxWinCreated = _fallGuysContext.Episodes
                                        .Where(e => e.Crowns == 1)
                                        .GroupBy(e => e.Crowns)
                                        .Select(s => s.Max(e => e.Created))
                                        .FirstOrDefault();

                    result.Streak = _fallGuysContext.Episodes
                                    .Where(e => e.Created > maxWinCreated)
                                    .GroupBy(e => e.Crowns)
                                    .Select(s => s.Count())
                                    .FirstOrDefault();
                }
            }
            catch (Exception e)
            {
                _logger.LogError($"Unable to get streak {e.Message}");
            }

            return(result);
        }
        public async Task <List <StreakDto> > GetStreaks() // TODO - TH - Refactor this so it gets players and includes the other info
        {
            var gamePlayers = _appDbContext.GamePlayers
                              .Include(gp => gp.Game)
                              .Include(gp => gp.Player)
                              .Where(gp => !gp.Player.IsArchived);

            var playerDateWinList = await gamePlayers
                                    .Select(o => new
            {
                Player = o.PlayerId,
                o.GameId,
                Win = o.WasResistance == o.Game.ResistanceWin,
            })
                                    .ToListAsync();

            var playersWinHistories = playerDateWinList
                                      .GroupBy(
                o => o.Player,
                o => new WinHistoryItem {
                Win = o.Win, GameId = o.GameId
            });

            var streakDtos = new List <StreakDto>();

            foreach (var playerWinHistory in playersWinHistories)
            {
                var playerId = playerWinHistory.Key;

                var winHistory    = playerWinHistory.ToList();
                var streakHistory = TransformWinHistoryToStreakHistory(winHistory);

                var winStreaks    = streakHistory.Where(s => s.IsAWinStreak).Select(s => s.Streak);
                var lossStreaks   = streakHistory.Where(s => !s.IsAWinStreak).Select(s => s.Streak);
                var currentStreak = streakHistory.Last();

                var streakDto = new StreakDto
                {
                    PlayerId         = playerId,
                    MaxWins          = winStreaks.Max(),
                    MaxLosses        = lossStreaks.Max(),
                    Current          = currentStreak.Streak,
                    CurrentWinOrLoss = currentStreak.IsAWinStreak,
                };

                streakDtos.Add(streakDto);
            }
            return(streakDtos
                   .OrderByDescending(p => (p.CurrentWinOrLoss ? +1 : -1) * p.Current)
                   .ToList());
        }