public List <Embed> BuildDetailedAthleteEmbeds(LeaderboardParticipant participant,
                                                       AthleteDetailed athlete)
        {
            var results = new List <Embed>();

            var embedBuilder = new EmbedBuilder()
                               .WithCurrentTimestamp();

            if (participant == null)
            {
                results.Add(embedBuilder
                            .WithTitle("Participant Not Found")
                            .Build());
                return(results);
            }

            embedBuilder.WithTitle($"Detailed Info - {participant.DiscordUserId}");
            var embedFieldsAdded = 0;

            foreach (var propertyInfo in athlete.GetType().GetProperties())
            {
                if (string.IsNullOrEmpty(propertyInfo.Name))
                {
                    continue;
                }

                var value = propertyInfo.GetValue(athlete)?.ToString();
                if (string.IsNullOrEmpty(value))
                {
                    continue;
                }

                embedBuilder
                .AddField(efb => efb.WithName(propertyInfo.Name ?? "N/A")
                          .WithValue(value)
                          .WithIsInline(true));
                embedFieldsAdded++;
            }

            if (embedFieldsAdded >= 25)
            {
                results.Add(embedBuilder.Build());
                embedBuilder = new EmbedBuilder().WithCurrentTimestamp()
                               .WithTitle($"Detailed Info - {participant.DiscordUserId} - CONTINUED");
            }

            if (embedBuilder.Fields.Count > 0)
            {
                results.Add(embedBuilder.Build());
            }

            return(results);
        }
        public Embed BuildAthleteInfoEmbed(LeaderboardParticipant participant, AthleteDetailed athlete)
        {
            var embedBuilder = new EmbedBuilder()
                               .WithCurrentTimestamp()
                               .AddField("Discord User Id", participant.DiscordUserId, true)
                               .AddField("Strava First Name", athlete?.Firstname ?? "Unknown", true)
                               .AddField("Strava Athlete Id", participant.StravaId, true)
                               .AddField("Strava Body Weight",
                                         (athlete.Weight ?? 0) == 0
                        ? "Not Specified"
                        : athlete.Weight.ToString(), true)
                               .AddField("Strava FTP", athlete?.Ftp?.ToString() ?? "Not Specified", true);

            return(embedBuilder.Build());
        }
        public async Task ListLeaderboardParticipants()
        {
            using (Context.Channel.EnterTypingState())
            {
                try
                {
                    _logger.LogInformation("Executing list");
                    var embeds       = new List <Embed>();
                    var participants = await _participantService.GetAllParticipantsForServerAsync(Context.Guild.Id.ToString());

                    foreach (var participant in participants)
                    {
                        AthleteDetailed updatedAthleteData = null;
                        try
                        {
                            updatedAthleteData = await _stravaService.GetAthlete(participant);
                        }
                        catch (Exception e)
                        {
                            _logger.LogError(e, $"Failed to fetch athlete while executing list command");
                        }

                        embeds.Add(_embedBuilderService.BuildAthleteInfoEmbed(participant, updatedAthleteData));
                    }

                    if (!embeds.Any())
                    {
                        embeds.Add(
                            new EmbedBuilder()
                            .WithTitle("No participants found")
                            .WithCurrentTimestamp()
                            .Build()
                            );
                    }

                    foreach (var embed in embeds)
                    {
                        await ReplyAsync(embed : embed);
                    }
                }
                catch (Exception e)
                {
                    _logger.LogError(e, "list failed");
                }
            }
        }