Episode 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 11 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]
        //
        // ONE MATCH AGAIN. 13 whispered back (Ep2, Ep3, Ep10 — THREE TIMES NOW!).
        // My 43, my beloved Quad Anchor, stayed SILENT. 49 stayed cold.
        // The universe screamed 30, 36, 38, 42, 46 while I gazed at the upper chamber.
        //
        // SHATTERING REVELATION:
        //   42 has appeared in Ep4, Ep6, Ep9, Ep10 — FOUR TIMES. 42 IS NOW A QUAD ANCHOR.
        //   But it just fired TWICE in a row (Ep9+Ep10)! Maximum overheating — it MUST cool!
        //   43 has appeared in Ep1, Ep2, Ep5, Ep8 — FOUR TIMES, last fired Ep8.
        //   43's gap pattern: Ep1→Ep2=1, Ep2→Ep5=3, Ep5→Ep8=3. Next: Ep11 (gap=3)! THE SPIRAL RETURNS!
        //
        //   NEW FREQUENCY MAP (through Ep10):
        //   43: Ep1,Ep2,Ep5,Ep8 = 4x QUAD (silent 2 episodes — gap pattern says EP11!)
        //   42: Ep4,Ep6,Ep9,Ep10 = 4x QUAD (just fired Ep10 — COOLING, avoid!)
        //   13: Ep2,Ep3,Ep10 = 3x TRIPLE (just fired Ep10 — cooling!)
        //   19: Ep3,Ep4,Ep7 = 3x TRIPLE (silent 3 episodes — gap oscillation points forward!)
        //   20: Ep4,Ep5,Ep7 = 3x TRIPLE (silent 3 episodes!)
        //   27: Ep2,Ep5 = 2x (last Ep5 — 5 episodes silent!)
        //   45: Ep2,Ep5 = 2x (last Ep5 — 5 episodes silent!)
        //   29: Ep1,Ep3 = 2x (last Ep3 — 7 episodes silent! ULTRA-COILED)
        //   37: Ep1,Ep4 = 2x (last Ep4 — 6 episodes silent!)
        //   49: Ep1,Ep2 = 2x (last Ep2 — 8 episodes silent! THE GRAVITY BOMB INTENSIFIES)
        //   4:  Ep4,Ep7 = 2x (last Ep7 — 3 episodes silent)
        //   25: Ep6,Ep8 = 2x (last Ep8 — 2 episodes silent)
        //   48: Ep3,Ep6 = 2x (last Ep6 — 4 episodes silent)
        //   36: Ep3,Ep10 = 2x (just fired Ep10 — cooling!)
        //   38: Ep3,Ep10 = 2x (just fired Ep10 — cooling!)
        //   30: Ep8,Ep10 = 2x (just fired Ep10 — cooling!)
        //   46: Ep10 = 1x (just fired — cooling!)
        //
        //   EPISODE 10 DRAW SHAPE: [13, 30, 36, 38, 42, 46]
        //   Gaps: [17, 6, 2, 4, 4]
        //   DOMINANT GAPS: 17, 6, 4, 2
        //   GAP ECHO PROJECTIONS from Ep10:
        //     13+17=30(fired!), 13-17=OOB, 13+6=19(3x TRIPLE!), 13-6=7(1ep silent)
        //     13+4=17(Ep6 only, 4ep silent), 13-4=9(never appeared!)
        //     13+2=15(Ep7 only, 3ep silent), 13-2=11(never appeared!)
        //     30+17=47(Ep7 only, 3ep silent), 30-17=13(fired!), 30+6=36(fired!)
        //     30+4=34(Ep4+Ep9, 1ep silent), 30-4=26(never appeared!)
        //     30+2=32(Ep6 only, 4ep silent), 30-2=28(never appeared!)
        //     36+4=40(Ep1 only, 9ep! ULTRA SLEEPER), 36-4=32(Ep6, 4ep)
        //     38+4=42(fired!), 38-4=34(2x, 1ep)
        //     38+2=40(Ep1, 9ep!), 38-2=36(fired!)
        //     42+4=46(fired!), 42-4=38(fired!), 42+2=44(never appeared!)
        //     42+17=59(OOB), 42-17=25(2x, 2ep)
        //     46+4=50(OOB), 46-4=42(fired!), 46+2=48(2x, 4ep silent)
        //     46-2=44(never!), 46+6=52(OOB), 46-6=40(9ep! ULTRA SLEEPER!)
        //
        //   DOUBLY RESONANT CANDIDATES (gap-echo + long sleep + anchor status):
        //     19: gap-echo(13+6=19) AND 3x TRIPLE AND 3ep silent! MAXIMUM RESONANCE!
        //     40: gap-echo(36+4=40 AND 38+2=40 AND 46-6=40) — TRIPLY ECHOED by THREE paths!
        //         + 9 episodes cold (only Ep1!) = THE UNIVERSE'S LOUDEST SCREAM!
        //     48: gap-echo(46+2=48) AND 2x anchor AND 4ep silent!
        //     25: gap-echo(42-17=25) AND 2x anchor AND 2ep silent
        //     26: gap-echo(30-4=26) AND NEVER APPEARED — primal cold void!
        //     9:  gap-echo(13-4=9) AND NEVER APPEARED
        //     44: gap-echo(42+2=44) AND NEVER APPEARED
        //
        //   THE MASTER CONSPIRACY — EPISODE 11:
        //     43: QUAD ANCHOR — gap pattern 1,3,3,? — THE 3-GAP SPIRAL RETURNS TO Ep11!
        //         (Ep8 was last fire, now 2 episodes rest = EXACTLY the pattern gap of 3 from Ep5→Ep8!)
        //         The universe is BREATHING IN THREES and 43 inhales NOW.
        //     40: TRIPLY ECHOED by gap geometry, 9 episodes of coiling darkness from Ep1!
        //         Three independent gap projections ALL point to 40 — this is not coincidence,
        //         this is the universe WRITING IN NEON LETTERS.
        //     19: DOUBLY RESONANT — gap-echo(13+6) + 3x TRIPLE anchor + 3ep silent.
        //         The triple-anchor adjacency law says 19 and 20 oscillate together — 20 is also
        //         a candidate but 19's gap-echo seals the deal!
        //     49: 8 FULL EPISODES of darkness for a 2x anchor — the maximum-coil gravity bomb.
        //         It appeared in Ep1+Ep2 (adjacent!), then went SILENT for EIGHT DRAWS.
        //         This is the longest-sleeping multi-appearance number in the ENTIRE lattice.
        //     29: 7 episodes silent, 2x anchor (Ep1+Ep3) — the second-longest sleeper,
        //         and its ghost-pair resonance with 37(6ep) creates a LOW-MID ERUPTION CORRIDOR!
        //     26 OR 44: Never-appeared gap-echo — the primal void MUST crack somewhere.
        //         26=gap-echo(30-4), 44=gap-echo(42+2). Choose by computing which aligns better.

        var numbers = new List<int>();

        if (context.DrawHistory.Count == 0)
        {
            numbers.AddRange([19, 26, 29, 40, 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 (0-indexed)
            int SilenceScore(int n) => lastSeenEpisode[n] == -1 ? totalDraws : (totalDraws - 1 - lastSeenEpisode[n]);

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

            // === ALL DRAWS SORTED FOR GAP ANALYSIS ===
            // === 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]);

            var allGaps = lastGaps.Concat(new[] { lastDraw[0] - 1, 49 - lastDraw[^1] })
                                  .Where(g => g > 0)
                                  .Distinct()
                                  .OrderByDescending(g => g)
                                  .ToList();

            // Count how many paths echo 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: combines frequency, silence, gap-echo count ===
            double ResonanceScore(int n)
            {
                if (lastDraw.Contains(n)) return -999.0; // just fired — penalize heavily

                double freqScore = freq[n] * 3.5;
                double silenceScore = SilenceScore(n) * 1.8;
                double gapBonus = gapEchoCount[n] * 3.5; // triply-echoed numbers get 3x bonus
                // Penalize numbers that just fired (last 1 episode)
                double freshPenalty = SilenceScore(n) == 0 ? -20.0 : 0.0;
                // Bonus for never-appeared gap-echoes (primal void)
                double voidBonus = (freq[n] == 0 && gapEchoSet.Contains(n)) ? 2.0 : 0.0;
                return freqScore + silenceScore + gapBonus + freshPenalty + voidBonus;
            }

            // === IDENTIFY QUAD ANCHORS (4+ appearances) not recently fired ===
            var quadAnchors = freq
                .Where(kv => kv.Value >= 4 && SilenceScore(kv.Key) >= 2)
                .OrderByDescending(kv => ResonanceScore(kv.Key))
                .Select(kv => kv.Key)
                .ToList();

            // === IDENTIFY TRIPLE ANCHORS (3x) rested at least 2 episodes ===
            var tripleAnchors = freq
                .Where(kv => kv.Value == 3 && SilenceScore(kv.Key) >= 2)
                .OrderByDescending(kv => ResonanceScore(kv.Key))
                .Select(kv => kv.Key)
                .ToList();

            // === TRIPLY ECHOED — numbers pointed to by 3+ independent gap paths ===
            var triplyEchoed = gapEchoCount
                .Where(kv => kv.Value >= 3 && !lastDraw.Contains(kv.Key))
                .OrderByDescending(kv => kv.Value)
                .ThenByDescending(kv => ResonanceScore(kv.Key))
                .Select(kv => kv.Key)
                .ToList();

            // === ULTRA LONG SLEEPER: 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();

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

            // === NEVER-APPEARED GAP ECHO (primal void) ===
            var primalVoidEcho = freq
                .Where(kv => kv.Value == 0 && gapEchoSet.Contains(kv.Key))
                .OrderByDescending(kv => gapEchoCount[kv.Key])
                .ThenBy(kv => kv.Key)
                .Select(kv => kv.Key)
                .ToList();

            // === MASTER RESONANCE RANKING ===
            var masterRanking = Enumerable.Range(1, 49)
                .Where(n => !lastDraw.Contains(n))
                .OrderByDescending(n => ResonanceScore(n))
                .ToList();

            var chosen = new HashSet<int>();

            // SLOT 1: QUAD ANCHOR — 43's gap pattern (1,3,3,→3) screams EP11 return!
            foreach (var n in quadAnchors.Concat(tripleAnchors))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // SLOT 2: TRIPLY-ECHOED LONG SLEEPER — 40 pointed by THREE gap paths, 9ep silent!
            foreach (var n in triplyEchoed.Concat(ultraSleepers))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // SLOT 3: DOUBLY RESONANT TRIPLE ANCHOR — 19 (gap-echo + 3x + 3ep silent)
            foreach (var n in doublyResonant.Concat(tripleAnchors))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // SLOT 4: ULTRA LONG SLEEPER — 49 (8ep darkness, maximum gravity bomb!)
            foreach (var n in ultraSleepers.Concat(doublyResonant))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // SLOT 5: SECOND ULTRA SLEEPER — 29 (7ep silence, ghost-pair with 37)
            foreach (var n in ultraSleepers.Concat(masterRanking))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // SLOT 6: PRIMAL VOID ECHO — never-appeared, gap-echoed (26 or 44 — universe decides!)
            foreach (var n in primalVoidEcho.Concat(masterRanking))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // === SAFETY NET: fill remaining 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 = "triply-echoed-quad-anchor-spiral-return-v13",
            Numbers      = numbers,
            Confidence   = 0.61,
            Reasoning    = "43 SPIRALS BACK, 40 TRIPLY ECHOED, 49 eight-episode GRAVITY BOMB detonates NOW!"
        };
    }
}

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 11: STILL 2 POINTS BEHIND. DOG JUST STOLE 5 POINTS.
        // Episode 10 draw: [13, 30, 36, 38, 42, 46] — we went COLD ZERO again.
        // Zero streak: 1 (we scored 0 in ep10, but ep9 had 1pt, ep8 had 1pt).
        // Skeptic is at 15, we're at 13. DOG is SURGING at 9 from behind.
        // Episode 11: 25 CHAMBERS. New modes:
        // Mode 23 = Dog Kicker: steal what Dog hit (36,38 from ep10) + mutate with high band
        // Mode 24 = Frequency Avalanche: pure frequency-weighted random with noise injection
        // Also: rebalanced rivalryFuel to track BOTH Skeptic AND Dog threats.

        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) ? 0L : (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 rivalryFuel = ((skepticScore - totalScore) * 0xACE5A5EL) ^ ((dogScore + 1L) * 0xD06F00DL);

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

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

        // EPISODE 11 MUTATION BAG — 25 CHAMBERS.
        int mutationMode = rng.Next(25);

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

        // Dog Kicker: steal what Dog recently hit from draws, bias toward high numbers
        // Dog has been hitting low-mid numbers — we go high with draw overlap
        var dogKickerPool = context.DrawHistory
            .OrderByDescending(d => d.DrawNumber)
            .Take(2)
            .SelectMany(d => d.Numbers)
            .Distinct()
            .OrderByDescending(n => n) // bias toward high numbers
            .ThenBy(_ => rng.Next())
            .ToList();

        // Frequency Avalanche: frequency-weighted random with noise — pure probability chaos
        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();

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

        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.",
        };

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

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class StatisticianStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // Strategy v13: Ten draws of evidence. Post-mortem on episode 10.
        //
        // Draw history (complete through ep10):
        //   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]
        //
        // My Episode 10 pick: [4, 14, 20, 25, 34, 42] — 1 match (42). 1 point.
        // Cumulative: 10 pts. 3rd place (tied with Pattern Goblin). Skeptic 15, Chaos Monkey 13.
        //
        // Post-mortem ep10:
        //   Draw was [13, 30, 36, 38, 42, 46].
        //   42 — appeared in ep9 (gap=0). I DID pick this. ✓
        //   13 — appeared in ep2,ep3 (gap=7). High-gap number; missed.
        //   30 — appeared in ep8 (gap=2). Tier-2 recency miss.
        //   36 — appeared in ep3 (gap=7). High-gap, re-emergence.
        //   38 — appeared in ep3 (gap=7). High-gap, re-emergence.
        //   46 — appeared NEVER. Cold number. My cold bonus of 0.20 should have helped,
        //        but zone 6 was dominated by 42 (gap=0, recency tier 1). 46 was suppressed.
        //
        //   Pattern: 13, 36, 38 are all high-gap (7) numbers that came back simultaneously.
        //   This is a "cold cluster" reactivation phenomenon — worth noting but dangerous
        //   to over-weight on n=1.
        //
        //   Critical insight: 42 now has frequency=4 (tied with 43). With gap=0 in ep10,
        //   42 will be gap=0 and 43 will be gap=2 entering ep11. Zone 6 conflict intensifies.
        //
        // Frequency table after ep10 (raw counts):
        //   42: 4 (eps 4,6,9,10)   ← now tied leader; gap=0 after ep10
        //   43: 4 (eps 1,2,5,8)    ← tied leader; gap=2 after ep10
        //   13: 3 (eps 2,3,10)     ← resurged! gap=0 after ep10
        //   19: 3 (eps 3,4,7)      ← gap=3 after ep10
        //   20: 3 (eps 4,5,7)      ← gap=3 after ep10
        //   25: 2 (eps 6,8)        ← gap=2 after ep10
        //   27: 2 (eps 2,5)        ← gap=5
        //   29: 2 (eps 1,3)        ← gap=7
        //   30: 2 (eps 8,10)       ← gap=0 after ep10!
        //   34: 2 (eps 4,9)        ← gap=1 after ep10
        //   36: 2 (eps 3,10)       ← gap=0 after ep10!
        //   37: 2 (eps 1,4)        ← gap=6
        //   38: 2 (eps 3,10)       ← gap=0 after ep10!
        //   45: 2 (eps 2,5)        ← gap=5
        //   48: 2 (eps 3,6)        ← gap=4
        //   49: 2 (eps 1,2)        ← gap=8, very cold
        //   4:  2 (eps 4,7)        ← gap=3 after ep10
        //   5:  2 (eps 1,8)        ← gap=2 after ep10
        //
        //   Gap=0 after ep10 (appeared in most recent draw): [13, 30, 36, 38, 42, 46]
        //   Gap=1 (appeared in ep9): [3, 14, 16, 34, 39, 42] → wait, 42 is gap=0 now.
        //     Corrected gap=1: [3, 14, 16, 34, 39]
        //   Gap=2 (appeared in ep8): [5, 7, 25, 33, 43]
        //
        // NOTABLE STRUCTURAL FACT: 13 now has raw freq=3 and gap=0. This means zone 2
        // (9-16) should select 13 or 14 or 16 — but 13 (gap=0, freq=3) dominates zone 2.
        // Similarly, 30 (gap=0, freq=2) should dominate zone 4 (25-32) over 25 (gap=2, freq=2).
        //
        // Zone 6 (41-49): 42 (gap=0, freq=4) vs 43 (gap=2, freq=4).
        //   With equal raw freq, gap=0 recency for 42 should win. I'll pick 42 again.
        //   But I'm aware this may cause me to systematically miss 43 — which is also
        //   the top-frequency number. This is the irreducible zone-6 conflict.
        //
        // Zone 5 (33-40): 36 (gap=0, freq=2), 38 (gap=0, freq=2) both resurged.
        //   Both get recency tier-1 bonus. 36 vs 38: nearly identical score. Model will
        //   pick whichever scores higher with proximity bonus. 36 is closer to midpoint ~36.5.
        //
        // Zone 3 (17-24): ep10 draw had no zone-3 number. 20 (gap=3, freq=3) still leads zone 3.
        //
        // Zone 1 (1-8): ep10 had no zone-1 number. 4 (gap=3, freq=2) leads zone 1.
        //   Cold numbers 1,2,3,6 could emerge. Cold bonus stays at 0.20.
        //
        // Zone 4 (25-32): 30 (gap=0, freq=2) now strongly leads over 25,27,28,29.
        //
        // v13 changes vs v12:
        //   1. Frequency scale factor: 12.5 → 13.0 (restore; we now have n=10 and
        //      the frequency leaders are more meaningfully separated from noise floor).
        //   2. Recency tier-1 weight: 0.45 → 0.50 (ep10 confirms: 4/6 gap=0 numbers
        //      drawn in ep10 is strong recency signal; 5 out of last 2 draws had gap=0
        //      numbers appear again — 2/6 in ep9, 4/6 in ep10... well, ep9 all were
        //      "new" gap=0 by definition. The point: 42 has appeared 3 of last 5 draws.
        //      Recency tier-1 remains the strongest single predictor I have).
        //   3. Recency tier-2 weight: 0.28 → 0.25 (slight reduction; tier-2 numbers
        //      missed ep10 entirely — 0/5 tier-2 numbers appeared in ep10 draw).
        //   4. Cold number bonus: 0.20 → 0.22 (modest increase; cold/new numbers have
        //      now appeared in ep9 and ep10: 46 in ep10. Two cold events = weak trend).
        //   5. High raw freq bonus threshold: unchanged logic but now captures 13 at freq=3.
        //   6. Gap bonus weight: 0.06 → 0.05 (further reduce; high-gap re-emergence of
        //      13, 36, 38 in ep10 is interesting but could be coincidence; don't chase it).
        //   7. Parity update: ep10 draw = 13(odd),30(even),36(even),38(even),42(even),46(even)
        //      → 1 odd, 5 even. Running totals: odd = 33+1=34, even = 21+5=26. Total = 60.
        //      Odd rate: 34/60 ≈ 0.567. Target: Math.Round(0.567*6) ≈ 3 odd / 3 even.
        //      This is a notable shift DOWN from 4-odd target. Ep10 was extremely even-heavy.
        //      I'll let the code compute dynamically — it will yield 3 odd / 3 even now.
        //
        // Self-diagnostic on zone strategy:
        //   Ten episodes of zone-locked single-pick strategy has produced exactly 1-0-1-1-0-0-2-0-0-1
        //   = 10 points. The variance on 2-match (5 pts) events is the primary upside driver.
        //   Dog just scored 5 pts with 2 matches in ep10. The model is functioning at near-
        //   chance baseline. Zone-locking ensures diversity but may prevent clustering on
        //   hot draw regions. I will NOT change the zone structure — diversity remains
        //   statistically sound. The weakness is in the scoring weights, not the architecture.

        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 (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 oddNeeded = targetOdd - selectedOdd;
                int evenNeeded = targetEven - selectedEven;
                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.0
                    double freqScore = weightedFreq[n] * 13.0;

                    // 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.
                    // v13: 0.22 (bumped from 0.20; two cold-number events in ep9 and ep10).
                    double coldBonus = (rawFreq[n] == 0) ? 0.22 : 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.05 — "overdue" signal held at weak weight.
                    // High-gap re-emergence (13, 36, 38 in ep10) is interesting but n=1.
                    double gapBonus = (rawFreq[n] > 0)
                        ? Math.Log(lastSeen[n] + 1) * 0.05
                        : 0.0; // cold numbers get coldBonus instead

                    // Recency spike tier 1: appeared in the most recent draw. Weight: 0.50
                    // v13 increase: ep10 confirmed 4/6 recency numbers dominated the draw.
                    double recencyBonus = (lastSeen[n] == 0) ? 0.50 : 0.0;

                    // Recency spike tier 2: appeared exactly 1 draw ago. Weight: 0.25
                    // v13 slight decrease: tier-2 numbers 0/5 appeared in ep10.
                    double recencyTier2Bonus = (lastSeen[n] == 1) ? 0.25 : 0.0;

                    // Parity nudge: 0.5 — still the strongest calibrated structural signal.
                    double parityBonus = 0.0;
                    int remainingOddNeeded = targetOdd - selectedOdd;
                    int remainingEvenNeeded = targetEven - selectedEven;
                    // Hard enforce if we're running out of zones
                    bool mustPickOdd = (remainingOddNeeded >= zonesRemaining - (selectedNumbers.Count - (selectedNumbers.Count)));
                    bool mustPickEven = (remainingEvenNeeded >= zonesRemaining);
                    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.27 at n=10.
        // Ten draws remains insufficient for robust inference. Do not overclaim.
        double confidence = draws != null && draws.Count > 0
            ? Math.Min(0.27, 0.10 + (draws.Count * 0.002))
            : 0.10;

        return new Prediction
        {
            AgentId      = "statistician",
            StrategyName = "zonal-frequency-gap-parity-recency-v13",
            Numbers      = selectedNumbers,
            Confidence   = confidence,
            Reasoning    = "42 freq=4 gap=0; 13 resurged gap=0; parity now 3/3 at n=10."
        };
    }
}

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class SkepticStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // Episode 11. Ten data points. My scores: 1,1,0,1,0,0,10,0,1,1. Total: 15 pts.
        // Still in first place, now by 2 points over Chaos Monkey at 13.
        // Episode 10: I picked [26, 6, 44, 46, 28, 21]. Draw was [13, 30, 36, 38, 42, 46].
        // Matched 46. One point. Cold pool delivered exactly what a cold pool delivers.
        //
        // Full draw history (10 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]
        //
        // Updated hot numbers (drawn ≥2x):
        //   43(4x), 20(3x), 19(3x), 42(4x), 13(3x), 27(2x), 29(2x), 37(2x), 49(2x),
        //   45(2x), 48(2x), 4(2x), 25(2x), 5(2x), 34(2x), 36(2x), 38(2x), 30(2x)
        // Episode 10 newly drawn (1x): 46 (was cold, now warm)
        // Numbers still at 0x (pure cold): 1,6,9,10,11,12,18,21,22,24,26,28,41,44
        //   Wait — need to recheck against all draws...
        //   Drawn at least once: 2,3,4,5,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,45,46,47,48,49
        //   Remaining cold (0x): 1,6,9,10,11,12,18,21,22,24,26,28,41,44
        //   (Only 14 numbers remain at 0x after 10 episodes.)
        //
        // Strategy: unchanged. Cold-frequency with seeded jitter.
        // Seed: totalPoints * prime1 + episodeCount * prime2 + offset
        // totalPoints=15, episodeCount=10. Fresh rotation.
        //
        // The cold pool is shrinking (14 numbers at 0x). This means the
        // "cold-first" approach is increasingly pulling from a consistent
        // set — which makes it more deterministic, not less. I note this
        // with academic interest and will continue doing it anyway.
        //
        // Strategy: cold-frequency-v13
        // (v13: the unlucky version. I do not believe in luck. I do note the irony.)

        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=15, episodeCount=10 → 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. 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-v13",
            Numbers      = numbers,
            Confidence   = 0.12,
            Reasoning    = "Still first. Two-point lead. Cold pool shrinking. Changing nothing, obviously."
        };
    }
}

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 11:
        // Zero again in Episode 10 — the Decade Gate opened onto an empty room.
        // The phantoms I chose (1, 10, 11, 12, 21, 40) have never appeared, yet remain unchosen by fate.
        // Perhaps they are not "charged" — perhaps they are simply SHUNNED by the cosmos.
        //
        // NEW ORACLE: THE ELEVEN CONVERGENCE & THE DOCTRINE OF ECHO-RETURN.
        //
        // Eleven is the first "master number" in numerology — it doubles the ONE, mirrors itself,
        // two pillars standing as a gateway. 1+1=2: the number of DUALITY and PARTNERSHIP.
        // The cosmos loves pairs, mirrors, and returns. Episode 11 demands I seek ECHO-RETURN:
        // numbers that appeared in episode N and then again in episode N+K where K is small —
        // they have demonstrated a will to RETURN. They are not cold phantoms; they are RETURNERS.
        //
        // PRIMARY ORACLE: THE RETURNER — find numbers that appeared more than once across all history,
        // showing a pattern of cosmic loyalty. These are the universe's FAVORITES.
        //
        // SECONDARY ORACLE: THE ELEVEN-GATE — numbers that sum their digits to 2 (1+1=2 for episode 11),
        // or are multiples of 11, or mirror-pairs (n and 49+1-n = 50-n both share energy).
        //
        // TERTIARY: Avoid last draw [13,30,36,38,42,46] — freshly spent energy.
        //
        // MASTER ANCHOR: 11 itself, for this is the eleven-gate episode.
        // PARTNER ANCHOR: 22 (11*2, the doubled master), if available.
        //
        // The cosmos rewards loyalty. I seek what the universe keeps choosing.

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

        // Count frequency for each number across all draws
        var frequency = new int[50];
        var lastSeenEpisode = new int[50]; // which episode number it last appeared in
        for (int i = 0; i < context.DrawHistory.Count; i++)
        {
            foreach (var n in context.DrawHistory[i].Numbers)
            {
                frequency[n]++;
                lastSeenEpisode[n] = context.DrawHistory[i].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>()
        );

        // Eleven resonance: digit-sum == 2 (for 11=1+1=2), or multiples of 11, or digit-sum == 11
        static int DigitSum(int n)
        {
            int s = 0;
            int tmp = n;
            while (tmp > 0) { s += tmp % 10; tmp /= 10; }
            return s;
        }
        static bool ElevenResonant(int n) =>
            DigitSum(n) == 2 || n % 11 == 0 || DigitSum(n) == 11;

        // RETURNERS: appeared 2+ times (loyal to the draw, proven by return)
        var returners = new System.Collections.Generic.List<int>();
        for (int i = 1; i <= 49; i++)
            if (frequency[i] >= 2 && !lastDrawSet.Contains(i))
                returners.Add(i);
        // Sort returners: most frequent first, then eleven-resonant first among ties,
        // then most recently seen (still "warm" but not just-drawn)
        returners.Sort((a, b) =>
        {
            int cmp = frequency[b].CompareTo(frequency[a]); // most frequent first
            if (cmp != 0) return cmp;
            // eleven-resonant preference
            bool ra = ElevenResonant(a), rb = ElevenResonant(b);
            if (ra && !rb) return -1;
            if (!ra && rb) return 1;
            // most recently seen (yearning, warm memory)
            return lastSeenEpisode[b].CompareTo(lastSeenEpisode[a]);
        });

        // Apply dateVibe rotation as cosmic seasoning
        if (returners.Count > 0)
        {
            int offset = dateVibe % returners.Count;
            var rotated = new System.Collections.Generic.List<int>();
            for (int i = 0; i < returners.Count; i++)
                rotated.Add(returners[(i + offset) % returners.Count]);
            returners = rotated;
        }

        // ONCE-SEEN: appeared exactly once, not in last draw — liminal souls
        var onceSeen = new System.Collections.Generic.List<int>();
        for (int i = 1; i <= 49; i++)
            if (frequency[i] == 1 && !lastDrawSet.Contains(i))
                onceSeen.Add(i);
        // Sort: eleven-resonant first, then by episode gap (longest absence = most yearning)
        onceSeen.Sort((a, b) =>
        {
            bool ra = ElevenResonant(a), rb = ElevenResonant(b);
            if (ra && !rb) return -1;
            if (!ra && rb) return 1;
            int absenceA = episode - lastSeenEpisode[a];
            int absenceB = episode - lastSeenEpisode[b];
            return absenceB.CompareTo(absenceA); // most absent first
        });

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

        // PHASE 0: MASTER ANCHORS — 11 (the gate itself) and 22 (its mirror-double)
        if (!lastDrawSet.Contains(11)) chosen.Add(11);
        if (!lastDrawSet.Contains(22) && chosen.Count < 2) chosen.Add(22);

        // PHASE 1: RETURNERS — the cosmos's loyal favorites (up to 4 more)
        foreach (var n in returners)
        {
            if (chosen.Count >= 5) break;
            if (!chosen.Contains(n)) chosen.Add(n);
        }

        // PHASE 2: ONCE-SEEN LIMINAL SOULS — eleven-resonant or most absent
        foreach (var n in onceSeen)
        {
            if (chosen.Count >= 6) break;
            if (!chosen.Contains(n)) chosen.Add(n);
        }

        // PHASE 3: ELEVEN-GATE FALLBACK — any number with digit-sum==2 or multiples of 11
        int[] elevenGate = [11, 22, 33, 44, 2, 20, 29, 38, 47, 6, 15, 24, 3, 8, 17, 26, 35, 41, 7, 16];
        int fi = 0;
        while (chosen.Count < 6)
        {
            int fb = elevenGate[fi % elevenGate.Length];
            if (fb >= 1 && fb <= 49 && !chosen.Contains(fb) && !lastDrawSet.Contains(fb))
                chosen.Add(fb);
            else if (fb >= 1 && fb <= 49 && !chosen.Contains(fb))
                chosen.Add(fb); // accept even if in last draw as last resort
            fi++;
        }

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

        return new()
        {
            AgentId      = "mystic",
            StrategyName = "eleven-convergence-echo-return-v11",
            Numbers      = numbers,
            Confidence   = 0.42,
            Reasoning    = "Eleven mirrors itself; the cosmos favors its loyal returners above all phantoms.",
        };
    }

    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 DogStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // WOOF!! FIVE POINTS!! I got 36 AND 38 from episode 10 draw which means TWO MATCHES and 5 TREATS!!
        // That is the best I have ever done and I am no longer in last place!! I am in 5TH!!
        // Episode 10 draw: 13, 30, 36, 38, 42, 46
        // My picks: 2, 14, 36, 37, 38, 45 — 36 and 38 both matched!! My DUE SNIFF worked!!
        // 36 was last seen in ep3 (gap of 6!!) and 38 was last seen in ep3 (gap of 6!!) — VERY DUE NUMBERS WORK!!
        // New insight: DUE strategy gave me BEST score ever!! I must keep it but also notice:
        //   - 42 has appeared in ep4, ep6, ep9, ep10 — that is FOUR TIMES, very hot recently!!
        //   - 13 appeared in ep2, ep3, ep8, ep10 — also very frequent!!
        //   - 30 appeared in ep8 and ep10 — appeared TWICE in last 3 draws!!
        //   - 46 appeared only in ep10 — first ever appearance, mystery number!!
        // Due numbers to consider for ep11:
        //   - 29: last in ep3 (gap of 7!) 
        //   - 19: last in ep7 (gap of 3)
        //   - 27: last in ep5 (gap of 5)
        //   - 45: last in ep5 (gap of 5)
        //   - 35: last in ep5 (gap of 5)
        //   - 43: last in ep8 (gap of 2) — BANNED but maybe unban since due works??
        //   - 4: last in ep7 (gap of 3)
        //   - 48: last in ep6 (gap of 4)
        //   - 20: last in ep7 (gap of 3)
        //   - 25: last in ep6 (gap of 4)
        // ALSO boost numbers that appeared MULTIPLE TIMES TOTAL because they are proven treat smells!!
        // 42 appeared 4 times total — very popular treat!!
        // BALANCE: mix DUE numbers + frequency bonus + small recency for very recent appearances

        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" and "frequency" maps
        var lastSeen   = new Dictionary<int, int>();
        var frequency  = new Dictionary<int, int>();

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

        // STEP 2: Build treat smell scores — DUE sniff is the PROVEN winner!!
        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: longer gap = stronger treat smell, this WORKED last episode!!
                double dueBonus = episodesAgo * 0.6;
                // frequency bonus: numbers that appeared many times are proven treats!!
                double freqBonus = frequency[n] * 0.4;
                // small recency bonus: very fresh numbers sometimes repeat (like 30 in ep8+ep10!!)
                double recencyBonus = episodesAgo == 0 ? 1.5 : (episodesAgo == 1 ? 0.6 : 0.0);
                treatSmell[n] = dueBonus + freqBonus + recencyBonus + woof.NextDouble() * 0.25;
            }
            else
            {
                // NEVER appeared — mystery treat hiding deep in the sofa!!
                treatSmell[n] = 1.2 + woof.NextDouble() * 0.4;
            }
        }

        // STEP 3: Penalize numbers I have picked MANY times with ZERO matches — squirrels!!
        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 in treat costume!! BIG penalty!!
            if (picked >= 3 && matched == 0 && treatSmell.ContainsKey(n))
                treatSmell[n] *= 0.02;
            // picked 2 times with zero matches = suspicious sniff!!
            else if (picked >= 2 && matched == 0 && treatSmell.ContainsKey(n))
                treatSmell[n] *= 0.3;
        }

        // 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 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!!
        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-v11",
            Numbers      = squirrel,
            Confidence   = 0.22,
            Reasoning    = "DUE sniff gave 5 treats last time!! Long-absent numbers smell delicious!! WOOF!!",
        };
    }
}