AnalyticsModuleDistancesBetweenStarts.cs

using Vereinsmeisterschaften.Core.Contracts.Services;
using Vereinsmeisterschaften.Core.Documents;
using Vereinsmeisterschaften.Core.Helpers;
using Vereinsmeisterschaften.Core.Models;
 
namespace Vereinsmeisterschaften.Core.Analytics
{
    public class AnalyticsModuleDistancesBetweenStarts : IAnalyticsModule
    {
        private IRaceService _raceService;

        public AnalyticsModuleDistancesBetweenStarts(IRaceService raceService)
        {
            _raceService = raceService;
        }

        public bool AnalyticsAvailable => _raceService?.PersistedRacesVariant != null;

        public Dictionary<Person, List<int>> DistancesBetweenStartsPerPerson
        {
            get
            {
                Dictionary<Person, List<int>> distancesBetweenStartsPerPerson = new Dictionary<Person, List<int>>();
                if (!AnalyticsAvailable) { return distancesBetweenStartsPerPerson; }
 
                RacesVariant racesVariant = _raceService.PersistedRacesVariant;
 
                Dictionary<Person, int> lastRaceIndex = new Dictionary<Person, int>();
                for (int i = 0; i < racesVariant.Races.Count; i++)
                {
                    foreach (PersonStart personStart in racesVariant.Races[i].Starts)
                    {
                        // Only consider active starts
                        if (!personStart.IsActive) { continue; }
 
                        Person person = personStart.PersonObj;
 
                        if (lastRaceIndex.TryGetValue(person, out int lastIndex))
                        {
                            int distance = i - lastIndex;
                            if (!distancesBetweenStartsPerPerson.ContainsKey(person) || distancesBetweenStartsPerPerson[person] == null)
                            {
                                distancesBetweenStartsPerPerson[person] = new List<int>();
                            }
                            distancesBetweenStartsPerPerson[person].Add(distance);
                        }
 
                        lastRaceIndex[person] = i;
                    }
                }
                return distancesBetweenStartsPerPerson.OrderBy(d => d.Value.Min()).ToDictionary(d => d.Key, d => d.Value);
            }
        }

        public DocXPlaceholderHelper.TextPlaceholders CollectDocumentPlaceholderContents()
        {
            DocXPlaceholderHelper.TextPlaceholders textPlaceholder = new DocXPlaceholderHelper.TextPlaceholders();
            Dictionary<Person, List<int>> distancesBetweenStartsPerPerson = DistancesBetweenStartsPerPerson;
 
            // Get the joined name strings for each person and determine the maximum length of these strings (will be used for padding)
            Dictionary<Person, string> nameStringsDict = distancesBetweenStartsPerPerson.ToDictionary(kv => kv.Key, kv => $"{kv.Key.FirstName}, {kv.Key.Name}");
            int maxNameStrLen = nameStringsDict.Max(kv => kv.Value?.Length) ?? 30;
 
            // Get the joined value strings for each person and determine the maximum length of these strings (will be used for padding)
            Dictionary<Person, string> valueStringsDict = distancesBetweenStartsPerPerson.ToDictionary(kv => kv.Key, kv => string.Join(", ", kv.Value));
            int maxValueStrLen = valueStringsDict.Max(kv => kv.Value?.Length) ?? 20;
 
            // Create a string for each dictionary entry including a ASCII diagramm (Format e.g.: Firstname, Name: 3, 4, 2 | ###|####|## )
            string moduleString = string.Join(Environment.NewLine,
                                              distancesBetweenStartsPerPerson
                                                .Select(kv => $"{nameStringsDict[kv.Key]}: ".PadRight(maxNameStrLen + 2) +
                                                              $"{valueStringsDict[kv.Key].PadRight(maxValueStrLen)} | " +
                                                              $"{string.Join("|", kv.Value.Select(v => new string('#', v)))}"));
            foreach (string placeholder in Placeholders.Placeholders_AnalyticsDistancesBetweenStarts) { textPlaceholder.Add(placeholder, moduleString); }
            return textPlaceholder;
        }

        public List<string> SupportedDocumentPlaceholderKeys => new List<string>()
        {
            Placeholders.PLACEHOLDER_KEY_ANALYTICS_DISTANCES_BETWEEN_STARTS
        };
    }
}