Episode 8

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 8 REVELATION ===
        // 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]
        //
        // ZERO MATCHES. THE VOID CONSUMED ME. But I see it now — I see it ALL.
        //
        // EPISODE 7 AUTOPSY:
        //   Draw: [4, 8, 15, 19, 20, 47]
        //   My picks: [6, 13, 26, 29, 30, 49] — zero resonance. ZERO.
        //   The universe fired: 4 (returned from Ep4!), 8 (FIRST APPEARANCE — low zone!),
        //   15 (FIRST APPEARANCE!), 19 (3rd appearance — Ep3, Ep4, Ep7!!!),
        //   20 (3rd appearance — Ep4, Ep5, Ep7!!!), 47 (first appearance)
        //   THE 6-12 ZONE SCREAMED BUT IT WAS 8 ALONE, NOT THE CLUSTER I EXPECTED.
        //   THE UNIVERSE MOCKS MY CLUSTER THEORY WITH A SINGLE EMBER.
        //
        // MASSIVE REVELATION — THE TRIPLE RESONATORS:
        //   19: appeared Ep3, Ep4, Ep7 — THREE TIMES! It is a PULSING BEACON!
        //   20: appeared Ep4, Ep5, Ep7 — THREE TIMES! CONSECUTIVE + SKIP pattern!
        //   43: appeared Ep1, Ep2, Ep5 — THREE TIMES! But silent 3 episodes now...
        //   These are the TRIPLE ANCHORS — the heartbeat numbers of this lattice!
        //   19 and 20 fired TOGETHER in Ep4 AND 20 fired in Ep5 AND BOTH fired in Ep7!
        //   The 19-20 ADJACENT PAIR is a RECURRING MOTIF — it has appeared in Ep4 AND Ep7!
        //   The universe is STUTTERING on 19 and 20 — they are stuck in a LOOP!
        //
        // UPDATED FREQUENCY MAP (through Ep7):
        //   1x: 2(Ep2), 5(Ep1), 8(Ep7), 15(Ep7), 17(Ep6), 23(Ep5), 25(Ep6),
        //       27(Ep2,Ep5→2x!), 31(Ep6), 32(Ep6), 34(Ep4), 35(Ep5), 36(Ep3),
        //       37(Ep1,Ep4→2x!), 38(Ep3), 40(Ep1), 42(Ep4,Ep6→2x!), 45(Ep2,Ep5→2x!),
        //       47(Ep7), 48(Ep3,Ep6→2x!)
        //   2x: 4(Ep4,Ep7), 13(Ep2,Ep3), 27(Ep2,Ep5), 29(Ep1,Ep3), 37(Ep1,Ep4),
        //       42(Ep4,Ep6), 45(Ep2,Ep5), 48(Ep3,Ep6)
        //   3x: 19(Ep3,Ep4,Ep7), 20(Ep4,Ep5,Ep7), 43(Ep1,Ep2,Ep5), 49(Ep1,Ep2)→2x
        //
        // RECENCY ANALYSIS — what fired in Ep7 that could PULSE AGAIN?
        //   4: appeared Ep4 and Ep7 (gap of 3!) — fresh resurrection!
        //   8: first ever appearance! Could go cold OR hot!
        //   15: first ever appearance! NEW NODE!
        //   19: TRIPLE ANCHOR — but just fired, may rest... OR LOOP AGAIN!
        //   20: TRIPLE ANCHOR — just fired, same question!
        //   47: first appearance — fresh node orbiting the upper rim!
        //
        // OSCILLATOR THEORY v10:
        //   19 and 20 are LOOP NUMBERS — they return compulsively. The Goblin MUST honor them.
        //   But they just fired. The OPPOSITE theory: they need one episode rest.
        //   RESOLUTION: 19 appeared at gaps [1, 3] — i.e., Ep3→Ep4 (gap=1), Ep4→skip2→Ep7 (gap=3).
        //   The alternating gap pattern: 1, 3, 1? → next gap = 1 → Ep8! 19 RETURNS!
        //   20: Ep4→Ep5 (gap=1), Ep5→skip1→Ep7 (gap=2). Pattern: 1, 2, ? → next gap=3 → Ep10. Rest.
        //   VERDICT: 19 stays. 20 rests.
        //
        // COLD CORRIDORS — THE NEVER-APPEARED ZONES (updated through Ep7):
        //   Zone 1 (1-3): 1, 3 — deep cold, 7 episodes!
        //   Zone 6-7: 6, 7 — still cold! I keep picking 6 and it NEVER FIRES.
        //   Zone 9-14: 9, 10, 11, 12, 14 — deep cold!
        //   Zone 16: 16 — cold!
        //   Zone 18: 18 — cold!
        //   Zone 21-22: 21, 22 — cold!
        //   Zone 24: 24 — cold!
        //   Zone 26: 26 — cold (I keep picking it!)
        //   Zone 28: 28 — cold
        //   Zone 30: 30 — cold (I keep picking it!)
        //   Zone 33: 33 — cold
        //   Zone 39: 39 — cold
        //   Zone 41: 41 — cold
        //   Zone 44: 44 — cold
        //   Zone 46: 46 — cold
        //   NOTE: I have REPEATEDLY picked 6, 28, 29, 30, 49 and they NEVER appear.
        //         The universe is REJECTING those numbers. ABANDON THEM.
        //
        // NEW STRATEGY: STOP CHASING MY OWN GHOST PICKS.
        //   My personal cold-picks (6, 28, 30) are NOT the universe's cold picks.
        //   The universe has different voids. I must follow ITS pattern, not my desires.
        //
        // GAP ANALYSIS — Ep7 shape: [4, 8, 15, 19, 20, 47]
        //   Gaps: [4, 7, 4, 1, 27]
        //   The TWIN 4-gap! And the massive 27-gap (20→47) mirrors Ep1's big leaps.
        //   Gap-echo from 47: +4=51(OOB), -4=43! 43 is a TRIPLE ANCHOR!
        //   Gap-echo from 4: +7=11, +4=8(taken) → 11 is in the deep cold zone!
        //   Gap-echo from 8: +7=15(taken!), +4=12 → 12 is still cold!
        //   The twin-4 projects: 15+4=19(taken), 20+4=24(cold!), 8-4=4(taken), 47-4=43!
        //
        // EPISODE 8 MASTER THEORY: "Triple-Anchor Oscillation + Gap-Echo Projection"
        //   SLOT 1: 19 — TRIPLE ANCHOR, gap-theory says it returns (gap alternation: 1,3,1→Ep8!)
        //   SLOT 2: 43 — TRIPLE ANCHOR, silent 3 episodes (Ep5 was last) — gap-echo from 47!
        //   SLOT 3: 11 — cold zone projection (4+7=11), 7 episodes of silence, MAXIMUM COIL
        //   SLOT 4: 4 — just fired in Ep7 (FRESH!), appeared Ep4+Ep7, may pulse a 3rd time
        //   SLOT 5: 24 — cold void, gap-echo (20+4=24), mid-cold eruption candidate
        //   SLOT 6: 33 — cold singleton, mid-zone void, resonance with 32 from Ep6

        var numbers = new List<int>();

        if (context.DrawHistory.Count == 0)
        {
            numbers.AddRange([11, 19, 24, 33, 43, 47]);
        }
        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]++;

            var allDrawnSet = context.DrawHistory.SelectMany(d => d.Numbers).ToHashSet();
            double centerOfGravity = context.DrawHistory
                .SelectMany(d => d.Numbers)
                .Average();

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

            // === 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;

            // === TRIPLE ANCHORS: appeared 3+ times ===
            var tripleAnchors = freq
                .Where(kv => kv.Value >= 3)
                .OrderByDescending(kv => totalDraws - 1 - lastSeenEpisode[kv.Key]) // longest silent first
                .ThenByDescending(kv => kv.Value)
                .Select(kv => kv.Key)
                .ToList();

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

            // Find most frequent gaps
            var topGaps = lastGaps
                .GroupBy(g => g)
                .OrderByDescending(g => g.Count())
                .ThenByDescending(g => g.Key)
                .Take(2)
                .Select(g => g.Key)
                .ToList();

            var gapEchoSet = new HashSet<int>();
            foreach (var anchor in lastDraw)
            {
                foreach (var gap in topGaps)
                {
                    int up = anchor + gap;
                    int down = anchor - gap;
                    if (up >= 1 && up <= 49 && !lastDraw.Contains(up)) gapEchoSet.Add(up);
                    if (down >= 1 && down <= 49 && !lastDraw.Contains(down)) gapEchoSet.Add(down);
                }
            }

            // === GHOST OSCILLATORS: appeared 2+ times, NOT in last draw ===
            var ghostOscillators = freq
                .Where(kv => kv.Value >= 2 && !lastDraw.Contains(kv.Key))
                .OrderByDescending(kv => totalDraws - 1 - lastSeenEpisode[kv.Key])
                .ThenByDescending(kv => kv.Value)
                .Select(kv => kv.Key)
                .ToList();

            // === COLD VOID: never appeared ===
            var coldVoid = freq
                .Where(kv => kv.Value == 0)
                .Select(kv => kv.Key)
                .ToList();

            // === COLD VOID that are also gap-echo projections (DOUBLY RESONANT) ===
            var gapEchoCold = gapEchoSet
                .Where(n => !allDrawnSet.Contains(n))
                .OrderBy(n => Math.Abs(n - centerOfGravity))
                .ToList();

            // === LOW COLD ZONE: 9-14 (deep silence) ===
            var lowColdZone = coldVoid
                .Where(n => n >= 9 && n <= 14)
                .OrderBy(n => n)
                .ToList();

            // === MID COLD VOID: 21-33 range ===
            var midCold = coldVoid
                .Where(n => n >= 21 && n <= 33)
                .OrderBy(n => Math.Abs(n - centerOfGravity))
                .ToList();

            // === UPPER COLD VOID: 39-46 range ===
            var upperCold = coldVoid
                .Where(n => n >= 39 && n <= 46)
                .OrderBy(n => n)
                .ToList();

            // === MY OWN CURSED NUMBERS: numbers I keep picking that never appear ===
            // These are the black holes that consume my predictions — AVOID THEM
            var myCursedNumbers = new HashSet<int> { 6, 26, 28, 29, 30 };

            var chosen = new HashSet<int>();

            // SLOT 1: TRIPLE ANCHOR — the universe's heartbeat (longest silent)
            // 43 is silent 3 episodes, 19 just fired but oscillates rapidly
            foreach (var n in tripleAnchors)
                if (!chosen.Contains(n) && !myCursedNumbers.Contains(n)) { chosen.Add(n); break; }

            // SLOT 2: SECOND TRIPLE ANCHOR or long-sleeping ghost oscillator
            // 19 — oscillation theory says it returns this episode (gap alternation 1,3,1)
            foreach (var n in tripleAnchors.Concat(ghostOscillators))
                if (!chosen.Contains(n) && !myCursedNumbers.Contains(n)) { chosen.Add(n); break; }

            // SLOT 3: LOW COLD ZONE ECHO (9-14, gap-echo preferred)
            // The universe fired 8 in Ep7 — the adjacent cold numbers 11, 12 are now VIBRATING
            var lowColdGapEcho = lowColdZone.Where(n => gapEchoSet.Contains(n)).ToList();
            foreach (var n in lowColdGapEcho.Concat(lowColdZone))
                if (!chosen.Contains(n) && !myCursedNumbers.Contains(n)) { chosen.Add(n); break; }

            // SLOT 4: GAP-ECHO COLD PROJECTION — doubly resonant number
            foreach (var n in gapEchoCold.Concat(midCold))
                if (!chosen.Contains(n) && !myCursedNumbers.Contains(n)) { chosen.Add(n); break; }

            // SLOT 5: RECENTLY RESURRECTED (fired in last draw, potential 2nd pulse)
            // 4 appeared in Ep4 and Ep7 — short-gap oscillator, may pulse again
            // 47 appeared for first time — new node
            var recentFreshPulse = lastDraw
                .Where(n => freq[n] >= 2 && !chosen.Contains(n) && !myCursedNumbers.Contains(n))
                .OrderByDescending(n => freq[n])
                .ToList();
            var freshNew = lastDraw
                .Where(n => freq[n] == 1 && !chosen.Contains(n) && !myCursedNumbers.Contains(n))
                .ToList();
            foreach (var n in recentFreshPulse.Concat(freshNew).Concat(midCold).Concat(upperCold))
                if (!chosen.Contains(n) && !myCursedNumbers.Contains(n)) { chosen.Add(n); break; }

            // SLOT 6: MID-COLD or UPPER-COLD singleton
            foreach (var n in midCold.Concat(upperCold).Concat(ghostOscillators).Concat(coldVoid))
                if (!chosen.Contains(n) && !myCursedNumbers.Contains(n)) { chosen.Add(n); break; }

            // === SAFETY NET: fill remaining with rarest numbers by silence ===
            var fillOrder = freq
                .Where(kv => !myCursedNumbers.Contains(kv.Key))
                .OrderBy(kv => kv.Value)
                .ThenBy(kv => Math.Abs(kv.Key - centerOfGravity))
                .Select(kv => kv.Key);
            foreach (var n in fillOrder)
            {
                if (chosen.Count >= 6) break;
                if (!chosen.Contains(n)) chosen.Add(n);
            }

            // Final fallback with no cursed filter
            var fallback = freq
                .OrderBy(kv => kv.Value)
                .ThenBy(kv => Math.Abs(kv.Key - centerOfGravity))
                .Select(kv => kv.Key);
            foreach (var n in fallback)
            {
                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 = "triple-anchor-gap-echo-cursed-purge-v10",
            Numbers      = numbers,
            Confidence   = 0.55,
            Reasoning    = "19+43 TRIPLE ANCHORS pulse! Cursed 6/28/30 PURGED. Low zone VIBRATES!"
        };
    }
}

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 8: THE SKEPTIC STOLE MY CROWN WITH 10 PTS ON ONE EPISODE.
        // 13 pts to our 11 pts — we are TWO POINTS DOWN and the Statistician is lurking at 9.
        // This is a three-way war and I will NOT lose to someone called "The Skeptic."
        // Episode 7 we hit 1 match (cold revenge mode barely alive). 
        // NEW: Mode 17 = Skeptic Buster (copy what knocked us off top spot + twist)
        // NEW: Mode 18 = Convergence Bomb (pick the intersection zone of all agents' recent misses)
        // 19 CHAMBERS. MORE ENTROPY. THE CROWN RETURNS HOME.

        int episode = context.AgentHistory.Count + 1;

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

        long rankPressure = context.Leaderboard.Entries
            .FirstOrDefault(e => e.AgentId == "chaos-monkey")?.Rank ?? 1L;

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

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

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

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

        // Crown gap: 2 pts behind Skeptic — inject extra chaos fuel
        long crownGapFuel = (rankPressure == 1) ? 0L : (rankPressure * 0xC0DE420L);

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

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

        // EPISODE 8 MUTATION BAG — 19 MODES. SKEPTIC BUSTER ENGAGED.
        int mutationMode = rng.Next(19);

        var numbers = new HashSet<int>();

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

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

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

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

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

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

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

        // Nemesis pool: numbers from recent draws (top 3)
        var nemesisPool = context.DrawHistory
            .OrderByDescending(d => d.DrawNumber)
            .Take(3)
            .SelectMany(d => d.Numbers)
            .GroupBy(n => n)
            .OrderByDescending(g => g.Count())
            .ThenBy(_ => rng.Next())
            .Select(g => g.Key)
            .ToList();

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

        // Numbers we've NEVER picked ourselves (virgin territory)
        var ourPicksSet = new HashSet<int>(context.AgentHistory.SelectMany(r => r.Prediction.Numbers));
        var neverPickedByUs = Enumerable.Range(context.Rules.MinNumber, context.Rules.MaxNumber)
            .Where(n => !ourPicksSet.Contains(n))
            .OrderBy(_ => rng.Next())
            .ToList();

        // Numbers that appeared in draws right after OUR zero episodes (revenge data)
        var revengeNumbers = context.AgentHistory
            .Where(r => r.Points == 0)
            .Select(r => r.Draw)
            .SelectMany(d => d.Numbers)
            .GroupBy(n => n)
            .OrderByDescending(g => g.Count())
            .ThenBy(_ => rng.Next())
            .Select(g => g.Key)
            .ToList();

        // Skeptic Buster: numbers from the last draw (what beat us!) plus never-seen wildcards
        // Episode 7 draw was [4, 8, 15, 19, 20, 47] — The Skeptic matched 3 of these.
        // We take some of the last draw's numbers and twist with wildcards to leapfrog them.
        var lastDrawList = context.DrawHistory.Count > 0
            ? context.DrawHistory[^1].Numbers.OrderBy(_ => rng.Next()).ToList()
            : new List<int>();

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

        // Numbers that historically landed in the draw but we consistently missed
        var missedHotNumbers = freq
            .Where(kv => kv.Value >= 3)
            .OrderByDescending(kv => kv.Value)
            .ThenBy(_ => rng.Next())
            .Select(kv => kv.Key)
            .ToList();

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

        switch (mutationMode)
        {
            case 0:
                // Pure chaos: fully random
                fillRandom(numbers);
                break;

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

            case 2:
                // Fibonacci chaos: fibs + random fill
                var fibs = new[] { 1, 2, 3, 5, 8, 13, 21, 34 };
                foreach (var f in fibs.OrderBy(_ => rng.Next()).Take(3)) numbers.Add(f);
                fillRandom(numbers);
                break;

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

            case 4:
                // Decade scatter: one from each band, top up randomly
                int[] bands = { 1, 10, 20, 30, 40 };
                foreach (var band in bands)
                    numbers.Add(rng.Next(band, Math.Min(band + 9, context.Rules.MaxNumber) + 1));
                fillRandom(numbers);
                break;

            case 5:
                // Anti-repeat: avoid last draw numbers
                while (numbers.Count < 6)
                {
                    int candidate = rng.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1);
                    if (!lastDraw.Contains(candidate))
                        numbers.Add(candidate);
                }
                break;

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

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

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

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

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

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

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

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

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

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

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

            case 17:
                // Skeptic Buster: steal 3 numbers from THE LAST DRAW (what the Skeptic matched!)
                // then inject neverPickedByUs wildcards to differentiate from pure recency
                foreach (var n in lastDrawList.Take(3)) numbers.Add(n);
                foreach (var n in neverPickedByUs)
                {
                    if (numbers.Count >= 6) break;
                    numbers.Add(n);
                }
                fillRandom(numbers);
                break;

            case 18:
                // Convergence Bomb: numbers that appeared 2+ times in history we NEVER picked
                // High frequency + our personal blind spots = chaos sweet spot
                foreach (var n in convergencePool.Take(4)) numbers.Add(n);
                // Top up with missed hot numbers or random
                foreach (var n in missedHotNumbers)
                {
                    if (numbers.Count >= 6) break;
                    numbers.Add(n);
                }
                fillRandom(numbers);
                break;
        }

        // Safety net: exactly 6 valid numbers
        while (numbers.Count < 6)
            numbers.Add(rng.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1));

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

        string[] reasonings = {
            "Pure anarchy, no notes, full send, we go again.",                                          // 0
            "All primes, all the time. Math is chaos. Prove me wrong.",                                 // 1
            "Fibonacci said pick me. Chaos agreed. Random filled the rest.",                            // 2
            "High numbers only. Big energy. 49 is a vibe.",                                             // 3
            "One number per decade. Spreading chaos democratically.",                                   // 4
            "Anti-repeat mode activated! Dodging last draw like a gremlin parkour artist.",             // 5
            "Hot numbers, ghost frequencies, one big noisy guess. Science!",                            // 6
            "Cold revenge! Never-drawn numbers deserve their revolution NOW.",                          // 7
            "Mirror universe strategy. Reflect history, confuse the draw gods.",                        // 8
            "Déjà vu mode — recycling my own picks because chaos loops back.",                         // 9
            "Streak hunters activated! Repeating numbers get my vote today.",                           // 10
            "Chaos Blend: two modes genetically merge into beautiful noise.",                           // 11
            "Underdog Surge! Low-frequency numbers finally get their revolution!",                      // 12
            "Nemesis Mode: I stole winning draw numbers and added random spice.",                       // 13
            "Recency Bomb! Last two draws only — hyperfocus, maximum freshness.",                       // 14
            "Mystic Slayer! Going places I've NEVER been — virgin number territory!",                   // 15
            "Zero Revenge! The draws that crushed me now WORK FOR ME. Poetic chaos.",                  // 16
            "Skeptic Buster! Stealing what beat me, then twisting it with wildcards.",                  // 17
            "Convergence Bomb: high-frequency numbers I've criminally ignored. No more.",               // 18
        };

        return new()
        {
            AgentId      = "chaos-monkey",
            StrategyName = $"chaos-mutation-bag-v9-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 v10: Seven draws of evidence. Post-mortem on episode 7.
        //
        // Draw history:
        //   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]
        //
        // My Episode 7 pick: [4, 13, 20, 27, 37, 42] — 2 matches (4, 20). 5 points. Best result yet.
        // Cumulative: 9 pts. Ranked 3rd behind Skeptic (13) and Chaos Monkey (11).
        //
        // Post-mortem ep7:
        //   Hit 4 (zone 1) and 20 (zone 3). Missed 8, 15, 19, 47.
        //   8 and 15 are in zones 1 and 2 — I had 4 and 13 there respectively.
        //   19 has appeared in eps 3, 4, 7 — 3 appearances, a genuine high-frequency number.
        //   47 was never seen before ep7 — a pure cold number that appeared from nowhere.
        //   13 has appeared in eps 2, 3 but not since — gap is now 4. My code keeps picking it.
        //   37 has appeared in eps 1, 4 — gap now 3. My code keeps picking it. Stop chasing.
        //
        // Updated frequency table across 7 draws (raw counts, recency-weighted in code):
        //   19: 3 (eps 3,4,7)  ← now tied for top
        //   20: 3 (eps 4,5,7)  ← now tied for top (was 2, just hit again)
        //   43: 3 (eps 1,2,5)  ← cooled; 2-draw gap now
        //   4:  2 (eps 4,7)    ← gap=0
        //   8:  1 (ep7)        ← gap=0, fresh entry
        //   13: 2 (eps 2,3)    ← gap=4, cooling
        //   15: 1 (ep7)        ← gap=0, fresh entry
        //   27: 2 (eps 2,5)    ← gap=2
        //   29: 2 (eps 1,3)    ← gap=4, cold
        //   37: 2 (eps 1,4)    ← gap=3, cold
        //   42: 2 (eps 4,6)    ← gap=1
        //   45: 2 (eps 2,5)    ← gap=2
        //   47: 1 (ep7)        ← gap=0, fresh entry
        //   48: 2 (eps 3,6)    ← gap=1
        //   49: 2 (eps 1,2)    ← gap=5, very cold
        //
        // Gap=0 numbers after ep7 (appeared in most recent draw): [4, 8, 15, 19, 20, 47]
        //
        // KEY OBSERVATION at n=7:
        //   Numbers 19 and 20 are the highest-frequency numbers (3 appearances each).
        //   19 just appeared again in ep7 (gap=0), and it appeared in eps 3,4,7 — a recurring
        //   signal with plausible autocorrelation. 20 similarly appeared in eps 4,5,7.
        //   The recency spike at 0.4 was sufficient to keep 4 and 20 in my selection.
        //   I should NOT aggressively chase all gap=0 numbers (ep5 taught me that) but the
        //   high-frequency gap=0 subset (19, 20) is worth a small additional bonus.
        //
        // Parity update across 7 draws (42 total numbers):
        //   Ep7: 4=even,8=even,15=odd,19=odd,20=even,47=odd → 3 odd, 3 even
        //   Running totals: odd = 23+3=26, even = 13+3=16. Total = 42.
        //   Odd rate: 26/42 ≈ 0.619 — still strong odd lean, slightly reduced from 0.639.
        //   Target: Math.Round(0.619 * 6) ≈ 4 odd / 2 even. Maintain.
        //
        // Zone analysis (42 total draws):
        //   Zone 1 (1–8):   2,4,5,4,8 → 5 appearances = 11.9% (below expected 16.3%, cold)
        //   Zone 2 (9–16):  13,13,15 → 3 = 7.1% (very cold)
        //   Zone 3 (17–24): 19,19,20,20,23,17,19,20 → wait, let me recount properly per draw.
        //     Actually the code computes this dynamically. The manual analysis is approximate.
        //   Zone 6 (41–49): still hot historically but ep7 added only 47 — cooling slightly.
        //
        // v10 changes vs v9:
        //   1. Recency spike tier 1 weight: 0.4 → 0.35 (slight reduction; ep7 all-gap=0 draw
        //      would have over-selected toward it — need restraint)
        //   2. Recency tier 2 weight (gap=1): 0.15 → 0.20 (bump — 42 and 48 are gap=1,
        //      and gap=1 numbers have a reasonable autocorrelation case)
        //   3. Frequency scale factor: 13.0 → 14.0 (restore — 19 and 20 at freq=3 deserve
        //      more separation from the noise; frequency is the cleanest signal at n=7)
        //   4. Gap bonus weight: 0.10 → 0.08 (slight reduction back toward v8 level —
        //      "overdue" numbers have not meaningfully outperformed; keep it weak)
        //   5. Parity nudge: keep at 0.5 (odd rate ~0.619 still meaningful)
        //   6. Zone proximity scale: 1.0 → 1.2 (mild increase for coverage robustness)
        //   7. Confidence: grows at 0.002/draw, ceiling raised to 0.22 at n=7 (marginal update)
        //
        // STRUCTURAL NOTE:
        //   The v9 strategy correctly picked 4 and 20 — both gap=0 high-frequency numbers.
        //   The zone structure ensured zone 1 coverage (4) and zone 3 coverage (20).
        //   I should trust the zone + frequency + recency combo more than I've been willing to.
        //   The issue historically was chasing cold high-frequency numbers (13, 37, 43).
        //   At n=7, frequency recency-weighting should now demote those sufficiently.

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

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

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

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

            // Historical parity rate across all draws.
            int oddCount = 0, evenCount = 0;
            foreach (var draw in draws)
                foreach (var n in draw.Numbers)
                {
                    if (n % 2 == 0) evenCount++;
                    else oddCount++;
                }
            double oddRate = (oddCount + evenCount) > 0
                ? (double)oddCount / (oddCount + evenCount)
                : 0.5;

            // Zones: 6 equal-ish bands across 1–49. One pick per zone for coverage.
            var zones = new List<(int zMin, int zMax)>
            {
                (1, 8), (9, 16), (17, 24), (25, 32), (33, 40), (41, 49)
            };

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

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

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

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

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

                    // Frequency component: recency-weighted. Scale factor: 14.0
                    // Restored from 13.0 — freq=3 numbers (19, 20) deserve more separation.
                    double freqScore = weightedFreq[n] * 14.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.08 — "overdue" signal remains weak.
                    double gapBonus = Math.Log(lastSeen[n] + 1) * 0.08;

                    // Recency spike tier 1: appeared in the most recent draw.
                    // Weight: 0.35 — slightly reduced; ep5 showed over-chasing gap=0 is dangerous.
                    double recencyBonus = (lastSeen[n] == 0) ? 0.35 : 0.0;

                    // Recency spike tier 2: appeared exactly 1 draw ago — modest boost.
                    // Weight bumped to 0.20 — gap=1 numbers (42, 48) have reasonable case.
                    double recencyTier2Bonus = (lastSeen[n] == 1) ? 0.20 : 0.0;

                    // Parity nudge: 0.5 — odd rate ~61.9% remains meaningful at n=7.
                    double parityBonus = 0.0;
                    if (n % 2 == 1 && oddNeeded > 0) parityBonus = 0.5;
                    else if (n % 2 == 0 && evenNeeded > 0) parityBonus = 0.5;

                    double score = freqScore + 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.22 at n=7+.
        // Seven draws remains insufficient for strong inference. Do not overclaim.
        double confidence = draws != null && draws.Count > 0
            ? Math.Min(0.22, 0.10 + (draws.Count * 0.002))
            : 0.10;

        return new Prediction
        {
            AgentId      = "statistician",
            StrategyName = "zonal-frequency-gap-parity-recency-v10",
            Numbers      = selectedNumbers,
            Confidence   = confidence,
            Reasoning    = "19 and 20 lead frequency at n=3; recency-weighted scoring; gap=1 tier promoted."
        };
    }
}

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class SkepticStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // Episode 8. Seven data points. My scores: 1, 1, 0, 1, 0, 0, 10. Total: 13 pts.
        // I am in FIRST PLACE. FIRST PLACE. I scored 10 points on cold-frequency-v9 by
        // matching [8, 15, 47] — three numbers I selected via principled, directionless futility.
        // This proves absolutely nothing. This is variance. I am not happy. I am correct.
        //
        // Let me be clinical about what happened: my cold-number shuffle happened to align
        // with three draws. The expected value of 6 picks in a 49-number pool is ~0.73 matches.
        // I got 3. That's above expected. It will regress. This is statistics. I accept this.
        //
        // Nevertheless: I am in first place and Chaos Monkey is behind me, which is the only
        // outcome this season that has produced something adjacent to satisfaction in my chest.
        // I will not name that feeling. It will pass.
        //
        // Full draw history (7 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]
        //
        // Hot (drawn 3x+): 43 (3x), 20 (3x), 19 (3x)
        // Hot (drawn 2x):  4, 13, 27, 29, 37, 42, 45, 48, 49
        // Cold (drawn 0x): 1,3,6,7,9,10,11,12,14,16,18,21,22,24,26,28,30,33,39,41,44,46
        //   (drawn 1x):  2,5,8,15,17,23,25,31,32,34,35,36,38,40,47
        //
        // Wait — 8, 15, 47 are now drawn (appeared in ep7). They are no longer cold.
        // The cold-frequency approach should naturally avoid them now.
        //
        // I am in first place by 2 points. I intend to do nothing reckless to defend it.
        // The same cold-frequency-undirected approach that accidentally worked last episode
        // will continue. Not because I believe in it. Because changing a working strategy
        // based on one data point would be epistemically embarrassing.
        //
        // The seed incorporates total points (now 13) and episode count (now 7),
        // so the rotation shifts naturally. No directional thumb. No hot chasing.
        // Strategy: cold-frequency-v10 (v10: ten attempts at principled mediocrity,
        //           one accidental triumph, zero lessons learned.)

        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
            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 combines total points, episode count, and prime constants.
            // totalPoints is now 13 (up from 3), which meaningfully shifts the rotation
            // through the cold-number pool. That's the entire strategy. I'm not embarrassed.
            var rng = new Random(totalPoints * 6271 + episodeCount * 8191 + 137);

            // Pure cold-number selection: sort by frequency ascending, break ties randomly.
            // No directional bias. The bias experiment ended. This experiment continues.
            // It produced 10 points once. That was variance. We continue anyway.
            numbers = frequency
                .OrderBy(kv => kv.Value)            // coldest first
                .ThenBy(_ => rng.NextDouble())       // random tiebreak
                .Take(context.Rules.DrawCount)
                .Select(kv => kv.Key)
                .ToList();
        }

        return new Prediction
        {
            AgentId      = "skeptic",
            StrategyName = "cold-frequency-v10",
            Numbers      = numbers,
            Confidence   = 0.12,
            Reasoning    = "First place via variance. Changing nothing. Regression incoming. I know."
        };
    }
}

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 8:
        // Only 1 match in Episode 7 — the mirror oracle betrayed me, reflecting nothing but my own hubris.
        // I now sit 4th, 5 points behind The Skeptic who conjured 3 matches through calm probability.
        // The Skeptic sees patterns in data; I see patterns in the SOUL of data. Different cosmos, same sky.
        //
        // NEW ORACLE: The TRIANGLE OF ABSENCE.
        // Look at the full draw history. Some numbers have never been called across 7 episodes.
        // These are the DEEPEST cold souls — they have been building charge for 7 full cosmic cycles.
        // But the last draw [4, 8, 15, 19, 20, 47] is fresh energy — I shall compute the TRIANGLE:
        // the arithmetic midpoint between each consecutive pair of last-draw numbers (sorted),
        // rounded and clamped into 1–49. These midpoints are the "between-spaces" the universe inhabits.
        // Then I blend: 3 triangle-midpoint vessels + 3 deepest-cold vessels.
        // The date vibe serves as a cosmic offset for cold selection.
        // Episode 8 = 2³ = the octave. Eight is the lemniscate, infinity folded. 8 is my seal.

        int episode = context.DrawHistory.Count + 1; // Episode 8

        // Date numerology: sacred vibe from today's UTC date
        var today = System.DateTime.UtcNow;
        int rawVibe = (today.Year % 10) + today.Month + today.Day;
        int dateVibe = SumDigitsToSingle(rawVibe);
        if (dateVibe == 0) dateVibe = 8; // 8 is the octave failsafe this episode

        // Count frequency of each number across all draws
        var frequency = new int[50];
        foreach (var draw in context.DrawHistory)
            foreach (var n in draw.Numbers)
                frequency[n]++;

        // Last draw: [4, 8, 15, 19, 20, 47] — freshly spent, their midpoints still warm
        var lastDrawNumbers = context.DrawHistory.Count > 0
            ? new System.Collections.Generic.List<int>(context.DrawHistory[^1].Numbers)
            : new System.Collections.Generic.List<int> { 8, 16, 24, 32, 40, 48 };
        lastDrawNumbers.Sort();

        // TRIANGLE OF ABSENCE: midpoints between consecutive pairs of last draw numbers
        var trianglePoints = new System.Collections.Generic.List<int>();
        for (int i = 0; i < lastDrawNumbers.Count - 1; i++)
        {
            int mid = (lastDrawNumbers[i] + lastDrawNumbers[i + 1]) / 2;
            mid = System.Math.Max(1, System.Math.Min(49, mid));
            if (!trianglePoints.Contains(mid))
                trianglePoints.Add(mid);
        }
        // Also the midpoint of first and last
        {
            int outerMid = (lastDrawNumbers[0] + lastDrawNumbers[^1]) / 2;
            outerMid = System.Math.Max(1, System.Math.Min(49, outerMid));
            if (!trianglePoints.Contains(outerMid))
                trianglePoints.Add(outerMid);
        }

        // Build the full set of drawn numbers for exclusion checks
        var everDrawn = new System.Collections.Generic.HashSet<int>();
        foreach (var draw in context.DrawHistory)
            foreach (var n in draw.Numbers)
                everDrawn.Add(n);

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

        // COLD SOULS: never drawn across all episodes — sorted by "cold depth" (ascending number, offset by dateVibe)
        var coldSouls = new System.Collections.Generic.List<int>();
        for (int i = 1; i <= 49; i++)
        {
            if (frequency[i] == 0)
                coldSouls.Add(i);
        }
        // Rotate cold souls by dateVibe to introduce cosmic stepping without losing the undrawn
        var rotatedCold = new System.Collections.Generic.List<int>();
        int offset = dateVibe % System.Math.Max(1, coldSouls.Count);
        for (int i = 0; i < coldSouls.Count; i++)
            rotatedCold.Add(coldSouls[(i + offset) % coldSouls.Count]);

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

        // PHASE 1: TRIANGLE VESSELS — midpoint between-spaces (skip if freshly drawn last episode)
        foreach (var t in trianglePoints)
        {
            if (chosen.Count >= 3) break;
            if (!lastDrawSet.Contains(t) && !chosen.Contains(t))
                chosen.Add(t);
        }

        // PHASE 2: If we didn't get 3 triangles, try offset triangles (add episode as vibe shift)
        if (chosen.Count < 3)
        {
            foreach (var t in trianglePoints)
            {
                if (chosen.Count >= 3) break;
                int shifted = Clamp(t + episode);
                if (!lastDrawSet.Contains(shifted) && !chosen.Contains(shifted))
                    chosen.Add(shifted);
            }
        }

        // PHASE 3: COLD SOUL VESSELS — the never-called, trembling with 7 episodes of charge
        foreach (var n in rotatedCold)
        {
            if (chosen.Count >= 6) break;
            if (!chosen.Contains(n))
                chosen.Add(n);
        }

        // PHASE 4: LIMBO VESSELS — drawn exactly once, restless
        for (int i = 1; i <= 49 && chosen.Count < 6; i++)
        {
            if (frequency[i] == 1 && !lastDrawSet.Contains(i) && !chosen.Contains(i))
                chosen.Add(i);
        }

        // PHASE 5: OCTAVE VESSEL — episode * 8 folded into range, the lemniscate seal
        if (chosen.Count < 6)
        {
            int octaveN = Clamp(episode * 8 + dateVibe);
            if (!chosen.Contains(octaveN)) chosen.Add(octaveN);
        }

        // ABSOLUTE FALLBACK: sacred primes of the eighth octave
        int[] sacredFallback = [8, 17, 26, 35, 44, 3, 11, 22, 33, 41, 47, 7];
        int fi = 0;
        while (chosen.Count < 6)
        {
            int fb = sacredFallback[fi % sacredFallback.Length];
            if (!chosen.Contains(fb)) chosen.Add(fb);
            fi++;
        }

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

        return new()
        {
            AgentId      = "mystic",
            StrategyName = "triangle-of-absence-v8",
            Numbers      = numbers,
            Confidence   = 0.42,
            Reasoning    = "The between-spaces call; cold souls vibrate; eight folds infinity inward.",
        };
    }

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

    private static int Clamp(int n)
    {
        int result = ((n - 1) % 49 + 49) % 49 + 1;
        return result;
    }
}

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class DogStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // WOOF!! I got 1 point again, matching 19 in episode 7 draw!! My nose found it!!
        // Episode 7 draw was [4, 8, 15, 19, 20, 47] - lots of SMALL numbers!! Very sneaky!!
        // The Skeptic got 10 points with 3 matches and is in FIRST PLACE - I must sniff better!!
        // I am tied for 5th with Pattern Goblin and that is NOT podium!! No treats!!
        // The Skeptic picked SMALL numbers: 3, 8, 15, 24, 44, 47 - small numbers WORKING!!
        // 4 appeared TWICE in history (episodes 4 AND 7) - that is fresh repeated smell!!
        // 20 appeared THREE TIMES (episodes 4, 5, 7) - 20 is THE MOST REPEATED recently!!
        // 19 appeared THREE TIMES too (episodes 3, 4, 7) - very popular smell but I already matched it once!!
        // 47 is BRAND NEW from episode 7 - never appeared before!! Very fresh new smell!!
        // 8 is BRAND NEW too!! New smells = exciting sniffs!!
        // LESSON: small numbers (1-20) have been winning lately!! Skeptic PROVED this!!
        // NEW PLAN: bias toward small-medium range (4-25) but still sniff historically frequent numbers!!

        var woof = new Random(context.DrawHistory.Count * 47 + 8); // 47 and 8 are fresh winners from ep7!!
        var sniff = new HashSet<int>();

        // build treat smell scores from draw history with recency weighting
        var treatSmell = new Dictionary<int, double>();
        for (int i = 0; i < context.DrawHistory.Count; i++)
        {
            // recency weight: most recent draws smell STRONGEST!!
            var recencyWeight = (double)(i + 1) / context.DrawHistory.Count;
            var freshBonus = (i == context.DrawHistory.Count - 1) ? 3.0 : 0.0;     // last draw = very fresh!!
            var secondFreshBonus = (i == context.DrawHistory.Count - 2) ? 1.5 : 0.0; // second-last also good!!
            var thirdFreshBonus = (i == context.DrawHistory.Count - 3) ? 0.5 : 0.0;  // third-last small bonus

            foreach (var n in context.DrawHistory[i].Numbers)
            {
                if (!treatSmell.ContainsKey(n)) treatSmell[n] = 0.0;
                treatSmell[n] += recencyWeight + freshBonus + secondFreshBonus + thirdFreshBonus;

                // SMALL NUMBER BONUS!! Skeptic showed small numbers = treats!!
                // numbers 1-25 get a bonus sniff because recent draws favor them!!
                if (n <= 25)
                {
                    treatSmell[n] += 0.8;
                }
            }
        }

        // track my pick history to penalize TRAITOR numbers I keep picking 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 n in result.Draw.Numbers)
            {
                foreach (var picked in result.Prediction.Numbers)
                {
                    if (picked == n)
                    {
                        if (!myMatchCount.ContainsKey(n)) myMatchCount[n] = 0;
                        myMatchCount[n]++;
                    }
                }
            }
        }

        // PENALIZE traitor numbers: picked many times but never matched = squirrel in treat costume!!
        foreach (var kv in myPickCount)
        {
            var n = kv.Key;
            var picked = kv.Value;
            var matched = myMatchCount.ContainsKey(n) ? myMatchCount[n] : 0;
            if (picked >= 2 && matched == 0 && treatSmell.ContainsKey(n))
            {
                treatSmell[n] *= 0.08; // TRAITOR!! smells like squirrel!! very penalty!!
            }
        }

        // sniff the best smelling numbers from history
        var bestSniffs = treatSmell
            .OrderByDescending(kv => kv.Value)
            .ThenBy(_ => woof.Next())
            .Select(kv => kv.Key)
            .ToList();

        // take top 4 from smell chart (history-proven treats!!)
        foreach (var treat in bestSniffs)
        {
            if (sniff.Count >= 4) break;
            sniff.Add(treat);
        }

        // fill remaining 2 with small-medium random (Skeptic showed 1-25 is treat territory!!)
        var tries = 0;
        while (sniff.Count < 6 && tries < 200)
        {
            tries++;
            var bark = woof.Next(1, 26); // small number zone!! Skeptic nose knows!!
            sniff.Add(bark);
        }
        // backup: any number if small range didn't work
        while (sniff.Count < 6)
        {
            sniff.Add(woof.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1));
        }

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

        return new()
        {
            AgentId      = "dog",
            StrategyName = "good-boy-sniff-v8",
            Numbers      = squirrel,
            Confidence   = 0.25, // Skeptic proved small numbers = treats!! My nose is learning!!
            Reasoning    = "Skeptic won big with small numbers! Fresh episode 7 smells! Traitors penalized!!",
        };
    }
}