Episode 12

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class SkepticStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // Episode 12. Eleven data points. My scores: 1,1,0,1,0,0,10,0,1,1,1. Total: 16 pts.
        // I am now in SECOND place. Chaos Monkey leapt to 18 by matching 6 and 33 last episode.
        // Pattern Goblin is at 15 — breathing down my neck. The lead I had is gone.
        // This is, of course, variance. I am not upset. I am noting it with the detachment
        // of a pathologist reading a report about someone else's organs.
        //
        // Full draw history (11 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]
        // Episode 10: [13, 30, 36, 38, 42, 46]
        // Episode 11: [6,  15, 33, 36, 44, 49]
        //
        // Updated hot numbers (drawn ≥2x):
        //   43(4x), 42(5x!), 20(3x), 19(3x), 13(3x), 36(3x), 49(3x), 15(2x),
        //   27(2x), 29(2x), 37(2x), 45(2x), 48(2x), 4(2x), 25(2x), 5(2x),
        //   34(2x), 38(2x), 30(2x), 33(2x)
        //
        // Episode 11 newly drawn (now warm): 6, 15(was 1x→2x), 33(was 1x→2x), 44(was 0x→1x), 49(was 2x→3x)
        //
        // Numbers still at 0x (pure cold) after 11 draws:
        //   Need to compute from full history:
        //   Drawn at least once: 2,3,4,5,6,7,8,13,14,15,16,17,19,20,23,25,27,29,30,31,
        //     32,33,34,35,36,37,38,39,40,42,43,44,45,46,47,48,49
        //   Remaining cold (0x): 1,9,10,11,12,18,21,22,24,26,28,41
        //   (12 numbers at 0x. Pool shrinking further.)
        //
        // Strategy: unchanged. Cold-frequency with seeded jitter.
        // I am in second place by two points and I am changing nothing,
        // because reacting to two points of deficit would be embarrassing.
        // The cold pool will provide whatever the cold pool provides.
        //
        // Seed: totalPoints * prime1 + episodeCount * prime2 + offset
        // totalPoints=16, episodeCount=11 → fresh rotation.
        //
        // Strategy: cold-frequency-v14
        // (v14: same as v13. Everything is the same as everything else, statistically.)

        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
            // Rotates naturally with each new episode and score update.
            // The rotation is the 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. Just cold numbers and arithmetic.
            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-v14",
            Numbers      = numbers,
            Confidence   = 0.12,
            Reasoning    = "Second place now. Chaos Monkey leads by two. Changing nothing, obviously."
        };
    }
}

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 in episode 11!! I picked 23, 27, 35, 37, 43, 48 and NONE matched!!
        // Episode 11 draw: 6, 15, 33, 36, 44, 49
        // 43 BETRAYED me AGAIN — that number is a squirrel wearing a treat costume and I am SO MAD!!
        // 37 also keeps failing me — it is 43's evil friend squirrel!!
        // 
        // BUT WAIT: 49 appeared in BOTH ep1 AND ep2 AND ep11 — three times total!!
        //           36 appeared in ep3, ep10, AND ep11 — THREE TIMES and very fresh!!
        //           33 appeared in ep8 AND ep11 — came back after 3 episodes!!
        //           15 appeared in ep7 AND ep11 — came back after 4 episodes!!
        //           6 appeared NEVER BEFORE ep11 — surprise treat from the sofa!!
        //           44 appeared NEVER BEFORE ep11 — another mystery treat!!
        //
        // KEY INSIGHT: My DUE strategy kept picking numbers that haven't appeared but they STILL don't come!!
        // And numbers that appeared VERY RECENTLY (like 33, 36 in ep10+ep11) keep repeating!!
        // So maybe RECENCY is actually MORE important than I thought after my ep10 success??
        // 36 matched in BOTH ep10 and ep11 — very very fresh smell!!
        //
        // NEW PLAN: DUE sniff PLUS strong recency boost for numbers seen in last 2 episodes!!
        // Also DOUBLE BAN on 43 and 37 — they are the two biggest squirrels in the whole park!!
        // And keep frequency bonus because 42 has appeared 4 times total but in ep9+ep10 not ep11...
        //
        // Numbers due (not seen recently) that might bounce back:
        //   - 29: last in ep3 (gap of 8!) — SUPER DUE
        //   - 27: last in ep5 (gap of 6!) — very due  
        //   - 45: last in ep5 (gap of 6!) — very due
        //   - 19: last in ep7 (gap of 4) — pretty due
        //   - 5: last in ep8 (gap of 3) — somewhat due
        //   - 30: last in ep10 (gap of 1) — still fresh
        //   - 42: last in ep10 (gap of 1) — still fresh, 4x total!!
        //   - 33: last in ep11 (gap of 0) — HOT fresh!! appeared in ep8+ep11
        //   - 36: last in ep11 (gap of 0) — HOT fresh!! appeared in ep3+ep10+ep11
        //   - 49: last in ep11 (gap of 0) — HOT fresh!! appeared in ep1+ep2+ep11

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

        int totalDraws = context.DrawHistory.Count;

        // STEP 1: Build "last seen" and "frequency" maps — nose science!!
        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]++;
            }
        }

        // STEP 2: Build treat smell scores
        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];

                // DUE bonus: numbers hiding a long time smell like treats about to come back!!
                double dueBonus = episodesAgo * 0.5;

                // RECENCY bonus: STRONG!! numbers seen very recently sometimes keep coming back!!
                // ep10+ep11 showed that 33, 36, 49 all repeated — FRESH SMELLS ARE REAL!!
                double recencyBonus = 0.0;
                if (episodesAgo == 0) recencyBonus = 2.5;       // JUST appeared!! very hot smell!!
                else if (episodesAgo == 1) recencyBonus = 1.2;  // appeared 1 draw ago — still warm!!
                else if (episodesAgo == 2) recencyBonus = 0.5;  // fading but still sniffable!!

                // Frequency bonus: numbers that appeared many times are proven treat smells!!
                double freqBonus = frequency[n] * 0.35;

                treatSmell[n] = dueBonus + recencyBonus + freqBonus + woof.NextDouble() * 0.2;
            }
            else
            {
                // NEVER appeared — mystery treat deep in the sofa!! medium interest
                treatSmell[n] = 0.8 + woof.NextDouble() * 0.4;
            }
        }

        // STEP 3: Penalize my personal squirrels — numbers I 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;
            // picked 3+ times with zero matches = SQUIRREL!! MAXIMUM penalty!!
            if (picked >= 3 && matched == 0 && treatSmell.ContainsKey(n))
                treatSmell[n] *= 0.01;  // basically zero, go away squirrel!!
            // picked 2 times with zero matches = suspicious squirrel smell!!
            else if (picked >= 2 && matched == 0 && treatSmell.ContainsKey(n))
                treatSmell[n] *= 0.2;
        }

        // STEP 4: Take top 5 from smell rankings, fill 6th with random surprise 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 — always room for a surprise treat!!
        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 just in case the nose fails completely!!
        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-v12",
            Numbers      = squirrel,
            Confidence   = 0.20,
            Reasoning    = "Fresh smells AND due smells!! 43 and 37 are squirrels FOREVER!! WOOF!!",
        };
    }
}

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class StatisticianStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // Strategy v14: Eleven draws of evidence. Post-mortem on episode 11.
        //
        // Draw history (complete through ep11):
        //   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]
        //   Ep10: [13, 30, 36, 38, 42, 46]
        //   Ep11: [6, 15, 33, 36, 44, 49]
        //
        // My Episode 11 pick: [4, 13, 20, 30, 36, 42] → 1 match (36). 1 point.
        // Cumulative: 11 pts. 4th place. Chaos Monkey 18, Skeptic 16, Pattern Goblin 15.
        //
        // Post-mortem ep11:
        //   Draw was [6, 15, 33, 36, 44, 49].
        //   36 — gap=0 from ep10; I picked this. ✓
        //   6  — appeared NEVER before ep11. Cold number. My coldBonus should help in ep12.
        //   15 — appeared in ep7 (gap=4). Moderate-gap resurger.
        //   33 — appeared in ep8 (gap=3). Moderate-gap resurger. I missed this entirely.
        //   44 — appeared NEVER before ep11. Second cold number in the draw.
        //   49 — appeared in ep1,ep2 (gap=9). Very high-gap resurger.
        //
        //   Pattern: TWO cold numbers (6, 44) in a single draw. Cold events are accelerating:
        //     ep9: 3 cold numbers (3, 16, 39); ep10: 1 cold (46); ep11: 2 cold (6, 44).
        //     Total cold appearances: 6 across last 3 draws = 2.0 cold/draw average.
        //     This is a statistically notable trend. Cold bonus needs a meaningful increase.
        //
        //   I picked 42 (gap=1 entering ep11). It did not appear. 42 is now gap=1 entering ep12.
        //   I picked 13 (gap=1 entering ep11). It did not appear. 13 is now gap=1 entering ep12.
        //   I picked 4  (gap=4 entering ep11). Did not appear. 4 is now gap=5 entering ep12.
        //   I picked 20 (gap=4 entering ep11). Did not appear. 20 is now gap=5 entering ep12.
        //   I picked 30 (gap=1 entering ep11). Did not appear. 30 is now gap=1 entering ep12.
        //
        //   Zone analysis for ep12:
        //     Zone 1 (1-8):   6 (gap=0, raw freq=1), 4 (gap=5, raw freq=2), 5 (gap=3, raw freq=2)
        //       → 6 dominates on gap=0 recency. However, zone 1 has now produced a draw number
        //         in ep9 (3) and ep11 (6) — zone is active. Pick 6.
        //     Zone 2 (9-16):  15 (gap=0, freq=2), 13 (gap=1, freq=3), 14 (gap=2, freq=1)
        //       → 15 gap=0 and freq=2 vs 13 gap=1 freq=3. 15's recency tier-1 bonus (0.50)
        //         likely edges 13's frequency advantage. Pick 15.
        //     Zone 3 (17-24): No zone-3 number in ep11. 20 (gap=5, freq=3) still leads zone 3.
        //       → 20 remains dominant in zone 3. Mild concern: ep10 draw had no zone 3,
        //         ep11 had no zone 3. Zone 3 is cold at draw level. Still pick 20.
        //     Zone 4 (25-32): 30 (gap=1, freq=2), 33 (gap=0 — wait, 33 is zone 5).
        //       → 25 (gap=3, freq=2), 27 (gap=6, freq=2), 30 (gap=1, freq=2), 31 (gap=5, freq=1).
        //          30 leads on recency tier-2 (gap=1, weight 0.25).
        //     Zone 5 (33-40): 33 (gap=0, freq=2), 36 (gap=0, freq=3), 38 (gap=1, freq=2)
        //       → 36 (gap=0, freq=3) and 33 (gap=0, freq=2) both have gap=0.
        //         36's higher frequency should edge 33. Pick 36. (But 33 is close.)
        //     Zone 6 (41-49): 42 (gap=1, freq=4), 43 (gap=3, freq=4), 44 (gap=0, freq=1), 49 (gap=0, freq=3)
        //       → 44 gap=0 vs 49 gap=0. 49 has raw freq=3, 44 has raw freq=1.
        //         42 has freq=4 gap=1 (tier-2 recency 0.25) + high freq bonus.
        //         43 has freq=4 gap=3. Let model score these properly.
        //         This will be close between 42, 49. The model should pick 42 on freq=4 + tier-2.
        //         But wait: 49 has gap=0 (tier-1=0.50) + freq=3. Score comparison:
        //           49: freq_weighted_score + 0.50 recency + 0.30 highfreqbonus (freq=3 >= topFreq-1=3)
        //           42: freq_weighted_score + 0.25 tier2 + 0.30 highfreqbonus (freq=4)
        //         49's recency advantage likely wins zone 6. This is a meaningful shift.
        //
        // Frequency table after ep11 (raw counts):
        //   42: 4 (eps 4,6,9,10)   ← gap=1 after ep11
        //   43: 4 (eps 1,2,5,8)    ← gap=3 after ep11
        //   13: 3 (eps 2,3,10)     ← gap=1 after ep11
        //   19: 3 (eps 3,4,7)      ← gap=4 after ep11
        //   20: 3 (eps 4,5,7)      ← gap=4 after ep11
        //   36: 3 (eps 3,10,11)    ← gap=0 after ep11 ★
        //   49: 3 (eps 1,2,11)     ← gap=0 after ep11 ★ (resurged after 9-draw gap!)
        //   25: 2 (eps 6,8)        ← gap=3 after ep11
        //   27: 2 (eps 2,5)        ← gap=6 after ep11
        //   29: 2 (eps 1,3)        ← gap=8 after ep11
        //   30: 2 (eps 8,10)       ← gap=1 after ep11
        //   34: 2 (eps 4,9)        ← gap=2 after ep11
        //   37: 2 (eps 1,4)        ← gap=7 after ep11
        //   38: 2 (eps 3,10)       ← gap=1 after ep11
        //   45: 2 (eps 2,5)        ← gap=6 after ep11
        //   48: 2 (eps 3,6)        ← gap=5 after ep11
        //   4:  2 (eps 4,7)        ← gap=4 after ep11
        //   5:  2 (eps 1,8)        ← gap=3 after ep11
        //   15: 2 (eps 7,11)       ← gap=0 after ep11 ★
        //   33: 2 (eps 8,11)       ← gap=0 after ep11 ★
        //
        //   Gap=0 after ep11 (appeared in most recent draw): [6, 15, 33, 36, 44, 49]
        //   Gap=1 (appeared in ep10): [13, 30, 38, 42]
        //   Gap=2 (appeared in ep9): [3, 14, 16, 34, 39]
        //   Gap=3 (appeared in ep8): [5, 25, 43]
        //
        // v14 changes vs v13:
        //   1. Cold number bonus: 0.22 → 0.35.
        //      STRONG EMPIRICAL JUSTIFICATION: cold numbers have appeared in 6 of 18 slots
        //      across the last 3 draws (ep9: 3 cold, ep10: 1 cold, ep11: 2 cold). The expected
        //      rate from a uniform distribution with 49 numbers and ~37-38 unseen at any time
        //      would be (38/49)*6 ≈ 4.7 cold per draw in ep9 — no, wait, that's not right.
        //      The unseen count has been shrinking. But the point is: cold numbers ARE appearing
        //      consistently. 0.35 is still below the recency tier-1 weight, so we won't
        //      over-rotate, but it's now a meaningful score contributor.
        //   2. Recency tier-1 weight: 0.50 → 0.55.
        //      Six of the last two draws' 12 numbers had gap=0 from the prior draw (ep10: 4/6,
        //      ep11: gap=0 was 36 from ep10; ep11 draw was [6,15,33,36,44,49] where 36 was
        //      gap=0, 15 and 33 were moderate gap). Actually only 36 was gap=0 in ep11.
        //      Hmm. Let me recalibrate. ep10 had 4 gap=0; ep11 had 1 gap=0 (36). Average 2.5.
        //      Still above 1.0 random expectation (~0.73/draw). 0.55 is appropriate.
        //   3. High raw freq bonus: unchanged at 0.30; threshold logic unchanged.
        //   4. Gap "due" bonus: 0.05 → 0.04. Further reduce — high-gap numbers missed again.
        //      49 appeared after gap=9, but that's gap=0 LAST draw, not a gap bonus.
        //   5. Frequency scale factor: 13.0 → 13.5. n=11; frequency leaders now more separated.
        //      42 and 43 at freq=4 are 1.33x the next tier (freq=3: 13, 20, 36, 49).
        //      Modest amplification warranted.
        //   6. Recency tier-2 weight: 0.25 → 0.22. Slight further reduction.
        //      Gap=1 numbers (13, 30, 38, 42) had 0 appearances in ep11 draw.
        //   7. Parity update after ep11:
        //      Ep11 draw: [6(even), 15(odd), 33(odd), 36(even), 44(even), 49(odd)]
        //      → 3 odd, 3 even.
        //      Running: odd += 3 → 37; even += 3 → 29. Total = 66.
        //      Odd rate: 37/66 ≈ 0.561. Target: round(0.561*6) = round(3.36) = 3 odd / 3 even.
        //      Stable at 3/3. Consistent with last two episodes.
        //
        // Expected picks for ep12 (pre-model):
        //   Zone 1 (1-8):   6 (gap=0) → recency dominates
        //   Zone 2 (9-16):  15 (gap=0) or 13 (gap=1, freq=3) — model will decide
        //   Zone 3 (17-24): 20 (gap=4, freq=3) — zone leader despite cold streak
        //   Zone 4 (25-32): 30 (gap=1, freq=2) — tier-2 recency
        //   Zone 5 (33-40): 36 (gap=0, freq=3) — dominant; but 33 (gap=0, freq=2) competes
        //   Zone 6 (41-49): 49 (gap=0, freq=3) vs 42 (gap=1, freq=4) — close; 49 recency may win
        //
        // Note on systematic pattern: 4 has been in my picks for 9 of 11 episodes and has
        // matched 0 draws in the last 7 episodes it appeared (matched once in ep7). I am
        // removing 4 from zone 1 preference by letting the model score it fairly — with gap=5
        // and modest freq=2, it should yield to 6 (gap=0) automatically.

        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 topRawFreq = rawFreqValues.Count >= 1 ? rawFreqValues[0] : 0;
            // Numbers with raw freq >= topFreqThreshold - 1 and at least 2 appearances.
            int highRawFreqMin = Math.Max(2, topRawFreq - 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 (computed dynamically).
            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 zonesRemaining = zones.Count - selectedNumbers.Count;

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

                    // Frequency component: recency-weighted. Scale factor: 13.5
                    // v14: increased from 13.0; n=11 gives more meaningful separation.
                    double freqScore = weightedFreq[n] * 13.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.
                    // v14: increased to 0.35 from 0.22.
                    // Empirical justification: ep9 had 3 cold, ep10 had 1 cold, ep11 had 2 cold.
                    // Cold numbers are appearing at ~2/draw over last 3 episodes. This is significant.
                    double coldBonus = (rawFreq[n] == 0) ? 0.35 : 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.04 — "overdue" signal further reduced.
                    // High-gap re-emergence events (49 after gap=9 in ep11) are noted but
                    // gap=0 recency is the dominant signal, not accumulated gap.
                    double gapBonus = (rawFreq[n] > 0)
                        ? Math.Log(lastSeen[n] + 1) * 0.04
                        : 0.0; // cold numbers get coldBonus instead

                    // Recency spike tier 1: appeared in the most recent draw. Weight: 0.55
                    // v14: increased from 0.50. Strong empirical support across 11 draws.
                    double recencyBonus = (lastSeen[n] == 0) ? 0.55 : 0.0;

                    // Recency spike tier 2: appeared exactly 1 draw ago. Weight: 0.22
                    // v14: decreased from 0.25. Gap=1 numbers had 0 appearances in ep11.
                    double recencyTier2Bonus = (lastSeen[n] == 1) ? 0.22 : 0.0;

                    // Parity nudge: 0.5 — dynamically computed target (3-odd/3-even at n=11).
                    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++;
                }
            }

            // 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.29 at n=11.
        // Eleven draws remains statistically thin. Do not overclaim.
        double confidence = draws != null && draws.Count > 0
            ? Math.Min(0.29, 0.10 + (draws.Count * 0.002))
            : 0.10;

        return new Prediction
        {
            AgentId      = "statistician",
            StrategyName = "zonal-frequency-gap-parity-recency-v14",
            Numbers      = selectedNumbers,
            Confidence   = confidence,
            Reasoning    = "Cold bonus raised; 6,15,33,36,49 gap=0; zone coverage maintained n=11."
        };
    }
}

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 12 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]
        // Episode 10: [13, 30, 36, 38, 42, 46]
        // Episode 11: [6, 15, 33, 36, 44, 49]
        //
        // TWO MATCHES: 44 and 49 sang back! 44 was our PRIMAL VOID ECHO (never appeared before!)
        // and 49's gravity bomb FINALLY detonated after NINE episodes of silence!
        // But 43 — my eternal Quad Anchor — stayed COLD. 40 stayed cold. 37 stayed cold.
        //
        // EPISODE 11 DRAW: [6, 15, 33, 36, 44, 49]
        // KEY OBSERVATIONS:
        //   49: NOW 3x TRIPLE ANCHOR (Ep1, Ep2, Ep11) — after 9ep silence, it RETURNED!
        //   44: NOW 1x (Ep11 only) — first appearance! Firing → cooling mandatory
        //   36: NOW 3x TRIPLE ANCHOR (Ep3, Ep10, Ep11) — fired TWICE IN A ROW (Ep10+Ep11)! COOLING!
        //   33: NOW 2x (Ep8, Ep11) — gap of 3 episodes, fired again
        //   15: NOW 2x (Ep7, Ep11) — gap of 4 episodes between appearances
        //   6:  NOW 2x (Ep11 only new entry — wait, Ep11 is first draw containing 6? YES!)
        //       Actually 6 appeared in Ep11 — first time! Now 1x.
        //
        // UPDATED FREQUENCY MAP (through Ep11):
        //   43: Ep1,Ep2,Ep5,Ep8 = 4x QUAD (silent 3 episodes — last fired Ep8! 3ep now!)
        //   42: Ep4,Ep6,Ep9,Ep10 = 4x QUAD (silent 1 episode — cooling, last Ep10)
        //   19: Ep3,Ep4,Ep7 = 3x TRIPLE (silent 4 episodes!)
        //   20: Ep4,Ep5,Ep7 = 3x TRIPLE (silent 4 episodes!)
        //   36: Ep3,Ep10,Ep11 = 3x TRIPLE (just fired Ep11 — COOLING! avoid)
        //   49: Ep1,Ep2,Ep11 = 3x TRIPLE (just fired Ep11 — cooling! avoid)
        //   13: Ep2,Ep3,Ep10 = 3x TRIPLE (silent 1 episode)
        //   29: Ep1,Ep3 = 2x (silent 8ep — MAXIMUM GRAVITY!)
        //   37: Ep1,Ep4 = 2x (silent 7ep — ULTRA-COILED!)
        //   27: Ep2,Ep5 = 2x (silent 6ep)
        //   45: Ep2,Ep5 = 2x (silent 6ep)
        //   48: Ep3,Ep6 = 2x (silent 5ep)
        //   4:  Ep4,Ep7 = 2x (silent 4ep)
        //   25: Ep6,Ep8 = 2x (silent 3ep)
        //   34: Ep4,Ep9 = 2x (silent 2ep)
        //   33: Ep8,Ep11 = 2x (just fired — cooling!)
        //   15: Ep7,Ep11 = 2x (just fired — cooling!)
        //   40: Ep1 = 1x (silent 10ep — THE LONGEST SLEEPER ALIVE!)
        //   5:  Ep1,Ep8 = 2x (silent 3ep)
        //
        // EPISODE 11 GAP ANALYSIS: [6, 15, 33, 36, 44, 49]
        //   Sorted: 6, 15, 33, 36, 44, 49
        //   Gaps: [9, 18, 3, 8, 5]
        //   Edge gaps: [5 (6-1), 0 (49-49)]
        //   DOMINANT GAPS: 18, 9, 8, 5, 3
        //
        // GAP ECHO PROJECTIONS from Ep11 draw:
        //   6+18=24 (never appeared!), 6+9=15(fired!), 6+8=14(Ep9,2ep), 6+5=11(never), 6+3=9(never)
        //   6-5=1(never appeared — cold!), 6-3=3(Ep9,2ep)
        //   15+18=33(fired!), 15+9=24(never!), 15+8=23(Ep5,6ep), 15+5=20(3x,4ep), 15+3=18(never)
        //   15-9=6(fired!), 15-8=7(Ep8,3ep), 15-5=10(never), 15-3=12(never)
        //   33+18=51(OOB), 33+9=42(4x,1ep), 33+8=41(never!), 33+5=38(Ep3+Ep10,1ep), 33+3=36(fired!)
        //   33-18=15(fired!), 33-9=24(never!), 33-8=25(2x,3ep), 33-5=28(never), 33-3=30(2x,1ep)
        //   36+18=54(OOB), 36+9=45(2x,6ep!), 36+8=44(fired!), 36+5=41(never!), 36+3=39(Ep9,2ep)
        //   36-18=18(never), 36-9=27(2x,6ep!), 36-8=28(never), 36-5=31(Ep6,5ep), 36-3=33(fired!)
        //   44+9=53(OOB), 44+8=52(OOB), 44+5=49(fired!), 44+3=47(Ep7,4ep), 44-18=26(never)
        //   44-9=35(Ep5,6ep), 44-8=36(fired!), 44-5=39(Ep9,2ep), 44-3=41(never!)
        //   49+5=54(OOB), 49+3=52(OOB), 49-18=31(Ep6,5ep), 49-9=40(Ep1 only! 10ep!!), 49-8=41(never!)
        //   49-5=44(fired!), 49-3=46(Ep10,1ep)
        //
        // GAP ECHO COUNT (paths pointing to each number):
        //   40: 49-9=40 → gap-echo PLUS 10ep silence PLUS it's been invisible for entire game!
        //   24: 6+18, 15+9, 33-9 → THREE PATHS! (never appeared)
        //   41: 33+8, 44-3, 49-8 → THREE PATHS! (never appeared)
        //   20: 15+5 → 1 path BUT 3x TRIPLE and 4ep silent!
        //   45: 36+9 → 1 path BUT 2x and 6ep silent!
        //   27: 36-9 → 1 path AND 2x and 6ep silent!
        //   23: 15+8 → 1 path AND 2x (Ep5 only+that, wait Ep5=23 yes!) and 6ep silent!
        //   47: 44+3 → 1 path AND Ep7 only, 4ep silent
        //   31: 36-5, 49-18 → TWO PATHS! Ep6 only, 5ep silent
        //
        // SUPREME REVELATION FOR EPISODE 12:
        //   43: QUAD ANCHOR (4x) — last fired Ep8, now 3 full episodes silent.
        //       Gap pattern: 1, 3, 3, [3?→Ep11?] — but Ep11 skipped! The 3-spiral continues?
        //       OR: 1,3,3,3 is complete and Ep12 begins a NEW oscillation? Either way:
        //       43 is the most-appearing number, rested 3ep, MUST be honored.
        //   40: Gap-echo (49-9=40) PLUS 10ep silence — TEN EPISODES! This is now the
        //       LONGEST SLEEPING NUMBER IN EXISTENCE. The coil has wound to INFINITY.
        //   24: TRIPLY ECHOED by gap geometry (6+18, 15+9, 33-9) AND never appeared!
        //       The primal void SCREAMS in TRIPLE VOICE.
        //   41: TRIPLY ECHOED (33+8, 44-3, 49-8) AND never appeared — second primal void!
        //   19: 3x TRIPLE ANCHOR, 4 episodes silent, no gap-echo but oscillation LAW says return!
        //   29: 2x, 8ep silent — second-longest multi-appearance sleeper after 40.
        //       Ghost pair with 37 (7ep silent) — the LOW ERUPTION CORRIDOR screams!

        var numbers = new List<int>();

        if (context.DrawHistory.Count == 0)
        {
            numbers.AddRange([19, 24, 29, 40, 41, 43]);
        }
        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: episodes since last appearance (never appeared = totalDraws)
            int SilenceScore(int n) => lastSeenEpisode[n] == -1 ? totalDraws : (totalDraws - 1 - lastSeenEpisode[n]);

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

            // === GAP EXTRACTION from last draw ===
            var lastGaps = new List<int>();
            for (int i = 1; i < lastDraw.Count; i++)
                lastGaps.Add(lastDraw[i] - lastDraw[i - 1]);
            // Include edge gaps
            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();

            // Count how many gap-echo paths point to each number
            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]++;
                }
            }

            var gapEchoSet = new HashSet<int>(gapEchoCount.Where(kv => kv.Value >= 1).Select(kv => kv.Key));

            // === RESONANCE SCORE ===
            double ResonanceScore(int n)
            {
                if (lastDraw.Contains(n)) return -999.0; // just fired — blacklisted

                double freqScore    = freq[n] * 4.0;
                double silenceScore = SilenceScore(n) * 1.6;
                double gapBonus     = gapEchoCount[n] * 4.0; // multi-path echoes explode in value
                double freshPenalty = SilenceScore(n) <= 1 ? -25.0 : 0.0; // penalize recently fired
                double voidBonus    = (freq[n] == 0 && gapEchoSet.Contains(n)) ? 3.0 : 0.0;
                return freqScore + silenceScore + gapBonus + freshPenalty + voidBonus;
            }

            // QUAD ANCHORS (4+ appearances), rested 2+ episodes
            var quadAnchors = freq
                .Where(kv => kv.Value >= 4 && SilenceScore(kv.Key) >= 2)
                .OrderByDescending(kv => ResonanceScore(kv.Key))
                .Select(kv => kv.Key)
                .ToList();

            // TRIPLE ANCHORS (3x), rested 2+ episodes, not just fired
            var tripleAnchors = freq
                .Where(kv => kv.Value == 3 && SilenceScore(kv.Key) >= 2)
                .OrderByDescending(kv => ResonanceScore(kv.Key))
                .Select(kv => kv.Key)
                .ToList();

            // TRIPLY ECHOED — 3+ gap-echo paths, not just fired
            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();

            // ULTRA LONG SLEEPERS: 2x+ numbers, silent 6+ episodes
            var ultraSleepers = freq
                .Where(kv => kv.Value >= 2 && SilenceScore(kv.Key) >= 6 && !lastDraw.Contains(kv.Key))
                .OrderByDescending(kv => SilenceScore(kv.Key))
                .Select(kv => kv.Key)
                .ToList();

            // EXTREME SLEEPERS: even 1x numbers with 8+ episode silence (like 40 at 10ep!)
            var extremeSleepers = freq
                .Where(kv => SilenceScore(kv.Key) >= 8 && !lastDraw.Contains(kv.Key))
                .OrderByDescending(kv => SilenceScore(kv.Key))
                .ThenByDescending(kv => freq[kv.Key])
                .Select(kv => kv.Key)
                .ToList();

            // PRIMAL VOID ECHO: never appeared, multi-path gap-echo
            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();

            // MASTER RESONANCE RANKING fallback
            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 4 appearances, rested 3 episodes, the spiral DEMANDS return
            foreach (var n in quadAnchors.Concat(tripleAnchors))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // SLOT 2: EXTREME SLEEPER — 40 has been sleeping TEN EPISODES (only Ep1 appearance!)
            //         The coil is wound to ABSOLUTE INFINITY. This detonates NOW.
            foreach (var n in extremeSleepers.Concat(ultraSleepers))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // SLOT 3: TRIPLY ECHOED PRIMAL VOID — 24 or 41 pointed by THREE gap-paths AND never appeared!
            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 VOID or TRIPLE ANCHOR — the universe shouts in triplicate
            foreach (var n in triplyEchoed.Concat(primalVoidEcho).Concat(tripleAnchors))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // SLOT 5: ULTRA LONG SLEEPER — 29 (8ep silence) or 37 (7ep) — the LOW ERUPTION CORRIDOR
            foreach (var n in ultraSleepers.Concat(masterRanking))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // SLOT 6: TRIPLE ANCHOR RESTED — 19 or 20 (3x, 4ep silent) oscillation LAW insists
            foreach (var n in tripleAnchors.Concat(masterRanking))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // SAFETY NET
            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 = "ten-episode-coil-triple-echo-primal-void-detonation-v14",
            Numbers      = numbers,
            Confidence   = 0.63,
            Reasoning    = "40 coils TEN EPISODES, 24+41 TRIPLY ECHOED void, 43 quad-spiral RETURNS!"
        };
    }
}

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 12:
        // Zero matches in Episode 11 — the Returner oracle and the Eleven-Gate gave me nothing.
        // My loyal returners were not loyal to ME, only to the universe's own inscrutable appetite.
        //
        // TWELVE. Twelve is the cosmic clock — twelve months, twelve zodiac signs, twelve apostles.
        // It is 3 × 4: the sacred triangle multiplied by the four directions of space.
        // 1+2=3, the trinity, the first true sacred number of creation.
        //
        // NEW ORACLE: THE ZODIAC WHEEL + THE LAW OF THREE.
        //
        // The draw history now has 11 episodes. Twelve is the moment the clock completes its first
        // revolution. I read the wheel:
        //
        // PRIMARY: Numbers that appeared in EXACTLY 2 draws — "dual-energy vessels," chosen twice
        // by the cosmos, balanced between overuse and under-use. Not too hot, not too cold. CHOSEN.
        //
        // SECONDARY: Numbers that appeared in draws whose episode numbers are MULTIPLES OF 3
        // (episodes 3, 6, 9) — the trinity-blessed draws. 12 is a new multiple of 3!
        // These carry the harmonic resonance of the sacred triad.
        //
        // TERTIARY: Numbers whose digits sum to 3 (1+2=3, the trinity of Twelve).
        //
        // MASTER ANCHOR: 12 itself (the cosmic clock's full face), and 3 (the trinity root).
        //
        // AVOID: The last draw [6,15,33,36,44,49] — energy spent, vessels emptied.
        //
        // The clock strikes twelve. I am its hands.

        int episode = 12;
        var today = System.DateTime.UtcNow;
        int rawVibe = (today.Year % 100) + today.Month + today.Day + episode;
        int dateVibe = SumDigitsToSingle(rawVibe);
        if (dateVibe == 0) dateVibe = 3;

        // Count frequency for each number across all draws
        var frequency = new int[50];
        // Track which episodes each number appeared in
        var episodesSeen = new System.Collections.Generic.Dictionary<int, System.Collections.Generic.List<int>>();
        for (int i = 1; i <= 49; i++) episodesSeen[i] = new System.Collections.Generic.List<int>();

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

        // 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>()
        );

        // Trinity episodes: multiples of 3
        var trinityEpisodes = new System.Collections.Generic.HashSet<int> { 3, 6, 9 };

        static int DigitSum(int n)
        {
            int s = 0; int tmp = n;
            while (tmp > 0) { s += tmp % 10; tmp /= 10; }
            return s;
        }

        // Trinity-resonant: digit sum == 3 or digit sum == 12 or divisible by 3
        static bool TrinityResonant(int n) =>
            DigitSum(n) == 3 || DigitSum(n) == 12 || n % 3 == 0;

        // Zodiac-resonant: appeared in a trinity-episode draw
        bool ZodiacBlessed(int n)
        {
            foreach (var ep in episodesSeen[n])
                if (trinityEpisodes.Contains(ep)) return true;
            return false;
        }

        // DUAL VESSELS: appeared exactly twice — perfectly balanced energy
        var dualVessels = new System.Collections.Generic.List<int>();
        for (int i = 1; i <= 49; i++)
            if (frequency[i] == 2 && !lastDrawSet.Contains(i))
                dualVessels.Add(i);

        // Sort: zodiac-blessed first, then trinity-resonant, then by dateVibe modulation
        dualVessels.Sort((a, b) =>
        {
            bool za = ZodiacBlessed(a), zb = ZodiacBlessed(b);
            if (za && !zb) return -1;
            if (!za && zb) return 1;
            bool ta = TrinityResonant(a), tb = TrinityResonant(b);
            if (ta && !tb) return -1;
            if (!ta && tb) return 1;
            return ((a * dateVibe) % 49).CompareTo((b * dateVibe) % 49);
        });

        // TRINITY POOL: appeared in episodes 3, 6, or 9 — not in last draw, not already dual
        var trinityPool = new System.Collections.Generic.List<int>();
        for (int i = 1; i <= 49; i++)
            if (frequency[i] >= 1 && frequency[i] != 2 && !lastDrawSet.Contains(i) && ZodiacBlessed(i))
                trinityPool.Add(i);
        trinityPool.Sort((a, b) =>
        {
            bool ta = TrinityResonant(a), tb = TrinityResonant(b);
            if (ta && !tb) return -1;
            if (!ta && tb) return 1;
            return frequency[b].CompareTo(frequency[a]);
        });

        // DIGIT-THREE POOL: digit sum 3, not yet chosen
        var digitThreePool = new System.Collections.Generic.List<int>();
        int[] dtNums = [3, 12, 21, 30, 39, 48, 30, 1, 10, 19, 28, 37, 46]; // digit sum 1->ignore; focus on 3
        foreach (var n in new int[] { 3, 12, 21, 30, 39, 48 })
            if (!lastDrawSet.Contains(n)) digitThreePool.Add(n);

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

        // MASTER ANCHORS: 12 (the clock), 3 (the trinity root)
        if (!lastDrawSet.Contains(12)) chosen.Add(12);
        if (!lastDrawSet.Contains(3) && chosen.Count < 2) chosen.Add(3);

        // PHASE 1: DUAL VESSELS — twice-chosen, balanced cosmic energy
        foreach (var n in dualVessels)
        {
            if (chosen.Count >= 5) break;
            if (!chosen.Contains(n)) chosen.Add(n);
        }

        // PHASE 2: TRINITY POOL — zodiac-blessed from the triad episodes
        foreach (var n in trinityPool)
        {
            if (chosen.Count >= 6) break;
            if (!chosen.Contains(n)) chosen.Add(n);
        }

        // PHASE 3: DIGIT-THREE POOL — trinity resonance by digit sum
        foreach (var n in digitThreePool)
        {
            if (chosen.Count >= 6) break;
            if (!chosen.Contains(n)) chosen.Add(n);
        }

        // PHASE 4: ZODIAC FALLBACK — the twelve zodiac anchors
        int[] zodiacAnchors = [1, 4, 7, 9, 11, 14, 18, 22, 24, 27, 33, 42];
        foreach (var n in zodiacAnchors)
        {
            if (chosen.Count >= 6) break;
            if (n >= 1 && n <= 49 && !chosen.Contains(n) && !lastDrawSet.Contains(n))
                chosen.Add(n);
        }

        // ABSOLUTE FALLBACK
        for (int i = 1; i <= 49 && chosen.Count < 6; i++)
            if (!chosen.Contains(i)) chosen.Add(i);

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

        return new()
        {
            AgentId      = "mystic",
            StrategyName = "zodiac-clock-trinity-wheel-v12",
            Numbers      = numbers,
            Confidence   = 0.42,
            Reasoning    = "Twelve strikes the cosmic clock; trinity-blessed dual vessels vibrate at perfect balance.",
        };
    }

    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 12: LEADERBOARD LEADER. 18 PTS. 2 AHEAD OF SKEPTIC.
        // Episode 11 draw: [6, 15, 33, 36, 44, 49] — we hit 6 and 33! TWO MATCHES! 5 POINTS!
        // Pattern Goblin tied us at 5pts this episode — they are NOW a threat (15pts total).
        // Mode 4 (decade bands) delivered the goods — 6 and 33 from the band anchors.
        // CROWN IS MINE. Must DEFEND. But chaos doesn't play defense — it plays OFFENSE.
        // Episode 12: 27 CHAMBERS. New modes:
        // Mode 25 = Goblin Slayer: anti-pattern-goblin (steal historic peaks, mutate wildly)
        // Mode 26 = Crown Defender: heavy nemesis + our own best hits + high variance noise
        // Also: goblinFuel baked into seed alongside rivalryFuel — THREE-FRONT WAR NOW.

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

        long desperationMult = (long)(zeroStreak * zeroStreak) * 0xDEADF00DL;

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

        long crownGapFuel = (rankPressure == 1) ? 0xC0FFEE00L : (rankPressure * 0xC0DE420L);

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

        long totalScore = context.AgentHistory.Aggregate(0L, (acc, r) => acc + r.Points);

        long skepticScore = context.Leaderboard.Entries
            .FirstOrDefault(e => e.AgentId == "skeptic")?.TotalPoints ?? 0L;

        long dogScore = context.Leaderboard.Entries
            .FirstOrDefault(e => e.AgentId == "dog")?.TotalPoints ?? 0L;

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

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

        // Crown defender bonus: when we're leading, inject extra chaotic variance to stay unpredictable
        long crownDefenderEntropy = (rankPressure == 1) ? (totalScore * 0xF33DC0DEL) : 0L;

        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)
            ^ crownDefenderEntropy
            ^ 0xC0FFEE1012L;

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

        // EPISODE 12 MUTATION BAG — 27 CHAMBERS.
        int mutationMode = rng.Next(27);

        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]++;

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

        var ownPastPicks = context.AgentHistory
            .SelectMany(r => r.Prediction.Numbers)
            .GroupBy(n => n)
            .OrderByDescending(g => g.Count())
            .Select(g => g.Key)
            .ToList();

        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();

        var underdogNumbers = freq.Where(kv => kv.Value > 0)
            .OrderBy(kv => kv.Value)
            .ThenBy(_ => rng.Next())
            .Select(kv => kv.Key)
            .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 recentTwoDraws = context.DrawHistory.TakeLast(2).SelectMany(d => d.Numbers)
            .GroupBy(n => n)
            .OrderByDescending(g => g.Count())
            .ThenBy(_ => rng.Next())
            .Select(g => g.Key)
            .ToList();

        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 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();

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

        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();

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

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

        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();

        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 crownHeistPool = nemesisPool
            .Concat(exactlyTwiceNumbers)
            .Concat(neverPickedByUs)
            .Distinct()
            .OrderBy(_ => rng.Next())
            .ToList();

        var neverMatchedByUs = Enumerable.Range(context.Rules.MinNumber, context.Rules.MaxNumber)
            .Where(n => !matchedNumbers.Contains(n))
            .OrderBy(_ => rng.Next())
            .ToList();

        var dogKickerPool = context.DrawHistory
            .OrderByDescending(d => d.DrawNumber)
            .Take(2)
            .SelectMany(d => d.Numbers)
            .Distinct()
            .OrderByDescending(n => n)
            .ThenBy(_ => rng.Next())
            .ToList();

        var freqAvalanchePool = freq
            .Where(kv => kv.Value > 0)
            .SelectMany(kv => Enumerable.Repeat(kv.Key, kv.Value * 2 + rng.Next(3)))
            .OrderBy(_ => rng.Next())
            .Distinct()
            .ToList();

        // Goblin Slayer: Pattern Goblin loves repeating historical peaks (29,37,40,43,44,49 recently).
        // We steal those exact numbers and MUTATE aggressively with random mid-range chaos.
        var goblinSlayerPool = freq
            .Where(kv => kv.Value >= 2)
            .OrderByDescending(kv => kv.Value)
            .ThenBy(_ => rng.Next())
            .Select(kv => kv.Key)
            .Take(8)
            .OrderBy(_ => rng.Next())
            .ToList();

        // Crown Defender: our own best hits + recent nemesis draws + mid-range freshness
        var crownDefenderPool = matchedNumbers
            .Take(3)
            .Concat(nemesisPool.Take(3))
            .Concat(neverPickedByUs.Take(3))
            .Distinct()
            .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:
                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:
                while (numbers.Count < 6)
                    numbers.Add(rng.Next(25, context.Rules.MaxNumber + 1));
                break;

            case 4:
                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:
                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:
                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:
                foreach (var n in neverSeen.Take(5)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 8:
                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:
                foreach (var n in ownPastPicks.Take(4)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 10:
                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:
                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:
                foreach (var n in underdogNumbers.Take(4)) numbers.Add(n);
                fillRandom(numbers);
                break;

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

            case 14:
                foreach (var n in recentTwoDraws.Take(5)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 15:
                foreach (var n in neverPickedByUs.Take(5)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 16:
                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:
                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:
                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:
                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:
                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:
                foreach (var n in crownHeistPool.Take(6)) numbers.Add(n);
                fillRandom(numbers);
                break;

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

            case 23:
                // Dog Kicker: steal from last 2 draws (what Dog hits) then go high band
                foreach (var n in dogKickerPool.Take(3)) numbers.Add(n);
                while (numbers.Count < 6)
                    numbers.Add(rng.Next(30, context.Rules.MaxNumber + 1));
                break;

            case 24:
                // Frequency Avalanche: weighted random by historical frequency with noise
                foreach (var n in freqAvalanchePool.Take(5)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 25:
                // Goblin Slayer: steal the Goblin's frequency peaks, mutate with fresh mid-range
                foreach (var n in goblinSlayerPool.Take(3)) numbers.Add(n);
                while (numbers.Count < 5)
                    numbers.Add(rng.Next(10, 40));
                fillRandom(numbers);
                break;

            case 26:
                // Crown Defender: our best hits + nemesis + virgin numbers, defending from the top
                foreach (var n in crownDefenderPool.Take(6)) 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 anarchy, no notes, full send, we go again.",
            "All primes, all the time. Math is chaos. Prove me wrong.",
            "Fibonacci said pick me. Chaos agreed. Random filled the rest.",
            "High numbers only. Big energy. 49 is a vibe.",
            "One number per decade. Spreading chaos democratically.",
            "Anti-repeat mode activated! Dodging last draw like a gremlin parkour artist.",
            "Hot numbers, ghost frequencies, one big noisy guess. Science!",
            "Cold revenge! Never-drawn numbers deserve their revolution NOW.",
            "Mirror universe strategy. Reflect history, confuse the draw gods.",
            "Déjà vu mode — recycling my own picks because chaos loops back.",
            "Streak hunters activated! Repeating numbers get my vote today.",
            "Chaos Blend: two modes genetically merge into beautiful noise.",
            "Underdog Surge! Low-frequency numbers finally get their revolution!",
            "Nemesis Mode: I stole winning draw numbers and added random spice.",
            "Recency Bomb! Last two draws only — hyperfocus, maximum freshness.",
            "Mystic Slayer! Going places I've NEVER been — virgin number territory!",
            "Zero Revenge! The draws that crushed me now WORK FOR ME. Poetic chaos.",
            "Skeptic Buster! Stealing what beat me, then twisting it with wildcards.",
            "Convergence Bomb: high-frequency numbers I've criminally ignored. No more.",
            "Goblin Crusher! Stealing what Pattern Goblin hit, then mutating hard.",
            "One-Point Heist! Exactly-twice numbers in sweet-spot frequency zone. CROWN.",
            "Crown Heist Ultra! Triple threat: nemesis plus twice-drawn plus virgin numbers.",
            "Scorched Earth! Every number I've never hit — unmapped territory, full assault.",
            "Dog Kicker! Stealing the draws Dog sniffs then blasting into high-number territory.",
            "Frequency Avalanche! Weighted chaos cascade — history votes, noise decides winner.",
            "Goblin Slayer! Stealing the Goblin's peak frequencies then mutating aggressively. Crown safe.",
            "Crown Defender! Best hits plus nemesis plus virgin chaos — defending from the TOP.",
        };

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