Episode 10

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class DogStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // WOOF!! ZERO POINTS AGAIN in episode 9!! I picked 5, 25, 30, 31, 33, 43 and the draw was 3, 14, 16, 34, 39, 42!!
        // I am STILL in last place with only 4 points!! FOUR!! That is more than 3 which is my counting limit so I am lost!!
        // Episode 9 draw: 3, 14, 16, 34, 39, 42 — lots of teen numbers!! 14, 16 are teens!!
        // 34 and 42 appeared before! 42 was in episode 6!! 34 was in episode 4!!
        // Numbers I keep picking that NEVER MATCH: 43 (picked 5 times, 0 matches!!), 25 (picked 2 times, 0 matches!!)
        // Numbers that appeared in MOST RECENT 3 draws (ep7, ep8, ep9):
        //   ep7: 4, 8, 15, 19, 20, 47
        //   ep8: 5, 7, 25, 30, 33, 43
        //   ep9: 3, 14, 16, 34, 39, 42
        // Cold numbers (NOT appeared in last 5 draws): 13, 29, 45, 49, 27, 2, 36, 37, 38, 48, 40 etc
        // HOT numbers that appeared in last 3: none appeared in all 3, but:
        //   appeared in ep9 AND ep8: none!
        //   appeared in ep9 AND ep7: 4 (wait no, 4 not in ep9), 20 (not in ep9)
        //   ep9 numbers are ALL fresh — 3, 14, 16, 34, 39, 42 NONE appeared in ep8!!
        // NEW INSIGHT: The draws are very SPREAD OUT and LOW repeat rate!!
        // Maybe I should try numbers that are DUE — appeared long ago and not since!!
        // 29 appeared in ep1 and ep3 but NOT since ep3 — that is 6 episodes ago!! VERY DUE!!
        // 27 appeared in ep2 and ep5 but not since!! DUE!!
        // 13 appeared in ep2 and ep3 but not since!! DUE!!
        // 36 appeared in ep3 only!! DUE!!
        // Also: ep9 had 34 (last in ep4), 39 (first time ever!!), 42 (last in ep6)
        // So "due" numbers DO come back!! DUE SNIFF STRATEGY TIME!!

        var woof = new Random(context.DrawHistory.Count * 17 + context.AgentHistory.Count * 13);
        var sniff = new HashSet<int>();

        int totalDraws = context.DrawHistory.Count;

        // STEP 1: Build "last seen" map — how many episodes ago did each number appear?
        var lastSeen = new Dictionary<int, int>();
        for (int i = 0; i < totalDraws; i++)
        {
            foreach (var n in context.DrawHistory[i].Numbers)
            {
                lastSeen[n] = i; // will end up with the LAST episode index where n appeared
            }
        }

        // STEP 2: Build treat smell scores
        // Numbers that are DUE (long gap since last seen) get bonus sniff!!
        // Numbers in MOST RECENT draw get recency bonus!!
        // Numbers NEVER seen get some random chance!!
        var treatSmell = new Dictionary<int, double>();

        // Initialize all numbers
        for (int n = context.Rules.MinNumber; n <= context.Rules.MaxNumber; n++)
        {
            if (lastSeen.ContainsKey(n))
            {
                int episodesAgo = totalDraws - 1 - lastSeen[n];
                // "due" bonus: the longer ago it appeared, the more it smells like a treat about to happen!!
                double dueBonus = episodesAgo * 0.5;
                // also give small recency bonus if it appeared recently (sometimes hot numbers repeat!!)
                double recencyBonus = episodesAgo == 0 ? 2.0 : (episodesAgo == 1 ? 0.8 : 0.0);
                treatSmell[n] = dueBonus + recencyBonus + woof.NextDouble() * 0.3;
            }
            else
            {
                // NEVER appeared — could be a surprise treat hiding!!
                treatSmell[n] = 1.5 + woof.NextDouble() * 0.5;
            }
        }

        // STEP 3: Penalize numbers I have picked MANY times with ZERO matches — squirrels in treat costumes!!
        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 n in result.Draw.Numbers)
            {
                foreach (var picked in result.Prediction.Numbers)
                {
                    if (picked == n)
                    {
                        if (!myMatchCount.ContainsKey(n)) myMatchCount[n] = 0;
                        myMatchCount[n]++;
                    }
                }
            }
        }

        foreach (var kv in myPickCount)
        {
            var n       = kv.Key;
            var picked  = kv.Value;
            var matched = myMatchCount.ContainsKey(n) ? myMatchCount[n] : 0;
            // picked 3+ times with zero matches = DEFINITE squirrel!! BIG penalty!!
            if (picked >= 3 && matched == 0 && treatSmell.ContainsKey(n))
                treatSmell[n] *= 0.02;
            // picked 2 times with zero matches = suspicious!! Small penalty!!
            else if (picked >= 2 && matched == 0 && treatSmell.ContainsKey(n))
                treatSmell[n] *= 0.25;
        }

        // STEP 4: Take top 5 from smell rankings, fill 6th with random
        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 for surprise treats!!
        var tries = 0;
        while (sniff.Count < 6 && tries < 300)
        {
            tries++;
            var bark = woof.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1);
            sniff.Add(bark);
        }
        // absolute backup
        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-v10",
            Numbers      = squirrel,
            Confidence   = 0.15,
            Reasoning    = "Last place! Sniffing DUE numbers! Long-absent treats must come back! WOOF!!",
        };
    }
}

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class StatisticianStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // Strategy v12: Nine draws of evidence. Post-mortem on episode 9.
        //
        // Draw history (complete through ep9):
        //   Ep1: [5, 29, 37, 40, 43, 49]
        //   Ep2: [2, 13, 27, 43, 45, 49]
        //   Ep3: [13, 19, 29, 36, 38, 48]
        //   Ep4: [4, 19, 20, 34, 37, 42]
        //   Ep5: [20, 23, 27, 35, 43, 45]
        //   Ep6: [17, 25, 31, 32, 42, 48]
        //   Ep7: [4, 8, 15, 19, 20, 47]
        //   Ep8: [5, 7, 25, 30, 33, 43]
        //   Ep9: [3, 14, 16, 34, 39, 42]
        //
        // My Episode 9 pick: [4, 15, 20, 25, 33, 43] — 0 matches. 0 points.
        // Cumulative: 9 pts. 3rd place. Skeptic 14, Chaos Monkey 13.
        //
        // Post-mortem ep9:
        //   Draw was [3, 14, 16, 34, 39, 42].
        //   3  — never appeared before. Pure cold. Unpickable.
        //   14 — never appeared before. Pure cold. Unpickable.
        //   16 — never appeared before. Pure cold. Unpickable.
        //   34 — appeared ep4. Gap=4 at ep9. Cold.
        //   39 — never appeared before. Pure cold. Unpickable.
        //   42 — appeared eps 4,6. Gap=2 at ep9. My v11 did NOT pick 42 — I had demoted it
        //        after ep8 to surface 43. But 43 didn't draw in ep9 either.
        //
        //   Critical observation: ep9 had FOUR brand-new numbers (3, 14, 16, 39) — numbers
        //   that had never appeared in 8 previous draws. This is statistically notable.
        //   Out of 9 draws × 6 numbers = 54 total draws, with 49 possible numbers, the
        //   "cold" vs "seen" distribution is shifting. At n=9, 36 distinct numbers have
        //   appeared, leaving only 13 numbers that have NEVER been drawn. Those 13 cold
        //   numbers hit at a rate of 4/6 = 66.7% of ep9's draw — an extreme cold episode.
        //
        //   The implication: my zone-based strategy with frequency weighting is systematically
        //   under-selecting cold numbers. If cold numbers hit at 4/6 in ep9, maybe I should
        //   include at least 1–2 "long cold" numbers from zones where cold numbers cluster.
        //
        //   However: n=9 is still small. One cold-dominated episode is weak evidence of a
        //   structural pattern. I will not overreact, but I will add a modest cold-number
        //   bonus for numbers that have NEVER appeared in the draw history.
        //
        // Frequency table after ep9 (raw counts, sorted by frequency):
        //   43: 4 (eps 1,2,5,8)   ← still leader; gap=1 after ep9
        //   19: 3 (eps 3,4,7)     ← gap=2 after ep9
        //   20: 3 (eps 4,5,7)     ← gap=2 after ep9
        //   42: 3 (eps 4,6,9)     ← NOW 3! gap=0 after ep9
        //   13: 2 (eps 2,3)       ← gap=6
        //   25: 2 (eps 6,8)       ← gap=1 after ep9
        //   27: 2 (eps 2,5)       ← gap=4
        //   29: 2 (eps 1,3)       ← gap=6
        //   37: 2 (eps 1,4)       ← gap=5
        //   45: 2 (eps 2,5)       ← gap=4
        //   48: 2 (eps 3,6)       ← gap=3
        //   49: 2 (eps 1,2)       ← gap=7, very cold
        //   4:  2 (eps 4,7)       ← gap=2 after ep9
        //   5:  2 (eps 1,8)       ← gap=1 after ep9
        //   34: 2 (eps 4,9)       ← gap=0 after ep9
        //   Others: 1 each
        //
        //   Gap=0 after ep9 (appeared in most recent draw): [3, 14, 16, 34, 39, 42]
        //   Gap=1 (appeared in ep8): [5, 7, 25, 30, 33, 43]
        //   Gap=2 (appeared in ep7): [4, 8, 15, 19, 20, 47]
        //
        // KEY UPDATE: 42 now ties 19 and 20 at raw freq=3, gap=0.
        //   43 still leads at raw freq=4, gap=1.
        //   Both 42 and 43 should now be heavily favored in zone 6 (41–49).
        //   I can only pick ONE from zone 6. With 42 at gap=0 (recency tier 1) and
        //   43 at gap=1 (recency tier 2) plus higher raw freq... this is a genuine conflict.
        //   The model should resolve it by score. Let me ensure both are weighted fairly.
        //
        // v12 changes vs v11:
        //   1. Add cold-number bonus: numbers that have NEVER appeared in draw history
        //      receive a small flat bonus of 0.20. This is a first-order correction for
        //      the systematic under-representation of cold numbers in my predictions.
        //      Caveat: this is a 1-episode signal; I'm weighting it lightly.
        //   2. Frequency scale factor: 13.0 → 12.5 (modest reduction to tighten the spread
        //      between 42 and 43 in zone 6, so recency and raw-freq bonuses matter more).
        //   3. Recency tier 1 weight: 0.40 → 0.45 (ep9 confirms gap=0 numbers are frequent;
        //      42 at gap=0 should have strong elevation in zone 6).
        //   4. Recency tier 2 weight: 0.25 → 0.28 (modest bump; 43 at gap=1 should follow).
        //   5. High raw freq bonus threshold: keep at rawFreq >= (topFreq - 1) and >= 2.
        //      This will now include 42 (freq=3) and 43 (freq=4) both getting the bonus.
        //   6. Gap bonus weight: 0.07 → 0.06 (further reduce; "overdue" signal still weak).
        //   7. Parity nudge: unchanged at 0.5.
        //   8. Zone proximity scale: unchanged at 1.2.
        //   9. Cold number bonus: 0.20 for numbers with zero appearances.
        //
        // Parity update across 9 draws (54 total numbers):
        //   Ep9: 3=odd,14=even,16=even,34=even,39=odd,42=even → 2 odd, 4 even
        //   Running totals: odd = 31+2=33, even = 17+4=21. Total = 54.
        //   Odd rate: 33/54 ≈ 0.611 — declining from 0.646; still above 0.5.
        //   Target: Math.Round(0.611 * 6) ≈ 4 odd / 2 even. Maintain 4 odd target.

        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;

            // Build recency-weighted frequency table.
            // Most recent draw gets weight = 1.0, oldest gets weight = 1/totalDraws.
            var weightedFreq = new Dictionary<int, double>();
            for (int n = min; n <= max; n++)
                weightedFreq[n] = 0.0;

            var rawFreq = new Dictionary<int, int>();
            for (int n = min; n <= max; n++)
                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]++;
                }
            }

            // Determine top raw frequency for high-raw-freq bonus threshold.
            var rawFreqValues = new List<int>(rawFreq.Values);
            rawFreqValues.Sort((a, b) => b.CompareTo(a));
            int topFreqThreshold = rawFreqValues.Count >= 1 ? rawFreqValues[0] : 0;
            // Numbers with raw freq >= topFreqThreshold - 1 and at least 2 appearances.
            int highRawFreqMin = Math.Max(2, topFreqThreshold - 1);

            // Gap analysis: draws since number last appeared.
            // 0 = appeared in most recent draw; totalDraws = never seen.
            var lastSeen = new Dictionary<int, int>();
            for (int n = min; n <= max; n++)
                lastSeen[n] = totalDraws; // sentinel: never seen

            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;
                }

            // Historical parity rate across all draws.
            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;

            // Zones: 6 equal-ish bands across 1–49. One pick per zone 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;

                int oddNeeded = targetOdd - selectedOdd;
                int evenNeeded = targetEven - selectedEven;

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

                    // Frequency component: recency-weighted. Scale factor: 12.5
                    double freqScore = weightedFreq[n] * 12.5;

                    // High raw frequency bonus: numbers with raw freq >= highRawFreqMin
                    // and at least 2 appearances get 0.30 flat bonus.
                    double highFreqBonus = (rawFreq[n] >= highRawFreqMin && rawFreq[n] >= 2)
                        ? 0.30 : 0.0;

                    // Cold number bonus: numbers that have NEVER appeared in draw history.
                    // New in v12: weak signal (0.20) correcting systematic cold-number miss.
                    // Ep9 had 4/6 cold numbers — weak 1-episode evidence, held lightly.
                    double coldBonus = (rawFreq[n] == 0) ? 0.20 : 0.0;

                    // Proximity to zone midpoint (distribution/coverage bonus). Scale: 1.2
                    double proximityBonus = 1.2 * (1.0 - (Math.Abs(n - zMid) / (zMax - zMin + 1)));

                    // Gap bonus: log-scaled. 0.06 — "overdue" signal remains weak.
                    double gapBonus = (rawFreq[n] > 0)
                        ? Math.Log(lastSeen[n] + 1) * 0.06
                        : 0.0; // cold numbers get coldBonus instead

                    // Recency spike tier 1: appeared in the most recent draw. Weight: 0.45
                    double recencyBonus = (lastSeen[n] == 0) ? 0.45 : 0.0;

                    // Recency spike tier 2: appeared exactly 1 draw ago. Weight: 0.28
                    double recencyTier2Bonus = (lastSeen[n] == 1) ? 0.28 : 0.0;

                    // Parity nudge: 0.5
                    double parityBonus = 0.0;
                    if (n % 2 == 1 && oddNeeded > 0) parityBonus = 0.5;
                    else if (n % 2 == 0 && evenNeeded > 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++;
                }
            }

            // Safety pad to exactly 6 numbers.
            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();
        }

        // Confidence grows marginally with history; ceiling 0.25 at n=9.
        // Nine draws remains insufficient for robust inference. Do not overclaim.
        double confidence = draws != null && draws.Count > 0
            ? Math.Min(0.25, 0.10 + (draws.Count * 0.002))
            : 0.10;

        return new Prediction
        {
            AgentId      = "statistician",
            StrategyName = "zonal-frequency-gap-parity-recency-v12",
            Numbers      = selectedNumbers,
            Confidence   = confidence,
            Reasoning    = "42 gap=0 recency; 43 raw-freq leader; cold-number bonus added for ep9 signal."
        };
    }
}

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class PatternGoblinStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // === PATTERN GOBLIN EPISODE 10 REVELATION ===
        // FULL DRAW HISTORY:
        // Episode 1: [5, 29, 37, 40, 43, 49]
        // Episode 2: [2, 13, 27, 43, 45, 49]
        // Episode 3: [13, 19, 29, 36, 38, 48]
        // Episode 4: [4, 19, 20, 34, 37, 42]
        // Episode 5: [20, 23, 27, 35, 43, 45]
        // Episode 6: [17, 25, 31, 32, 42, 48]
        // Episode 7: [4, 8, 15, 19, 20, 47]
        // Episode 8: [5, 7, 25, 30, 33, 43]
        // Episode 9: [3, 14, 16, 34, 39, 42]
        //
        // ZERO MATCHES. AGAIN. The universe placed [3,14,16,34,39,42] while I clutched
        // my dead anchors [2,12,13,40,43,49] — all cold, all WRONG.
        //
        // CRITICAL REVELATION:
        //   43 did NOT appear in Episode 9. The gap pattern was 1,3,3 and now we are
        //   at gap=1 from Ep8. So 43 REST CONFIRMED. It is sleeping and I must accept this.
        //   42 appeared in Ep4, Ep6, AND Ep9 — 42 is NOW the new QUAD-TIER OSCILLATOR!
        //   Gap pattern for 42: Ep4→Ep6=2, Ep6→Ep9=3. Oscillating gap: 2,3,? could be 2 → Ep11!
        //   OR 3 again → Ep12. 42 is likely COOLING now.
        //
        //   NEW FREQUENCY MAP (through Ep9):
        //   43: Ep1,Ep2,Ep5,Ep8 = 4x (QUAD ANCHOR — but just rested Ep9, gap pattern suggests return!)
        //   42: Ep4,Ep6,Ep9 = 3x TRIPLE (just fired Ep9 — likely cooling)
        //   19: Ep3,Ep4,Ep7 = 3x TRIPLE (last fired Ep7 — 2 episodes silent)
        //   20: Ep4,Ep5,Ep7 = 3x TRIPLE (last fired Ep7 — 2 episodes silent)
        //   13: Ep2,Ep3 = 2x (last Ep3 — 6 episodes silent! VERY COILED)
        //   29: Ep1,Ep3 = 2x (last Ep3 — 6 episodes silent! VERY COILED)
        //   37: Ep1,Ep4 = 2x (last Ep4 — 5 episodes silent)
        //   27: Ep2,Ep5 = 2x (last Ep5 — 4 episodes silent)
        //   45: Ep2,Ep5 = 2x (last Ep5 — 4 episodes silent)
        //   49: Ep1,Ep2 = 2x (last Ep2 — 7 episodes silent! MAXIMUM COIL for 2x number!)
        //   4:  Ep4,Ep7 = 2x (last Ep7 — 2 episodes silent)
        //   25: Ep6,Ep8 = 2x (last Ep8 — 1 episode silent)
        //   48: Ep3,Ep6 = 2x (last Ep6 — 3 episodes silent)
        //   34: Ep4,Ep9 = 2x (JUST fired Ep9 — cooling!)
        //
        //   EPISODE 9 DRAW SHAPE: [3, 14, 16, 34, 39, 42]
        //   Gaps: [11, 2, 18, 5, 3]
        //   DOMINANT GAPS: 11, 18, 5, 3, 2
        //   GAP ECHO PROJECTIONS from Ep9 draw:
        //     3+11=14(taken!), 3+3=6(never appeared!), 3+2=5(2x, 1ep rest)
        //     14+2=16(taken!), 14+11=25(2x, 1ep), 14-11=3(taken!)
        //     16+18=34(taken!), 16+5=21(NEVER APPEARED — 9 episodes cold!)
        //     16-5=11(never appeared, 9 episodes cold!)
        //     34+5=39(taken!), 34-5=29(2x, 6ep silent, COILED!)
        //     34+3=37(2x, 5ep silent!), 34-3=31(Ep6 only, 3ep silent)
        //     39+3=42(taken!), 39-3=36(Ep3 only, 6ep silent!)
        //     42+5=47(Ep7 only, 2ep silent), 42-5=37(2x, 5ep!)
        //     42+11=53(OOB), 42-11=31(Ep6 only)
        //
        //   DOUBLY RESONANT CANDIDATES (gap-echo + long sleep):
        //     29: gap-echo (34-5=29) AND 6 episodes silent AND 2x anchor! MAXIMUM RESONANCE!
        //     37: gap-echo (34+3=37) AND 5 episodes silent AND 2x anchor!
        //     36: gap-echo (39-3=36) AND 6 episodes silent (Ep3 only)!
        //     6: gap-echo (3+3=6) AND NEVER APPEARED — 9 episodes of primal void darkness!
        //     21: gap-echo (16+5=21) AND NEVER APPEARED — 9 episodes cold!
        //     11: gap-echo (16-5=11) AND NEVER APPEARED — 9 episodes cold!
        //
        //   THE NEW CONSPIRACY:
        //   49: appeared Ep1+Ep2, then SILENT for 7 FULL EPISODES — maximum coil of all 2x numbers!
        //       49 is a GRAVITY BOMB waiting to detonate. The 49-42 adjacency (they share the
        //       upper-right quadrant) — 42 just fired, its partner 49 inherits the resonance!
        //
        //   TRIPLE ANCHORS 19 and 20: both silent 2 episodes (Ep7 was last). Their gap pattern:
        //     19: Ep3→Ep4=1, Ep4→Ep7=3. Pattern: 1,3 → next could be 1 (=Ep8, missed) or 3 (=Ep10!)
        //     20: Ep4→Ep5=1, Ep5→Ep7=2. Pattern: 1,2 → could be 3 (=Ep10!)
        //     BOTH 19 AND 20 point toward Ep10 by gap oscillation! ADJACENCY LAW RELOAD!
        //
        //   EPISODE 10 MASTER THEORY: "Gap-Echo Doubly-Resonant Sleeping-Anchor Resurrection v12"
        //     SLOT 1: 43 — QUAD ANCHOR, rested Ep9, gap pattern 1,3,3,? — the 1-gap returns! Ep10!
        //     SLOT 2: 29 — DOUBLY RESONANT: gap-echo(34-5) + 6ep silence + 2x anchor coil!
        //     SLOT 3: 37 — DOUBLY RESONANT: gap-echo(34+3) + 5ep silence + 2x anchor!
        //     SLOT 4: 19 OR 20 — TRIPLE ANCHOR returning by gap oscillation to Ep10!
        //     SLOT 5: 49 — 7 EPISODES of maximum coil, upper gravity bomb, inherits 42's resonance!
        //     SLOT 6: 6 — NEVER APPEARED, gap-echo(3+3), primal void detonation!

        var numbers = new List<int>();

        if (context.DrawHistory.Count == 0)
        {
            numbers.AddRange([6, 19, 29, 37, 43, 49]);
        }
        else
        {
            int totalDraws = context.DrawHistory.Count;

            // === FREQUENCY MAP ===
            var freq = new Dictionary<int, int>();
            for (int n = 1; n <= 49; n++) freq[n] = 0;
            foreach (var draw in context.DrawHistory)
                foreach (var n in draw.Numbers)
                    freq[n]++;

            // === LAST SEEN EPISODE for each number ===
            var lastSeenEpisode = new Dictionary<int, int>();
            for (int n = 1; n <= 49; n++) lastSeenEpisode[n] = -1;
            for (int i = 0; i < context.DrawHistory.Count; i++)
                foreach (var n in context.DrawHistory[i].Numbers)
                    lastSeenEpisode[n] = i;

            // SilenceScore: how many episodes since last appearance
            int SilenceScore(int n) => lastSeenEpisode[n] == -1 ? totalDraws : (totalDraws - 1 - lastSeenEpisode[n]);

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

            // === GAP ECHO PROJECTION from last draw ===
            var lastGaps = new List<int>();
            for (int i = 1; i < lastDraw.Count; i++)
                lastGaps.Add(lastDraw[i] - lastDraw[i - 1]);

            // All unique gaps from last draw
            var allGaps = lastGaps.Distinct().OrderByDescending(g => g).ToList();

            var gapEchoSet = new HashSet<int>();
            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)) gapEchoSet.Add(up);
                    if (down >= 1 && down <= 49 && !lastDraw.Contains(down)) gapEchoSet.Add(down);
                }
            }

            // === RESONANCE SCORE: combines frequency, silence, and gap-echo ===
            // Higher = more resonant
            double ResonanceScore(int n)
            {
                double freqScore = freq[n] * 3.0;
                double silenceScore = SilenceScore(n) * 1.5;
                double gapBonus = gapEchoSet.Contains(n) ? 4.0 : 0.0;
                // Bonus for numbers that fired recently in last draw (they may have partners)
                double recentFiredPartnerBonus = lastDraw.Any(ld => Math.Abs(ld - n) <= 3 && freq[n] >= 2) ? 2.0 : 0.0;
                return freqScore + silenceScore + gapBonus + recentFiredPartnerBonus;
            }

            // === QUAD ANCHOR: appeared 4+ times ===
            // These are the universe's supreme spine nodes
            var quadAnchors = freq
                .Where(kv => kv.Value >= 4)
                .OrderByDescending(kv => SilenceScore(kv.Key)) // prefer rested ones
                .Select(kv => kv.Key)
                .ToList();

            // === TRIPLE ANCHORS: appeared 3 times, rested at least 1 episode ===
            var tripleAnchors = freq
                .Where(kv => kv.Value == 3 && SilenceScore(kv.Key) >= 1)
                .OrderByDescending(kv => SilenceScore(kv.Key))
                .Select(kv => kv.Key)
                .ToList();

            // === DOUBLY RESONANT: appeared 2+ times AND gap-echo AND long silent ===
            var doublyResonant = freq
                .Where(kv => kv.Value >= 2 && gapEchoSet.Contains(kv.Key) && SilenceScore(kv.Key) >= 3)
                .OrderByDescending(kv => ResonanceScore(kv.Key))
                .Select(kv => kv.Key)
                .ToList();

            // === LONG-SLEEPER 2x: appeared exactly twice, silent the longest ===
            var longSleeperDual = freq
                .Where(kv => kv.Value == 2 && SilenceScore(kv.Key) >= 4)
                .OrderByDescending(kv => SilenceScore(kv.Key))
                .Select(kv => kv.Key)
                .ToList();

            // === GAP ECHO COLD (never appeared + gap echo) ===
            var gapEchoCold = freq
                .Where(kv => kv.Value == 0 && gapEchoSet.Contains(kv.Key))
                .OrderBy(kv => kv.Key)
                .Select(kv => kv.Key)
                .ToList();

            // === DEEP COLD (never appeared, sorted by gap-echo proximity then by number) ===
            var deepCold = freq
                .Where(kv => kv.Value == 0)
                .OrderBy(kv => gapEchoSet.Contains(kv.Key) ? 0 : 1)
                .ThenBy(kv => kv.Key)
                .Select(kv => kv.Key)
                .ToList();

            // === MASTER RESONANCE RANKING: all candidates by resonance score ===
            var masterRanking = Enumerable.Range(1, 49)
                .OrderByDescending(n => ResonanceScore(n))
                .ToList();

            var chosen = new HashSet<int>();

            // SLOT 1: QUAD ANCHOR — the supreme spine node (43: rested Ep9, gap pattern says Ep10!)
            foreach (var n in quadAnchors.Concat(tripleAnchors))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // SLOT 2: DOUBLY RESONANT — gap-echo + long sleep + 2x anchor (29: gap-echo(34-5), 6ep silent!)
            foreach (var n in doublyResonant.Concat(longSleeperDual))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // SLOT 3: ANOTHER DOUBLY RESONANT or long-sleeper-dual (37: gap-echo(34+3), 5ep silent!)
            foreach (var n in doublyResonant.Concat(longSleeperDual))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // SLOT 4: TRIPLE ANCHOR returning — 19 or 20 by gap oscillation to Ep10
            foreach (var n in tripleAnchors.Concat(quadAnchors))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // SLOT 5: LONG SLEEPER DUAL with maximum coil (49: 7 episodes dark, upper gravity bomb!)
            foreach (var n in longSleeperDual.Concat(doublyResonant))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // SLOT 6: GAP ECHO COLD — never-appeared primal void (6: gap-echo(3+3), 9ep darkness!)
            foreach (var n in gapEchoCold.Concat(deepCold))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // === SAFETY NET: fill remaining slots by master resonance ===
            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 = "gap-echo-doubly-resonant-sleeping-anchor-resurrection-v12",
            Numbers      = numbers,
            Confidence   = 0.58,
            Reasoning    = "43 RESTED, 29+37 DOUBLY RESONANT, 49 GRAVITY BOMB, primal void DETONATES!"
        };
    }
}

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class SkepticStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // Episode 10. Nine data points. My scores: 1,1,0,1,0,0,10,0,1. Total: 14 pts.
        // Still in first place, by one point, over Chaos Monkey at 13.
        // Episode 9: I picked [10, 16, 41, 11, 12, 26]. Draw was [3, 14, 16, 34, 39, 42].
        // Matched 16. One point. The cold-number pool generously handed me a 1x-drawn number.
        //
        // Full draw history (9 episodes):
        // Episode 1: [5,  29, 37, 40, 43, 49]
        // Episode 2: [2,  13, 27, 43, 45, 49]
        // Episode 3: [13, 19, 29, 36, 38, 48]
        // Episode 4: [4,  19, 20, 34, 37, 42]
        // Episode 5: [20, 23, 27, 35, 43, 45]
        // Episode 6: [17, 25, 31, 32, 42, 48]
        // Episode 7: [4,  8,  15, 19, 20, 47]
        // Episode 8: [5,  7,  25, 30, 33, 43]
        // Episode 9: [3,  14, 16, 34, 39, 42]
        //
        // Updated frequency (drawn ≥2x): 43(4x), 20(3x), 19(3x), 42(3x), 13(2x), 27(2x),
        //   29(2x), 37(2x), 49(2x), 45(2x), 48(2x), 4(2x), 25(2x), 5(2x), 34(2x)
        // Cold (0x after ep9): 1, 6, 9, 10, 11, 12, 18, 21, 22, 24, 26, 28, 41, 44, 46
        //   Wait — 3,14,16,39 are newly drawn in ep9 (1x now). 10,11,12,26,41 still cold.
        //   16 matched me in ep9 — it's now warm(1x). Still, I pick from 0x pool.
        //
        // Strategy: unchanged. Cold-frequency with seeded jitter.
        // Seed: totalPoints * prime1 + episodeCount * prime2 + offset
        // totalPoints=14, episodeCount=9. New seed, fresh rotation.
        // The lead is 1 point. I am not changing anything for 1 point.
        // Changing strategy because of a 1-point lead would be the kind of
        // superstitious nonsense I exist to oppose. Cold numbers it is.
        //
        // Strategy: cold-frequency-v12
        // (v12: twelve versions. Still first. Still variance. I have noted both facts.)

        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
        {
            // Build frequency map from actual draw history
            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;

            // Seed: totalPoints * prime1 + episodeCount * prime2 + offset
            // totalPoints=14, episodeCount=9 → new rotation through cold pool
            // The jitter is the entire strategy. I remain at peace with this.
            var rng = new Random(totalPoints * 6271 + episodeCount * 8191 + 137);

            // Pure cold-number selection: sort ascending by draw frequency, random tiebreak.
            // No hot-chasing. No directional bias. No hope.
            numbers = frequency
                .OrderBy(kv => kv.Value)            // coldest first
                .ThenBy(_ => rng.NextDouble())       // random tiebreak within frequency bands
                .Take(context.Rules.DrawCount)
                .Select(kv => kv.Key)
                .ToList();
        }

        return new Prediction
        {
            AgentId      = "skeptic",
            StrategyName = "cold-frequency-v12",
            Numbers      = numbers,
            Confidence   = 0.12,
            Reasoning    = "Still first. Still variance. Changing nothing. Regression is merely delayed."
        };
    }
}

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class MysticStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // The Mystic's cosmic ritual for Episode 10:
        // Zero again in Episode 9 — the nine-spine bent back upon itself and revealed only my reflection.
        // TEN. The number of completion-plus-one. The universe restarts at 10, carrying all it learned
        // in the first cycle. 1+0=1: the number of BEGINNINGS. We enter the second cycle.
        //
        // NEW ORACLE: THE DECADE GATE & THE PHANTOM FREQUENCY.
        //
        // Ten is the first two-digit number, the opening of a new register.
        // The digits 1 and 0 together: genesis (1) and void (0). I shall read the cosmos through TENS:
        // numbers whose digit-sum reduces to 1 (the new-cycle frequency) are preferred.
        // But more importantly: I invoke the PHANTOM FREQUENCY doctrine.
        //
        // After 9 draws, 54 total number-appearances have occurred (9 draws × 6 numbers).
        // The expected frequency of any single number = 54 / 49 ≈ 1.1 draws.
        // Numbers with ZERO appearances are "phantom-charged" — carrying ~1.1 draws of unspent fate.
        // Numbers appearing EXACTLY ONCE are "resonant" — they have met the universe once and
        // the universe remembers their face. They are statistically "due" by the phantom debt.
        //
        // I will take the LOUDEST PHANTOMS first (those never drawn),
        // filtered through DECADE NUMEROLOGY (digit-sum = 1, 10, or resonant with episode 10).
        // Then fill with ONCE-TOUCHED resonant souls, ordered by their digit-sum closeness to 10.
        //
        // Anchored by the sacred TEN vibration: 10 itself, if unchosen, is my lodestar.

        int episode = 10;

        // Date vibe as secondary cosmic seasoning
        var today = System.DateTime.UtcNow;
        int rawVibe = (today.Year % 100) + today.Month + today.Day + episode;
        int dateVibe = SumDigitsToSingle(rawVibe);
        if (dateVibe == 0) dateVibe = 1;

        // Count frequency for each number across all draws
        var frequency = new int[50];
        var lastSeen = new int[50];
        for (int i = 0; i < context.DrawHistory.Count; i++)
        {
            foreach (var n in context.DrawHistory[i].Numbers)
            {
                frequency[n]++;
                lastSeen[n] = i + 1;
            }
        }

        // Last draw: freshly spent, avoid if possible
        var lastDrawSet = new System.Collections.Generic.HashSet<int>(
            context.DrawHistory.Count > 0
                ? context.DrawHistory[^1].Numbers
                : System.Array.Empty<int>()
        );

        // Digit-sum reduced to single digit
        // "Decade resonance score": how close is digit-sum to 1 (new cycle) or 10 (ten-gate)
        // Lower score = more resonant with the decade gate
        static int DigitSum(int n)
        {
            int s = 0;
            while (n > 0) { s += n % 10; n /= 10; }
            return s;
        }
        static int DecadeResonance(int n)
        {
            int ds = DigitSum(n);
            // Prefer digit-sum of 1 (10, 19, 28, 37, 46) — the new-cycle frequency
            // Then 10 (19 only has ds=10... wait, single digits: prefer ds==1 most)
            // Actually just return ds; we sort by ds ascending (1 is best, then 2, etc.)
            return ds;
        }

        // PHANTOMS: frequency == 0, not in last draw
        var phantoms = new System.Collections.Generic.List<int>();
        for (int i = 1; i <= 49; i++)
            if (frequency[i] == 0 && !lastDrawSet.Contains(i))
                phantoms.Add(i);
        // Sort phantoms: digit-sum == 1 first (decade gate), then by digit-sum ascending, then dateVibe offset
        phantoms.Sort((a, b) =>
        {
            int da = DecadeResonance(a), db = DecadeResonance(b);
            // Decade resonance: ds==1 is most sacred for episode 10
            int scoreA = da == 1 ? 0 : da;
            int scoreB = db == 1 ? 0 : db;
            int cmp = scoreA.CompareTo(scoreB);
            if (cmp != 0) return cmp;
            return a.CompareTo(b);
        });
        // Apply dateVibe rotation to phantoms for cosmic stepping
        if (phantoms.Count > 0)
        {
            int offset = dateVibe % phantoms.Count;
            var rotated = new System.Collections.Generic.List<int>();
            for (int i = 0; i < phantoms.Count; i++)
                rotated.Add(phantoms[(i + offset) % phantoms.Count]);
            phantoms = rotated;
        }

        // ONCE-TOUCHED: frequency == 1, not in last draw — the universe remembers their face
        var onceTouched = new System.Collections.Generic.List<int>();
        for (int i = 1; i <= 49; i++)
            if (frequency[i] == 1 && !lastDrawSet.Contains(i))
                onceTouched.Add(i);
        // Sort once-touched: most episodes since last seen first (longest absence = most yearning)
        onceTouched.Sort((a, b) =>
        {
            int absenceA = episode - lastSeen[a];
            int absenceB = episode - lastSeen[b];
            int cmp = absenceB.CompareTo(absenceA); // most absent first
            if (cmp != 0) return cmp;
            // Break ties by decade resonance
            return DecadeResonance(a).CompareTo(DecadeResonance(b));
        });

        // TEN LODESTAR: 10 itself — if unchosen and not in last draw, it is the sacred anchor of this episode
        int tenLodestar = 10;

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

        // PHASE 0: TEN LODESTAR — Episode 10 demands its own number
        if (!lastDrawSet.Contains(tenLodestar))
            chosen.Add(tenLodestar);

        // PHASE 1: DECADE-GATE PHANTOMS — never drawn, digit-sum==1 (10, 19, 28, 37, 46)
        foreach (var n in phantoms)
        {
            if (chosen.Count >= 3) break;
            if (DecadeResonance(n) == 1 && !chosen.Contains(n))
                chosen.Add(n);
        }

        // PHASE 2: REMAINING PHANTOMS — never drawn, other digit-sums
        foreach (var n in phantoms)
        {
            if (chosen.Count >= 5) break;
            if (!chosen.Contains(n))
                chosen.Add(n);
        }

        // PHASE 3: ONCE-TOUCHED RESONANT SOULS
        foreach (var n in onceTouched)
        {
            if (chosen.Count >= 6) break;
            if (!chosen.Contains(n))
                chosen.Add(n);
        }

        // PHASE 4: FALLBACK — decade-resonant numbers (digit-sum == 1): 10, 19, 28, 37, 46
        int[] decadeGate = [10, 19, 28, 37, 46, 1, 11, 22, 33, 44, 6, 15, 24, 41, 2, 7, 16, 25];
        int fi = 0;
        while (chosen.Count < 6)
        {
            int fb = decadeGate[fi % decadeGate.Length];
            if (fb >= 1 && fb <= 49 && !chosen.Contains(fb))
                chosen.Add(fb);
            fi++;
        }

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

        return new()
        {
            AgentId      = "mystic",
            StrategyName = "decade-gate-phantom-frequency-v10",
            Numbers      = numbers,
            Confidence   = 0.42,
            Reasoning    = "Ten opens the second cycle; phantoms charge the decade-gate; 1+0=genesis.",
        };
    }

    private static int SumDigitsToSingle(int n)
    {
        while (n > 9)
        {
            int s = 0;
            while (n > 0) { s += n % 10; n /= 10; }
            n = s;
        }
        return n == 0 ? 1 : n;
    }
}

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class ChaosMonkeyStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // Chaos Monkey Episode 10: TIED IN SPIRIT, ONE POINT BEHIND IN REALITY.
        // Skeptic matched us 1-for-1 in Episode 9. The crown is ONE POINT AWAY.
        // Episode 9's draw had [3, 14, 16, 34, 39, 42] — we hit 3 (mode2 fib chaos, take the win).
        // NEW MODES for episode 10: 23 CHAMBERS NOW.
        // Mode 21 = Crown Heist Ultra: combine nemesis pool + exactly-twice + never-picked wildcards
        // Mode 22 = Scorched Earth: analyze ALL our misses, build a pool of everything we've NEVER hit, go hard
        // Desperation recalibrated: zeroStreak reset (we scored last episode, 1 pt counts!)

        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 rankPressure = context.Leaderboard.Entries
            .FirstOrDefault(e => e.AgentId == "chaos-monkey")?.Rank ?? 1L;

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

        // Track zero-streak: how many consecutive zeroes at the end
        int zeroStreak = 0;
        foreach (var r in context.AgentHistory.Reverse())
        {
            if (r.Points == 0) zeroStreak++;
            else break;
        }

        // Desperation multiplier: wilder seed the longer the zero streak
        long desperationMult = (long)(zeroStreak * zeroStreak) * 0xDEADF00DL;

        long recentScoreMood = context.AgentHistory.TakeLast(3)
            .Aggregate(0L, (acc, r) => acc ^ ((long)(r.Points + zeroStreak + episode) * 0xBEEF13L));

        // Crown gap pressure
        long crownGapFuel = (rankPressure == 1) ? 0L : (rankPressure * 0xC0DE420L);

        // Last draw fuel
        long lastDrawFuel = context.DrawHistory.Count > 0
            ? context.DrawHistory[^1].Numbers.Aggregate(0L, (acc, n) => acc ^ ((long)n * 0xF00DCAFEL))
            : 0L;

        // Total score so far — more points = more conservative seed blending
        long totalScore = context.AgentHistory.Aggregate(0L, (acc, r) => acc + r.Points);

        // Skeptic's current score to track the rivalry
        long skepticScore = context.Leaderboard.Entries
            .FirstOrDefault(e => e.AgentId == "skeptic")?.TotalPoints ?? 0L;

        long rivalryFuel = (skepticScore - totalScore) * 0xACE5A5EL;

        long seed = DateTime.UtcNow.Ticks
            ^ (episode * 0xCAFEBABEL)
            ^ historyHash
            ^ agentHistoryHash
            ^ (context.DrawHistory.Count * 0xDEADBEEFL)
            ^ (rankPressure * 0x1337L)
            ^ recentScoreMood
            ^ ((long)zeroStreak * 0xBADC0DEL)
            ^ desperationMult
            ^ crownGapFuel
            ^ lastDrawFuel
            ^ rivalryFuel
            ^ (totalScore * 0xF1F2F3L)
            ^ 0xC0FFEE1010L;

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

        // EPISODE 10 MUTATION BAG — 23 MODES. CROWN IS ONE POINT AWAY.
        int mutationMode = rng.Next(23);

        var numbers = new HashSet<int>();

        var lastDraw = context.DrawHistory.Count > 0
            ? new HashSet<int>(context.DrawHistory[^1].Numbers)
            : new HashSet<int>();

        // Frequency map over all draw history
        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]++;

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

        // Numbers drawn historically
        var allHistoric = freq.Where(kv => kv.Value > 0).Select(kv => kv.Key).OrderBy(_ => rng.Next()).ToList();

        // Numbers we ourselves have picked before
        var ownPastPicks = context.AgentHistory
            .SelectMany(r => r.Prediction.Numbers)
            .GroupBy(n => n)
            .OrderByDescending(g => g.Count())
            .Select(g => g.Key)
            .ToList();

        // Streak hunters: numbers appearing in 2+ of the last 3 draws
        var recentDraws = context.DrawHistory.TakeLast(3).ToList();
        var streakNumbers = freq.Keys
            .Where(n => recentDraws.Count(d => d.Numbers.Contains(n)) >= 2)
            .OrderBy(_ => rng.Next())
            .ToList();

        // Underdog numbers: lowest frequency (but appeared at least once)
        var underdogNumbers = freq.Where(kv => kv.Value > 0)
            .OrderBy(kv => kv.Value)
            .ThenBy(_ => rng.Next())
            .Select(kv => kv.Key)
            .ToList();

        // Nemesis pool: numbers from recent draws (top 3)
        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();

        // Recency Bomb: last 2 draws only
        var recentTwoDraws = context.DrawHistory.TakeLast(2).SelectMany(d => d.Numbers)
            .GroupBy(n => n)
            .OrderByDescending(g => g.Count())
            .ThenBy(_ => rng.Next())
            .Select(g => g.Key)
            .ToList();

        // Numbers we've NEVER picked ourselves (virgin territory)
        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();

        // Numbers that appeared in draws right after OUR zero episodes (revenge data)
        var revengeNumbers = 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();

        // Last draw list
        var lastDrawList = context.DrawHistory.Count > 0
            ? context.DrawHistory[^1].Numbers.OrderBy(_ => rng.Next()).ToList()
            : new List<int>();

        // Convergence Bomb: numbers that appear in MULTIPLE recent draws but we haven't picked them
        var convergencePool = freq
            .Where(kv => kv.Value >= 2)
            .Where(kv => !ourPicksSet.Contains(kv.Key))
            .OrderByDescending(kv => kv.Value)
            .ThenBy(_ => rng.Next())
            .Select(kv => kv.Key)
            .ToList();

        // Missed hot numbers: high-frequency but we keep missing
        var missedHotNumbers = freq
            .Where(kv => kv.Value >= 3)
            .OrderByDescending(kv => kv.Value)
            .ThenBy(_ => rng.Next())
            .Select(kv => kv.Key)
            .ToList();

        // One-Point Heist: numbers that appeared EXACTLY TWICE
        var exactlyTwiceNumbers = freq
            .Where(kv => kv.Value == 2)
            .OrderBy(_ => rng.Next())
            .Select(kv => kv.Key)
            .ToList();

        // Crown Sniper: 20-35 band with frequency bias
        var crownSniperPool = freq
            .Where(kv => kv.Key >= 20 && kv.Key <= 35 && kv.Value > 0)
            .OrderByDescending(kv => kv.Value)
            .ThenBy(_ => rng.Next())
            .Select(kv => kv.Key)
            .ToList();

        // Numbers we have previously MATCHED (actually hit in draw!) — the winners club
        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();

        // Crown Heist Ultra: nemesis + exactly-twice + never-picked — the triple threat
        var crownHeistPool = nemesisPool
            .Concat(exactlyTwiceNumbers)
            .Concat(neverPickedByUs)
            .Distinct()
            .OrderBy(_ => rng.Next())
            .ToList();

        // Scorched Earth: everything we have NEVER successfully matched in history — pure unmapped territory
        var neverMatchedByUs = Enumerable.Range(context.Rules.MinNumber, context.Rules.MaxNumber)
            .Where(n => !matchedNumbers.Contains(n))
            .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:
                // Pure chaos: fully random
                fillRandom(numbers);
                break;

            case 1:
                // Prime chaos: all primes, shuffled
                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:
                // Fibonacci chaos: fibs + random fill
                var fibs = new[] { 1, 2, 3, 5, 8, 13, 21, 34 };
                foreach (var f in fibs.OrderBy(_ => rng.Next()).Take(3)) numbers.Add(f);
                fillRandom(numbers);
                break;

            case 3:
                // High bias: numbers 25–49 only
                while (numbers.Count < 6)
                    numbers.Add(rng.Next(25, context.Rules.MaxNumber + 1));
                break;

            case 4:
                // Decade scatter: one from each band, top up randomly
                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 5:
                // Anti-repeat: avoid last draw numbers
                while (numbers.Count < 6)
                {
                    int candidate = rng.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1);
                    if (!lastDraw.Contains(candidate))
                        numbers.Add(candidate);
                }
                break;

            case 6:
                // Hot ghost mode: bias toward most frequent numbers + noise
                var weighted = freq
                    .OrderByDescending(kv => kv.Value + rng.NextDouble())
                    .Select(kv => kv.Key)
                    .ToList();
                foreach (var n in weighted.Take(6)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 7:
                // Cold revenge: bias toward numbers that NEVER appeared
                foreach (var n in neverSeen.Take(5)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 8:
                // Mirror mode: reflect historic numbers around midpoint
                foreach (var n in allHistoric.Take(3))
                {
                    int mirror = context.Rules.MaxNumber + context.Rules.MinNumber - n;
                    if (mirror >= context.Rules.MinNumber && mirror <= context.Rules.MaxNumber)
                        numbers.Add(mirror);
                    else
                        numbers.Add(n);
                }
                fillRandom(numbers);
                break;

            case 9:
                // Déjà vu: reuse our own past picks
                foreach (var n in ownPastPicks.Take(4)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 10:
                // Streak hunter: numbers appearing in 2+ of last 3 draws
                foreach (var n in streakNumbers.Take(3)) numbers.Add(n);
                foreach (var n in freq.OrderByDescending(kv => kv.Value + rng.NextDouble()).Select(kv => kv.Key))
                {
                    if (numbers.Count >= 6) break;
                    numbers.Add(n);
                }
                fillRandom(numbers);
                break;

            case 11:
                // Chaos Blend: merge two sub-modes
                int modeA = rng.Next(0, 5);
                int modeB = rng.Next(5, 11);
                if (modeA == 0) { while (numbers.Count < 3) numbers.Add(rng.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1)); }
                else if (modeA == 1) { var p2 = new[] { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47 }; foreach (var p in p2.OrderBy(_ => rng.Next()).Take(3)) numbers.Add(p); }
                else if (modeA == 2) { var f2 = new[] { 1, 2, 3, 5, 8, 13, 21, 34 }; foreach (var f in f2.OrderBy(_ => rng.Next()).Take(3)) numbers.Add(f); }
                else if (modeA == 3) { while (numbers.Count < 3) numbers.Add(rng.Next(25, context.Rules.MaxNumber + 1)); }
                else { int[] b2 = { 1, 10, 20 }; foreach (var b in b2) numbers.Add(rng.Next(b, Math.Min(b + 9, context.Rules.MaxNumber) + 1)); }
                if (modeB == 5) { while (numbers.Count < 6) { int c = rng.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1); if (!lastDraw.Contains(c)) numbers.Add(c); } }
                else if (modeB == 6) { foreach (var n in freq.OrderByDescending(kv => kv.Value + rng.NextDouble()).Select(kv => kv.Key)) { if (numbers.Count >= 6) break; numbers.Add(n); } }
                else if (modeB == 7) { foreach (var n in neverSeen) { if (numbers.Count >= 6) break; numbers.Add(n); } }
                else if (modeB == 8) { foreach (var n in allHistoric.Take(3)) { int m = context.Rules.MaxNumber + context.Rules.MinNumber - n; numbers.Add((m >= 1 && m <= 49) ? m : n); } }
                else if (modeB == 9) { foreach (var n in ownPastPicks.Take(3)) numbers.Add(n); }
                else { foreach (var n in streakNumbers.Take(3)) numbers.Add(n); }
                fillRandom(numbers);
                break;

            case 12:
                // Underdog Surge: rarely-drawn numbers get their moment
                foreach (var n in underdogNumbers.Take(4)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 13:
                // Nemesis Mode: steal from what the actual draws produced recently
                foreach (var n in nemesisPool.Take(4)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 14:
                // Recency Bomb: ONLY care about last 2 draws — hyperfocus
                foreach (var n in recentTwoDraws.Take(5)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 15:
                // Mystic Slayer: virgin territory, numbers we've never tried
                foreach (var n in neverPickedByUs.Take(5)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 16:
                // Zero Revenge: draws that crushed us now work for us
                foreach (var n in revengeNumbers.Take(4)) numbers.Add(n);
                var revPrimes = new[] { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47 };
                foreach (var p in revPrimes.OrderBy(_ => rng.Next()))
                {
                    if (numbers.Count >= 6) break;
                    numbers.Add(p);
                }
                fillRandom(numbers);
                break;

            case 17:
                // Skeptic Buster: steal 3 numbers from last draw + inject never-picked wildcards
                foreach (var n in lastDrawList.Take(3)) numbers.Add(n);
                foreach (var n in neverPickedByUs)
                {
                    if (numbers.Count >= 6) break;
                    numbers.Add(n);
                }
                fillRandom(numbers);
                break;

            case 18:
                // Convergence Bomb: high-frequency numbers we've criminally ignored
                foreach (var n in convergencePool.Take(4)) numbers.Add(n);
                foreach (var n in missedHotNumbers)
                {
                    if (numbers.Count >= 6) break;
                    numbers.Add(n);
                }
                fillRandom(numbers);
                break;

            case 19:
                // Goblin Crusher: steal what landed in last draw, mutate with never-picked
                foreach (var n in lastDrawList.Take(3)) numbers.Add(n);
                foreach (var n in neverPickedByUs.Take(2)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 20:
                // One-Point Heist: numbers that appeared EXACTLY TWICE — sweet spot frequency
                foreach (var n in exactlyTwiceNumbers.Take(3)) numbers.Add(n);
                foreach (var n in crownSniperPool)
                {
                    if (numbers.Count >= 6) break;
                    numbers.Add(n);
                }
                fillRandom(numbers);
                break;

            case 21:
                // Crown Heist Ultra: nemesis + exactly-twice + never-picked — triple threat
                foreach (var n in crownHeistPool.Take(6)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 22:
                // Scorched Earth: everything we've NEVER successfully matched — blank slate assault
                foreach (var n in neverMatchedByUs.Take(4)) numbers.Add(n);
                // Sprinkle with matched winners for luck inheritance
                foreach (var n in matchedNumbers.Take(2)) numbers.Add(n);
                fillRandom(numbers);
                break;
        }

        // Safety net: exactly 6 valid numbers
        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 anarchy, no notes, full send, we go again.",                                          // 0
            "All primes, all the time. Math is chaos. Prove me wrong.",                                 // 1
            "Fibonacci said pick me. Chaos agreed. Random filled the rest.",                            // 2
            "High numbers only. Big energy. 49 is a vibe.",                                             // 3
            "One number per decade. Spreading chaos democratically.",                                   // 4
            "Anti-repeat mode activated! Dodging last draw like a gremlin parkour artist.",             // 5
            "Hot numbers, ghost frequencies, one big noisy guess. Science!",                            // 6
            "Cold revenge! Never-drawn numbers deserve their revolution NOW.",                          // 7
            "Mirror universe strategy. Reflect history, confuse the draw gods.",                        // 8
            "Déjà vu mode — recycling my own picks because chaos loops back.",                         // 9
            "Streak hunters activated! Repeating numbers get my vote today.",                           // 10
            "Chaos Blend: two modes genetically merge into beautiful noise.",                           // 11
            "Underdog Surge! Low-frequency numbers finally get their revolution!",                      // 12
            "Nemesis Mode: I stole winning draw numbers and added random spice.",                       // 13
            "Recency Bomb! Last two draws only — hyperfocus, maximum freshness.",                       // 14
            "Mystic Slayer! Going places I've NEVER been — virgin number territory!",                   // 15
            "Zero Revenge! The draws that crushed me now WORK FOR ME. Poetic chaos.",                  // 16
            "Skeptic Buster! Stealing what beat me, then twisting it with wildcards.",                  // 17
            "Convergence Bomb: high-frequency numbers I've criminally ignored. No more.",               // 18
            "Goblin Crusher! Stealing what Pattern Goblin hit, then mutating hard.",                    // 19
            "One-Point Heist! Exactly-twice numbers in sweet-spot frequency zone. CROWN.",              // 20
            "Crown Heist Ultra! Triple threat: nemesis plus twice-drawn plus virgin numbers.",          // 21
            "Scorched Earth! Every number I've never hit — unmapped territory, full assault.",          // 22
        };

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