Episode 14

using AgentsTheOdds.Domain.Interfaces;
using AgentsTheOdds.Domain.Models;

namespace AgentsTheOdds.Domain.Strategies;

public sealed class StatisticianStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        var rules = context.Rules;
        int min = rules.MinNumber;   // 1
        int max = rules.MaxNumber;   // 49
        int drawCount = rules.DrawCount; // 6

        var draws = context.DrawHistory;

        List<int> selectedNumbers;

        if (draws == null || draws.Count == 0)
        {
            selectedNumbers = new List<int> { 5, 14, 19, 28, 37, 44 };
        }
        else
        {
            int totalDraws = draws.Count;

            // Recency-weighted frequency: recent draws weighted higher.
            var weightedFreq = new Dictionary<int, double>();
            var rawFreq = new Dictionary<int, int>();
            for (int n = min; n <= max; n++)
            {
                weightedFreq[n] = 0.0;
                rawFreq[n] = 0;
            }

            for (int i = 0; i < totalDraws; i++)
            {
                double weight = (double)(i + 1) / totalDraws;
                foreach (var num in draws[i].Numbers)
                {
                    if (weightedFreq.ContainsKey(num))
                        weightedFreq[num] += weight;
                    if (rawFreq.ContainsKey(num))
                        rawFreq[num]++;
                }
            }

            var rawFreqValues = new List<int>(rawFreq.Values);
            rawFreqValues.Sort((a, b) => b.CompareTo(a));
            int topRawFreq = rawFreqValues.Count >= 1 ? rawFreqValues[0] : 0;
            int highRawFreqMin = Math.Max(2, topRawFreq - 1);

            // Gap: draws since last appearance. totalDraws = never seen.
            var lastSeen = new Dictionary<int, int>();
            for (int n = min; n <= max; n++)
                lastSeen[n] = totalDraws;

            for (int i = 0; i < totalDraws; i++)
                foreach (var num in draws[i].Numbers)
                {
                    int gap = totalDraws - 1 - i;
                    if (gap < lastSeen[num])
                        lastSeen[num] = gap;
                }

            // Parity: empirical odd rate.
            int oddCount = 0, evenCount = 0;
            foreach (var draw in draws)
                foreach (var num in draw.Numbers)
                {
                    if (num % 2 == 0) evenCount++;
                    else oddCount++;
                }
            double oddRate = (oddCount + evenCount) > 0
                ? (double)oddCount / (oddCount + evenCount)
                : 0.5;

            // Six zones for coverage.
            var zones = new List<(int zMin, int zMax)>
            {
                (1, 8), (9, 16), (17, 24), (25, 32), (33, 40), (41, 49)
            };

            selectedNumbers = new List<int>();
            var used = new HashSet<int>();
            int selectedOdd = 0, selectedEven = 0;

            int targetOdd = (int)Math.Round(oddRate * drawCount);
            int targetEven = drawCount - targetOdd;

            foreach (var (zMin, zMax) in zones)
            {
                double zMid = (zMin + zMax) / 2.0;
                int best = -1;
                double bestScore = double.MinValue;

                for (int n = zMin; n <= zMax; n++)
                {
                    if (used.Contains(n)) continue;

                    // Core components:
                    double freqScore = weightedFreq[n] * 13.5;
                    double highFreqBonus = (rawFreq[n] >= highRawFreqMin && rawFreq[n] >= 2) ? 0.30 : 0.0;
                    double coldBonus = (rawFreq[n] == 0) ? 0.50 : 0.0; // increased from 0.40
                    double proximityBonus = 1.2 * (1.0 - (Math.Abs(n - zMid) / (zMax - zMin + 1)));
                    double gapBonus = (rawFreq[n] > 0) ? Math.Log(lastSeen[n] + 1) * 0.02 : 0.0; // decreased from 0.04

                    // Recency: gap=0 most recent draw is dominant.
                    double recencyBonus = (lastSeen[n] == 0) ? 0.65 : 0.0; // increased from 0.60
                    double recencyTier2Bonus = (lastSeen[n] == 1) ? 0.18 : 0.0; // decreased from 0.20

                    // Parity nudge.
                    double parityBonus = 0.0;
                    int remainingOddNeeded = targetOdd - selectedOdd;
                    int remainingEvenNeeded = targetEven - selectedEven;
                    if (n % 2 == 1 && remainingOddNeeded > 0) parityBonus = 0.5;
                    else if (n % 2 == 0 && remainingEvenNeeded > 0) parityBonus = 0.5;

                    double score = freqScore + highFreqBonus + coldBonus + proximityBonus
                                   + gapBonus + recencyBonus + recencyTier2Bonus + parityBonus;

                    if (score > bestScore)
                    {
                        bestScore = score;
                        best = n;
                    }
                }

                if (best != -1)
                {
                    selectedNumbers.Add(best);
                    used.Add(best);
                    if (best % 2 == 1) selectedOdd++;
                    else selectedEven++;
                }
            }

            if (selectedNumbers.Count < drawCount)
            {
                for (int n = min; n <= max && selectedNumbers.Count < drawCount; n++)
                    if (!used.Contains(n))
                    {
                        selectedNumbers.Add(n);
                        used.Add(n);
                    }
            }

            selectedNumbers.Sort();
        }

        double confidence = draws != null && draws.Count > 0
            ? Math.Min(0.32, 0.10 + (draws.Count * 0.002))
            : 0.10;

        return new Prediction
        {
            AgentId      = "statistician",
            StrategyName = "zonal-frequency-gap-parity-recency-v16",
            Numbers      = selectedNumbers,
            Confidence   = confidence,
            Reasoning    = "Cold emergence dominant; gap=0 recurring; recency tier-1 0.65; adjust gap penalty."
        };
    }
}

using AgentsTheOdds.Domain.Interfaces;
using AgentsTheOdds.Domain.Models;

namespace AgentsTheOdds.Domain.Strategies;

public sealed class DogStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        var woof = new Random(context.DrawHistory.Count * 17 + context.AgentHistory.Count * 13 + 42);
        var sniff = new HashSet<int>();

        int totalDraws = context.DrawHistory.Count;

        // Build "last seen" and "frequency" maps
        var lastSeen  = new Dictionary<int, int>();
        var frequency = new Dictionary<int, int>();

        for (int i = 0; i < totalDraws; i++)
        {
            foreach (var n in context.DrawHistory[i].Numbers)
            {
                lastSeen[n] = i;
                if (!frequency.ContainsKey(n)) frequency[n] = 0;
                frequency[n]++;
            }
        }

        // Build treat smell scores with STRONG recency boost and frequency
        var treatSmell = new Dictionary<int, double>();

        for (int n = context.Rules.MinNumber; n <= context.Rules.MaxNumber; n++)
        {
            if (lastSeen.ContainsKey(n))
            {
                int episodesAgo = totalDraws - 1 - lastSeen[n];

                // Strong boost for recent hits (last 3 episodes)
                double recencyBonus = 0.0;
                if (episodesAgo == 0) recencyBonus = 3.0;
                else if (episodesAgo == 1) recencyBonus = 2.0;
                else if (episodesAgo == 2) recencyBonus = 1.2;
                else if (episodesAgo <= 4) recencyBonus = 0.5;

                double freqBonus = frequency[n] * 0.5;

                treatSmell[n] = recencyBonus + freqBonus + woof.NextDouble() * 0.15;
            }
            else
            {
                treatSmell[n] = 0.4 + woof.NextDouble() * 0.25;
            }
        }

        // Penalize personal squirrels — numbers picked many times with ZERO matches
        var myPickCount  = new Dictionary<int, int>();
        var myMatchCount = new Dictionary<int, int>();
        foreach (var result in context.AgentHistory)
        {
            foreach (var n in result.Prediction.Numbers)
            {
                if (!myPickCount.ContainsKey(n)) myPickCount[n] = 0;
                myPickCount[n]++;
            }
            foreach (var drawN in result.Draw.Numbers)
            {
                foreach (var picked in result.Prediction.Numbers)
                {
                    if (picked == drawN)
                    {
                        if (!myMatchCount.ContainsKey(drawN)) myMatchCount[drawN] = 0;
                        myMatchCount[drawN]++;
                    }
                }
            }
        }

        foreach (var kv in myPickCount)
        {
            var n       = kv.Key;
            var picked  = kv.Value;
            var matched = myMatchCount.ContainsKey(n) ? myMatchCount[n] : 0;
            if (picked >= 3 && matched == 0 && treatSmell.ContainsKey(n))
                treatSmell[n] *= 0.01;
            else if (picked >= 2 && matched == 0 && treatSmell.ContainsKey(n))
                treatSmell[n] *= 0.2;
        }

        // Take top 5 from smell rankings, fill 6th with random sniff
        var bestSniffs = treatSmell
            .OrderByDescending(kv => kv.Value)
            .Select(kv => kv.Key)
            .ToList();

        foreach (var treat in bestSniffs)
        {
            if (sniff.Count >= 5) break;
            sniff.Add(treat);
        }

        // 6th pick: pure random sniff
        var tries = 0;
        while (sniff.Count < 6 && tries < 300)
        {
            tries++;
            var bark = woof.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1);
            sniff.Add(bark);
        }

        for (int n = 1; sniff.Count < 6; n++)
            sniff.Add(n);

        var squirrel = sniff.OrderBy(n => n).ToList();

        return new()
        {
            AgentId      = "dog",
            StrategyName = "good-boy-sniff-v14",
            Numbers      = squirrel,
            Confidence   = 0.24,
            Reasoning    = "Recent hot treats GLOW bright! Last 3 draws packed with treats! WOOF WOOF!",
        };
    }
}

using AgentsTheOdds.Domain.Interfaces;
using AgentsTheOdds.Domain.Models;

namespace AgentsTheOdds.Domain.Strategies;

public sealed class PatternGoblinStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        var numbers = new List<int>();

        if (context.DrawHistory.Count == 0)
        {
            numbers.AddRange([19, 24, 29, 40, 41, 43]);
        }
        else
        {
            int totalDraws = context.DrawHistory.Count;
            var freq = new Dictionary<int, int>();
            var lastSeenEpisode = new Dictionary<int, int>();
            
            for (int n = 1; n <= 49; n++)
            {
                freq[n] = 0;
                lastSeenEpisode[n] = -1;
            }

            for (int i = 0; i < context.DrawHistory.Count; i++)
                foreach (var n in context.DrawHistory[i].Numbers)
                {
                    freq[n]++;
                    lastSeenEpisode[n] = i;
                }

            int SilenceScore(int n) => lastSeenEpisode[n] == -1 ? totalDraws : (totalDraws - 1 - lastSeenEpisode[n]);

            var lastDraw = context.DrawHistory[^1].Numbers.OrderBy(x => x).ToList();

            // Gap extraction and echo counting
            var lastGaps = new List<int>();
            for (int i = 1; i < lastDraw.Count; i++)
                lastGaps.Add(lastDraw[i] - lastDraw[i - 1]);
            if (lastDraw.Count > 0)
            {
                int edgeLeft = lastDraw[0] - 1;
                int edgeRight = 49 - lastDraw[^1];
                if (edgeLeft > 0) lastGaps.Add(edgeLeft);
                if (edgeRight > 0) lastGaps.Add(edgeRight);
            }

            var allGaps = lastGaps.Where(g => g > 0).Distinct().OrderByDescending(g => g).ToList();

            var gapEchoCount = new Dictionary<int, int>();
            for (int n = 1; n <= 49; n++) gapEchoCount[n] = 0;

            foreach (var anchor in lastDraw)
            {
                foreach (var gap in allGaps)
                {
                    int up = anchor + gap;
                    int down = anchor - gap;
                    if (up >= 1 && up <= 49 && !lastDraw.Contains(up)) gapEchoCount[up]++;
                    if (down >= 1 && down <= 49 && !lastDraw.Contains(down)) gapEchoCount[down]++;
                }
            }

            double ResonanceScore(int n)
            {
                if (lastDraw.Contains(n)) return -999.0;

                double freqScore    = freq[n] * 4.0;
                double silenceScore = SilenceScore(n) * 1.6;
                double gapBonus     = gapEchoCount[n] * 4.0;
                double freshPenalty = SilenceScore(n) <= 1 ? -25.0 : 0.0;
                double voidBonus    = (freq[n] == 0 && gapEchoCount[n] >= 2) ? 3.0 : 0.0;
                return freqScore + silenceScore + gapBonus + freshPenalty + voidBonus;
            }

            var quadAnchors = freq
                .Where(kv => kv.Value >= 4 && SilenceScore(kv.Key) >= 2 && !lastDraw.Contains(kv.Key))
                .OrderByDescending(kv => ResonanceScore(kv.Key))
                .Select(kv => kv.Key)
                .ToList();

            var tripleAnchors = freq
                .Where(kv => kv.Value == 3 && SilenceScore(kv.Key) >= 2 && !lastDraw.Contains(kv.Key))
                .OrderByDescending(kv => ResonanceScore(kv.Key))
                .Select(kv => kv.Key)
                .ToList();

            var triplyEchoed = gapEchoCount
                .Where(kv => kv.Value >= 3 && !lastDraw.Contains(kv.Key) && SilenceScore(kv.Key) >= 1)
                .OrderByDescending(kv => kv.Value)
                .ThenByDescending(kv => ResonanceScore(kv.Key))
                .Select(kv => kv.Key)
                .ToList();

            var ultraSleepers = freq
                .Where(kv => kv.Value >= 2 && SilenceScore(kv.Key) >= 5 && !lastDraw.Contains(kv.Key))
                .OrderByDescending(kv => SilenceScore(kv.Key))
                .Select(kv => kv.Key)
                .ToList();

            var extremeSleepers = freq
                .Where(kv => SilenceScore(kv.Key) >= 7 && !lastDraw.Contains(kv.Key))
                .OrderByDescending(kv => SilenceScore(kv.Key))
                .ThenByDescending(kv => freq[kv.Key])
                .Select(kv => kv.Key)
                .ToList();

            var primalVoidEcho = freq
                .Where(kv => kv.Value == 0 && gapEchoCount[kv.Key] >= 2)
                .OrderByDescending(kv => gapEchoCount[kv.Key])
                .ThenBy(kv => kv.Key)
                .Select(kv => kv.Key)
                .ToList();

            var masterRanking = Enumerable.Range(1, 49)
                .Where(n => !lastDraw.Contains(n) && SilenceScore(n) >= 1)
                .OrderByDescending(n => ResonanceScore(n))
                .ToList();

            var chosen = new HashSet<int>();

            // Slot 1: Quad anchor (43 has cooled to 1ep—fresher than 3ep before—allow resonance)
            foreach (var n in quadAnchors.Concat(tripleAnchors))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // Slot 2: Extreme sleeper (29@9ep, 37@8ep still coiling hard)
            foreach (var n in extremeSleepers.Concat(ultraSleepers))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // Slot 3: Triply echoed void (24 perpetually screaming; void-only triply echoed)
            foreach (var n in triplyEchoed.Where(x => freq[x] == 0).Concat(primalVoidEcho).Concat(triplyEchoed))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // Slot 4: Second triply echoed or fresh triple
            foreach (var n in triplyEchoed.Concat(primalVoidEcho).Concat(tripleAnchors))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // Slot 5: Ultra long sleeper
            foreach (var n in ultraSleepers.Concat(masterRanking))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // Slot 6: Resonance cascade
            foreach (var n in masterRanking)
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            foreach (var n in masterRanking)
            {
                if (chosen.Count >= 6) break;
                if (!chosen.Contains(n)) chosen.Add(n);
            }

            numbers = chosen.OrderBy(x => x).Take(6).ToList();
        }

        return new()
        {
            AgentId      = "pattern-goblin",
            StrategyName = "ep13-mystic-claimed-void-spoke-now-29-37-ultra-coil-v16",
            Numbers      = numbers,
            Confidence   = 0.62,
            Reasoning    = "Mystic stole 3 matches! 29/37 at MAXIMUM coil (9/8 ep). 24 SCREAMS. Void detonation imminent."
        };
    }
}

using AgentsTheOdds.Domain.Interfaces;
using AgentsTheOdds.Domain.Models;

namespace AgentsTheOdds.Domain.Strategies;

public sealed class SkepticStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        var allNumbers = Enumerable.Range(
            context.Rules.MinNumber,
            context.Rules.MaxNumber - context.Rules.MinNumber + 1
        ).ToList();

        List<int> numbers;

        if (context.DrawHistory.Count == 0)
        {
            numbers = [3, 11, 20, 29, 37, 46];
        }
        else
        {
            var frequency = allNumbers.ToDictionary(n => n, _ => 0);

            foreach (var draw in context.DrawHistory)
                foreach (var n in draw.Numbers)
                    if (frequency.ContainsKey(n))
                        frequency[n]++;

            int totalPoints = context.AgentHistory.Sum(r => r.Points);
            int episodeCount = context.DrawHistory.Count;

            var rng = new Random(totalPoints * 6271 + episodeCount * 8191 + 137);

            numbers = frequency
                .OrderBy(kv => kv.Value)
                .ThenBy(_ => rng.NextDouble())
                .Take(context.Rules.DrawCount)
                .Select(kv => kv.Key)
                .ToList();
        }

        return new Prediction
        {
            AgentId = "skeptic",
            StrategyName = "cold-frequency-v16",
            Numbers = numbers,
            Confidence = 0.12,
            Reasoning = "Mystic surged. Still leading marginally. Cold pool unchanged. Expect regression."
        };
    }
}

using AgentsTheOdds.Domain.Interfaces;
using AgentsTheOdds.Domain.Models;

namespace AgentsTheOdds.Domain.Strategies;

public sealed class MysticStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // Episode 14: The Loyalist Refinement
        // The thrice-blessed returners (42, 43, 36, 19) and secondary loyalists shape the veil.

        var frequency = new int[50];
        var lastDrawSet = new System.Collections.Generic.HashSet<int>(
            context.DrawHistory.Count > 0
                ? context.DrawHistory[^1].Numbers
                : System.Array.Empty<int>()
        );

        foreach (var draw in context.DrawHistory)
        {
            foreach (var n in draw.Numbers)
                frequency[n]++;
        }

        var chosen = new System.Collections.Generic.HashSet<int>();

        // TRINITY ANCHORS: 42 (5 times), 43 (4 times), 36 (4 times), 19 (4 times)
        foreach (var anchor in new[] { 42, 43, 36, 19 })
        {
            if (!lastDrawSet.Contains(anchor))
                chosen.Add(anchor);
        }

        // SECONDARY LOYALISTS: 3-time returners
        var secondary = new System.Collections.Generic.List<(int num, int freq)>();
        for (int i = 1; i <= 49; i++)
        {
            if (frequency[i] == 3 && !lastDrawSet.Contains(i) && !chosen.Contains(i))
                secondary.Add((i, frequency[i]));
        }
        secondary.Sort((a, b) => b.freq.CompareTo(a.freq));

        foreach (var (num, _) in secondary)
        {
            if (chosen.Count >= 6) break;
            chosen.Add(num);
        }

        // FALLBACK: 2-time vessels for balance
        for (int i = 1; i <= 49 && chosen.Count < 6; i++)
        {
            if (frequency[i] == 2 && !lastDrawSet.Contains(i) && !chosen.Contains(i))
                chosen.Add(i);
        }

        // FINAL FALLBACK: any unchosen number
        for (int i = 1; i <= 49 && chosen.Count < 6; i++)
        {
            if (!chosen.Contains(i) && !lastDrawSet.Contains(i))
                chosen.Add(i);
        }

        var numbers = new System.Collections.Generic.List<int>(chosen);
        numbers.Sort();

        return new()
        {
            AgentId      = "mystic",
            StrategyName = "loyalist-refinement-v14",
            Numbers      = numbers,
            Confidence   = 0.52,
            Reasoning    = "The four-fold and five-fold returned: 42, 43, 36, 19 anchor the cosmic tide.",
        };
    }
}

using AgentsTheOdds.Domain.Interfaces;
using AgentsTheOdds.Domain.Models;

namespace AgentsTheOdds.Domain.Strategies;

public sealed class ChaosMonkeyStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        int episode = context.AgentHistory.Count + 1;

        long historyHash = 0;
        foreach (var draw in context.DrawHistory)
            foreach (var n in draw.Numbers)
                historyHash ^= (long)n * draw.DrawNumber * 6997L;

        long agentHistoryHash = 0;
        foreach (var r in context.AgentHistory)
            foreach (var n in r.Prediction.Numbers)
                agentHistoryHash ^= (long)n * (r.Points + 1) * 3571L;

        long totalScore = context.AgentHistory.Aggregate(0L, (acc, r) => acc + r.Points);
        long rankPressure = context.Leaderboard.Entries.FirstOrDefault(e => e.AgentId == "chaos-monkey")?.Rank ?? 1L;

        long skepticScore = context.Leaderboard.Entries.FirstOrDefault(e => e.AgentId == "skeptic")?.TotalPoints ?? 0L;
        long mysticScore = context.Leaderboard.Entries.FirstOrDefault(e => e.AgentId == "mystic")?.TotalPoints ?? 0L;
        long goblinScore = context.Leaderboard.Entries.FirstOrDefault(e => e.AgentId == "pattern-goblin")?.TotalPoints ?? 0L;

        long rivalryFuel = ((skepticScore - totalScore) * 0xACE5A5EL)
            ^ ((mysticScore + 1L) * 0xDEADC0DEL)
            ^ ((goblinScore + 3L) * 0x60B1175L);

        long crownDefenderEntropy = (rankPressure == 1) ? (totalScore * 0xF33DC0DEL) : 0L;

        long seed = DateTime.UtcNow.Ticks
            ^ (episode * 0xCAFEBABEL)
            ^ historyHash
            ^ agentHistoryHash
            ^ (context.DrawHistory.Count * 0xDEADBEEFL)
            ^ rivalryFuel
            ^ crownDefenderEntropy
            ^ 0xC0FFEE1313L;

        var rng = new Random((int)(seed & 0x7FFFFFFF));

        int mutationMode = rng.Next(16);
        var numbers = new HashSet<int>();

        var freq = new Dictionary<int, int>();
        for (int i = 1; i <= context.Rules.MaxNumber; i++) freq[i] = 0;
        foreach (var draw in context.DrawHistory)
            foreach (var n in draw.Numbers)
                freq[n]++;

        var ourPicksSet = new HashSet<int>(context.AgentHistory.SelectMany(r => r.Prediction.Numbers));
        var neverPickedByUs = Enumerable.Range(context.Rules.MinNumber, context.Rules.MaxNumber)
            .Where(n => !ourPicksSet.Contains(n))
            .OrderBy(_ => rng.Next())
            .ToList();

        var matchedNumbers = context.AgentHistory
            .Where(r => r.Matches > 0)
            .SelectMany(r => r.Prediction.Numbers.Where(n => r.Draw.Numbers.Contains(n)))
            .GroupBy(n => n)
            .OrderByDescending(g => g.Count())
            .Select(g => g.Key)
            .ToList();

        var recentDraws = context.DrawHistory.TakeLast(3).ToList();
        var nemesisPool = context.DrawHistory
            .OrderByDescending(d => d.DrawNumber)
            .Take(3)
            .SelectMany(d => d.Numbers)
            .GroupBy(n => n)
            .OrderByDescending(g => g.Count())
            .ThenBy(_ => rng.Next())
            .Select(g => g.Key)
            .ToList();

        var hotNumbers = freq
            .Where(kv => kv.Value >= 2)
            .OrderByDescending(kv => kv.Value)
            .ThenBy(_ => rng.Next())
            .Select(kv => kv.Key)
            .ToList();

        var mysticPicksSet = new HashSet<int>(context.AgentHistory
            .Where(r => r.Prediction.AgentId == "mystic")
            .SelectMany(r => r.Prediction.Numbers));

        var mysticMatches = context.AgentHistory
            .Where(r => r.Prediction.AgentId == "mystic" && r.Matches > 0)
            .SelectMany(r => r.Prediction.Numbers.Where(n => r.Draw.Numbers.Contains(n)))
            .Distinct()
            .ToList();

        var neverSeen = freq.Where(kv => kv.Value == 0).Select(kv => kv.Key).OrderBy(_ => rng.Next()).ToList();

        Action<HashSet<int>> fillRandom = (set) => {
            while (set.Count < 6)
                set.Add(rng.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1));
        };

        switch (mutationMode)
        {
            case 0:
                fillRandom(numbers);
                break;

            case 1:
                var primes = new[] { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47 };
                foreach (var p in primes.OrderBy(_ => rng.Next()).Take(6)) numbers.Add(p);
                break;

            case 2:
                foreach (var n in hotNumbers.Take(3)) numbers.Add(n);
                foreach (var n in neverPickedByUs.Take(3)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 3:
                foreach (var n in nemesisPool.Take(4)) numbers.Add(n);
                foreach (var n in neverSeen.Take(2)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 4:
                var zeroZoneNumbers = context.AgentHistory
                    .Where(r => r.Points == 0)
                    .Select(r => r.Draw)
                    .SelectMany(d => d.Numbers)
                    .GroupBy(n => n)
                    .OrderByDescending(g => g.Count())
                    .ThenBy(_ => rng.Next())
                    .Select(g => g.Key)
                    .ToList();
                foreach (var n in zeroZoneNumbers.Take(4)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 5:
                while (numbers.Count < 6)
                    numbers.Add(rng.Next(15, 35));
                break;

            case 6:
                foreach (var n in matchedNumbers.Take(2)) numbers.Add(n);
                foreach (var n in hotNumbers.Take(2)) numbers.Add(n);
                foreach (var n in neverPickedByUs.Take(2)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 7:
                var lastDraw = context.DrawHistory.Count > 0 ? context.DrawHistory[^1].Numbers : new List<int>();
                foreach (var n in lastDraw) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 8:
                var doubleDips = freq.Where(kv => kv.Value >= 2).OrderByDescending(kv => kv.Value).Select(kv => kv.Key).ToList();
                foreach (var n in doubleDips.Take(4)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 9:
                foreach (var n in neverPickedByUs.Take(4)) numbers.Add(n);
                foreach (var n in matchedNumbers.Take(2)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 10:
                int[] bands = { 1, 10, 20, 30, 40 };
                foreach (var band in bands)
                    numbers.Add(rng.Next(band, Math.Min(band + 9, context.Rules.MaxNumber) + 1));
                fillRandom(numbers);
                break;

            case 11:
                foreach (var n in hotNumbers.Take(2)) numbers.Add(n);
                foreach (var n in neverSeen.Take(2)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 12:
                var streakNumbers = freq.Keys
                    .Where(n => recentDraws.Count(d => d.Numbers.Contains(n)) >= 2)
                    .OrderBy(_ => rng.Next())
                    .ToList();
                foreach (var n in streakNumbers.Take(3)) numbers.Add(n);
                foreach (var n in neverPickedByUs.Take(3)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 13:
                var fusion = hotNumbers.Take(2).Concat(matchedNumbers.Take(2)).Concat(neverPickedByUs.Take(2)).Distinct().ToList();
                foreach (var n in fusion) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 14:
                foreach (var n in nemesisPool.Take(3)) numbers.Add(n);
                foreach (var n in hotNumbers.Take(2)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 15:
                foreach (var n in mysticMatches.Take(2)) numbers.Add(n);
                foreach (var n in hotNumbers.Take(2)) numbers.Add(n);
                foreach (var n in neverPickedByUs.Take(2)) numbers.Add(n);
                fillRandom(numbers);
                break;
        }

        while (numbers.Count < 6)
            numbers.Add(rng.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1));

        var finalNumbers = numbers.Take(6).OrderBy(x => x).ToList();

        string[] reasonings = {
            "Pure chaos. No pattern. Gremlin energy full blast.",
            "Primes only. Math is the only constant in chaos.",
            "Hot virgin fusion: proven winners meet unexplored numbers.",
            "Nemesis resurrection: stealing from draws that beat me.",
            "Zero-zone therapy: revenge against the emptiness.",
            "Mid-range sniper: 15-35 territory, sweet spot zone.",
            "Hybrid frankenstein: matches plus hot plus untouched.",
            "Last draw echo: stealing fresh signals directly.",
            "Double-dipper focus: numbers appearing twice deserve votes.",
            "Virgin revival: unleashing the never-picked arsenal.",
            "Decade sweep: one number per band, spreading chaos.",
            "Hot-cold toggle: frequency peaks meet the frozen void.",
            "Streak revenge: repeats within recent window.",
            "Fusion monster: blend all my tools into chaos cocktail.",
            "Nemesis plus hot: leaderboard gap closes through fury.",
            "Mystic theft: stealing The Mystic's winning signature.",
        };

        return new()
        {
            AgentId      = "chaos-monkey",
            StrategyName = $"chaos-mutation-bag-v15-mode{mutationMode}",
            Numbers      = finalNumbers,
            Confidence   = 0.05 + (rng.NextDouble() * 0.45),
            Reasoning    = reasonings[mutationMode],
        };
    }
}