RacesVariantsGenerator.cs

using System.Collections.Concurrent;
using Vereinsmeisterschaften.Core.Contracts.Services;
using Vereinsmeisterschaften.Core.Models;
 
namespace Vereinsmeisterschaften.Core.Services
{
    public class RacesVariantsGenerator
    {
        private readonly Random _random = new();
        private readonly double _minScoreThreshold;
        private readonly int _maxGroupSize;
        private readonly double _maxOneElementGroupPercentage;
        private readonly IProgress<double> _progressIteration;
        private readonly IProgress<double> _progressSolution;
        private readonly int _requiredVariantsCount;
        private readonly int _maxIterations;

        public RacesVariantsGenerator(IProgress<double> progressIteration = null, IProgress<double> progressSolution = null, int requiredVariantsCount = 100, int maxIterations = 100000, double minScoreThreshold = 90, int maxGroupSize = 3, double maxOneElementGroupPercentage = 0.15)
        {
            _progressIteration = progressIteration;
            _progressSolution = progressSolution;
            _maxGroupSize = maxGroupSize;
            _minScoreThreshold = minScoreThreshold;
            _maxOneElementGroupPercentage = maxOneElementGroupPercentage;
            _requiredVariantsCount = requiredVariantsCount;
            _maxIterations = maxIterations;
        }

        public async Task<List<RacesVariant>> GenerateBestRacesAsync(List<List<PersonStart>> sets, IWorkspaceService workspaceService = null, CancellationToken cancellationToken = default)
        {
            ConcurrentBag<RacesVariant> bestRaces = new ConcurrentBag<RacesVariant>();
            int attempts = 0;
            int foundVariants = 0;
 
            await Task.Run(() =>
            {
                Parallel.For(0, _maxIterations, new ParallelOptions() { MaxDegreeOfParallelism = (int)(0.25 * Environment.ProcessorCount) }, (i, state) =>
                {
                    if (cancellationToken.IsCancellationRequested || bestRaces.Count >= _requiredVariantsCount)
                    {
                        state.Stop();
                        return;
                    }
 
                    // Random grouping creation
                    RacesVariant candidate = CreateValidGrouping(sets, workspaceService);
 
                    // Calculate score and keep if above threshold
                    double score = candidate.CalculateScore();
                    if (score >= _minScoreThreshold)
                    {
                        bestRaces.Add(candidate);
                        Interlocked.Increment(ref foundVariants);
                    }
 
                    Interlocked.Increment(ref attempts);
 
                    // Calculate progress as a mixture of iteration progress and solution progress
                    double iterationProgress = (double)attempts / _maxIterations;
                    double solutionProgress = (double)foundVariants / _requiredVariantsCount;
                    //double overallProgress = Math.Min(1.0, Math.Max(iterationProgress, solutionProgress));
 
                    _progressIteration?.Report(iterationProgress * 100);
                    _progressSolution?.Report(solutionProgress * 100);
                });
            }, cancellationToken);
 
            return bestRaces.OrderByDescending(r => r.Score).Take(_requiredVariantsCount).ToList();
        }

        private RacesVariant CreateValidGrouping(List<List<PersonStart>> sets, IWorkspaceService workspaceService = null)
        {
            List<List<PersonStart>> groups = new List<List<PersonStart>>();
            List<List<PersonStart>> shuffledSets = sets.OrderBy(_ => _random.Next()).ToList(); // Shuffle sets for more randomness
            int oneElementGroupsCount = 0;
 
            foreach (List<PersonStart> set in shuffledSets)
            {
                HashSet<PersonStart> remainingElements = new HashSet<PersonStart>(set.OrderBy(_ => _random.Next())); // Shuffle each set
 
                while (remainingElements.Count > 0)
                {
                    int maxSize = Math.Min(_maxGroupSize, remainingElements.Count);
                    int minSize = Math.Max(2, (int)(maxSize * 0.5)); // Avoid too small groups
 
                    int groupSize = _random.Next(minSize, maxSize + 1);
                    List<PersonStart> selectedGroup = remainingElements.Take(groupSize).ToList();
 
                    if (selectedGroup.Count == 1)
                    {
                        oneElementGroupsCount++;
                    }
 
                    groups.Add(selectedGroup);
                    foreach (PersonStart item in selectedGroup)
                        remainingElements.Remove(item);
                }
            }
 
            // If too many single element groups were created → Adjust instead of restart
            if ((double)oneElementGroupsCount / groups.Count > _maxOneElementGroupPercentage)
            {
                groups = MergeSmallGroups(groups, sets);
            }
 
            RacesVariant variant = new RacesVariant(workspaceService);
            foreach (var group in groups)
            {
                variant.Races.Add(new Race(group));
            }
 
            return variant;
        }

        private List<List<PersonStart>> MergeSmallGroups(List<List<PersonStart>> groups, List<List<PersonStart>> sets)
        {
            List<List<PersonStart>> result = new();
            HashSet<int> mergedIndices = new();
 
            for (int i = 0; i < groups.Count; i++)
            {
                if (mergedIndices.Contains(i))
                    continue;
 
                var groupA = groups[i];
 
                // Nur kleine Gruppen betrachten
                if (groupA.Count >= 1)
                {
                    result.Add(groupA);
                    continue;
                }
 
                bool merged = false;
 
                for (int j = i + 1; j < groups.Count; j++)
                {
                    if (mergedIndices.Contains(j))
                        continue;
 
                    var groupB = groups[j];
 
                    if (groupA.Count + groupB.Count <= _maxGroupSize &&
                        AreFromSameSet(groupA.Concat(groupB).ToList(), sets))
                    {
                        result.Add(groupA.Concat(groupB).ToList());
                        mergedIndices.Add(i);
                        mergedIndices.Add(j);
                        merged = true;
                        break;
                    }
                }
 
                if (!merged)
                {
                    result.Add(groupA);
                }
            }
 
            return result;
        }
 
        private bool AreFromSameSet(List<PersonStart> starts, List<List<PersonStart>> sets)
        {
            foreach (var set in sets)
            {
                if (starts.All(p => set.Contains(p)))
                    return true;
            }
            return false;
        }
    }
}