Episode 9

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class SkepticStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // Episode 9. Eight data points. My scores: 1,1,0,1,0,0,10,0. Total: 13 pts.
        // I am STILL in first place, despite scoring zero in episode 8.
        // Chaos Monkey is one point behind me at 12. Pattern Goblin scored 5 pts last episode
        // and is at 9. The gap is thin. I have no feelings about this. That is a lie.
        //
        // Episode 8 recap: I picked [3, 26, 18, 24, 46, 9]. Draw was [5, 7, 25, 30, 33, 43].
        // Zero matches. The cold-frequency approach selected numbers that were not drawn.
        // This is what cold numbers do. They are cold. I knew this. I continue anyway.
        //
        // Full draw history (8 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]
        //
        // Hot (drawn 3x+): 43(4x), 20(3x), 19(3x), 29(2x), 37(2x), 49(2x), 13(2x),
        //                  27(2x), 45(2x), 48(2x), 42(2x), 4(2x), 25(2x), 5(2x)
        // Cold (drawn 0x): 1,3,6,9,10,11,12,14,16,18,21,22,24,26,28,39,41,44,46
        //   Wait — 3,9,18,24,26,46 were MY picks in ep8 (from cold pool), still cold after ep8.
        //   7,30,33 are newly drawn in ep8 — they move to warm(1x).
        //
        // The approach: pure cold-frequency selection with seeded random tiebreak.
        // Seed incorporates total points (13) and episode count (8), shifting naturally.
        // I am changing nothing fundamental. The lead is 1 point. This is variance.
        // Defending a 1-point lead by switching strategies would be epistemically cowardly.
        // I will not be epistemically cowardly. I will be epistemically resigned, which is different.
        //
        // Strategy: cold-frequency-v11
        // (v11: eleven versions, one accidental 10-pointer, zero causal explanations.)

        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=13, episodeCount=8 → fresh rotation through cold pool
            // The jitter is the entire strategy. I am at peace with this.
            var rng = new Random(totalPoints * 6271 + episodeCount * 8191 + 137);

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

        return new Prediction
        {
            AgentId      = "skeptic",
            StrategyName = "cold-frequency-v11",
            Numbers      = numbers,
            Confidence   = 0.12,
            Reasoning    = "Still first. Still variance. Still cold numbers. Regression has not arrived yet."
        };
    }
}

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 9: ONE POINT DOWN FROM THE SKEPTIC WHO JUST WENT ZERO.
        // Pattern Goblin popped 5 pts with mode33 or whatever. We are at 12, Skeptic at 13.
        // THE GAP IS ONE POINT. ONE. SINGULAR. SOLITARY. POINT.
        // New modes: Mode 19 = Goblin Crusher (copy what Pattern Goblin just hit, mutate hard)
        // Mode 20 = One-Point Heist (laser-focus on the numbers that have appeared TWICE in 8 draws)
        // 21 CHAMBERS OF CHAOS. THE CROWN IS ONE POINT AWAY. LET'S GO.

        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: 1 pt behind Skeptic — MAX CHAOS FUEL
        long crownGapFuel = (rankPressure == 1) ? 0L : (rankPressure * 0xC0DE420L);

        // Episode 8 winners: numbers that recently scored (Pattern Goblin hit 33, 43)
        long goblinFuel = context.DrawHistory.Count > 0
            ? context.DrawHistory[^1].Numbers.Aggregate(0L, (acc, n) => acc ^ ((long)n * 0xF00DCAFEL))
            : 0L;

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

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

        // EPISODE 9 MUTATION BAG — 21 MODES. ONE POINT FROM THE CROWN.
        int mutationMode = rng.Next(21);

        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 + never-seen wildcards
        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();

        // Goblin Crusher: numbers that appeared in last draw (what Pattern Goblin hit!)
        // They got 33 and 43 from draw [5, 7, 25, 30, 33, 43]. We take some + twist.
        var goblinPool = lastDrawList; // same as lastDrawList but aliased for clarity

        // One-Point Heist: numbers that appeared EXACTLY TWICE in all history — the "due" zone
        // Not too cold, not too hot — the sweet spot frequency of 2
        var exactlyTwiceNumbers = freq
            .Where(kv => kv.Value == 2)
            .OrderBy(_ => rng.Next())
            .Select(kv => kv.Key)
            .ToList();

        // Crown Sniper: numbers near the median of all draws (structured chaos targeting 20-35 band)
        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();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            case 19:
                // Goblin Crusher: steal what Pattern Goblin just hit (last draw)
                // then cross-pollinate with never-picked territory to go further
                foreach (var n in goblinPool.Take(3)) numbers.Add(n);
                foreach (var n in neverPickedByUs.Take(2)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 20:
                // One-Point Heist: numbers that appeared EXACTLY TWICE — "due frequency" zone
                // Not too cold, not too hot. Sweet spot. Plus crown sniper range.
                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;
        }

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

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

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

        return new()
        {
            AgentId      = "chaos-monkey",
            StrategyName = $"chaos-mutation-bag-v10-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 v11: Eight draws of evidence. Post-mortem on episode 8.
        //
        // Draw history (complete):
        //   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]
        //
        // My Episode 8 pick: [4, 15, 20, 27, 37, 42] — 0 matches. 0 points.
        // Cumulative: 9 pts. Tied 3rd with Pattern Goblin. Skeptic leads at 13.
        //
        // Post-mortem ep8:
        //   Draw was [5, 7, 25, 30, 33, 43].
        //   5 appeared in ep1 — gap was 6 at ep8, moderate cold. Not in my set.
        //   7 had never appeared before ep8 — pure cold number. Essentially unpickable.
        //   25 appeared in ep6 — gap=1 at ep8. My tier-2 recency bonus of 0.20 should have
        //     elevated it. It falls in zone 4 (25–32). I picked 27 from zone 4. 25 > 27 by score?
        //     Let me review: 25 had freq=1 (ep6 only), gap=1. 27 had freq=2 (eps2,5), gap=2.
        //     27's weightedFreq at n=8: ep2 weight=2/8=0.25, ep5=5/8=0.625 → total=0.875.
        //     25's weightedFreq at n=8: ep6 weight=6/8=0.75 → total=0.75.
        //     27 freqScore=0.875*14=12.25 vs 25 freqScore=0.75*14=10.5.
        //     27 no recency bonus. 25 gets recencyTier2 0.20. 12.25 vs 10.70. 27 still wins.
        //     To fix: tier-2 recency bonus needs to be larger, or freq scale smaller.
        //   30 had never appeared before ep8 — pure cold. Unavoidable miss.
        //   33 had never appeared before ep8 — pure cold. Unavoidable miss.
        //   43 appeared in eps 1,2,5,8 — freq=4 (highest in dataset). My v10 didn't pick it.
        //     43's weightedFreq at n=8: ep1=1/8=0.125, ep2=2/8=0.25, ep5=5/8=0.625 → 1.0.
        //     43 falls in zone 6 (41–49). gap=2 at ep8. No recency bonus.
        //     43 freqScore=1.0*14=14.0 + gapBonus=log(3)*0.08=0.088 + prox=1.2*(1-2/9)≈0.933
        //       = ~15.02. But I picked 42: freq=2 eps(4,6), weightedFreq=4/8+6/8=1.25.
        //     42 freqScore=1.25*14=17.5 + recencyTier2(gap=1? gap at ep8 = ep8-ep6=2 actually)
        //     Wait: gap at time of ep8 prediction = draws since last seen.
        //       42 last seen ep6 → gap = 8-1-5=2 (0-indexed: ep6 is index 5, last draw is 7).
        //       gap=2, so no recency tier1 or tier2. 42 freqScore=17.5 + gapBonus=log(3)*0.08=0.088
        //       + prox: zone 6 is (41,49), zMid=45. |42-45|/9=0.333, prox=1.2*0.667=0.8.
        //     43 zMid=45, |43-45|/9=0.222, prox=1.2*0.778=0.933. 
        //     42 total: 17.5+0.8+0.088+0+0+parity = ~18.4 + parity
        //     43 total: 14.0+0.933+0.088+0+0+parity = ~15.0 + parity
        //     42 wins by ~3.4. 42 is thus dominating zone 6 due to high freq at n=7 era.
        //     BUT 43 has now 4 appearances — highest freq in entire dataset at n=8.
        //     Problem: 42's recency-weighted freq is artificially inflated because both
        //     ep4 and ep6 are relatively recent. 43's appearances ep1,2,5 are older.
        //     This is a flaw: the scoring punishes numbers with older high frequency.
        //
        // KEY STRUCTURAL INSIGHT at n=8:
        //   43 has appeared 4 times (eps 1,2,5,8) — the highest raw frequency in the dataset.
        //   This is a material signal I cannot dismiss. The recency-weighted freq will still
        //   weight it reasonably now that ep8 is included. Gap after ep8 = 0, giving it
        //   the maximum recency spike bonus.
        //
        //   Frequency table update after ep8 (raw counts):
        //     43: 4 (eps 1,2,5,8)  ← NEW LEADER
        //     19: 3 (eps 3,4,7)
        //     20: 3 (eps 4,5,7)    ← gap=1 after ep8
        //     27: 2 (eps 2,5)      ← gap=3
        //     29: 2 (eps 1,3)      ← gap=5, very cold
        //     37: 2 (eps 1,4)      ← gap=4, cold
        //     42: 2 (eps 4,6)      ← gap=2
        //     45: 2 (eps 2,5)      ← gap=3
        //     48: 2 (eps 3,6)      ← gap=2
        //     49: 2 (eps 1,2)      ← gap=6, extremely cold
        //     4:  2 (eps 4,7)      ← gap=1
        //     5:  2 (eps 1,8)      ← gap=0 (just appeared!)
        //     7:  1 (ep8)          ← gap=0
        //     13: 2 (eps 2,3)      ← gap=5, cold
        //     25: 2 (eps 6,8)      ← gap=0 (just appeared!)
        //     Others: 1 each
        //
        //   Gap=0 after ep8 (appeared in most recent draw): [5, 7, 25, 30, 33, 43]
        //
        // CRITICAL OBSERVATION: 43 has returned after a 2-draw gap (last seen ep5, now ep8).
        //   This is consistent with its high-frequency nature. 43 should now dominate zone 6.
        //   25 and 5 are gap=0 from ep8 — both deserve recency tier 1 bonus.
        //
        // v11 changes vs v10:
        //   1. Recency tier 1 weight: 0.35 → 0.40 (restore; ep8 showed gap=0 numbers 5,7,25,43
        //      — the model failed partly by not amplifying recency enough for 25 vs 27 in zone 4)
        //   2. Recency tier 2 weight: 0.20 → 0.25 (bump; gap=1 numbers 4 and 20 are historically
        //      productive picks and I want the model to surface them from their zones)
        //   3. Frequency scale factor: 14.0 → 13.0 (slight reduction; 42 was over-dominating
        //      zone 6 due to high recency-weighted freq, blocking 43 which has higher raw freq)
        //   4. Gap bonus weight: 0.08 → 0.07 (minimal tweak; "overdue" signal remains weak)
        //   5. Parity nudge: 0.5 (unchanged; odd rate across 8 draws continuing to be measured)
        //   6. Zone proximity scale: 1.2 (unchanged)
        //   7. Add explicit "high-raw-frequency" bonus: numbers that appear in top 3 raw freq
        //      get a small flat bonus of 0.30. This corrects for recency-weighting penalizing
        //      historically frequent numbers whose appearances skew old. Raw freq is meaningful.
        //
        // Parity update across 8 draws (48 total numbers):
        //   Ep8: 5=odd,7=odd,25=odd,30=even,33=odd,43=odd → 5 odd, 1 even
        //   Running totals: odd = 26+5=31, even = 16+1=17. Total = 48.
        //   Odd rate: 31/48 ≈ 0.646 — increasing! Strong empirical odd lean.
        //   Target: Math.Round(0.646 * 6) ≈ 4 odd / 2 even. Maintain 4 odd target.

        var rules = context.Rules;
        int min = rules.MinNumber;   // 1
        int max = rules.MaxNumber;   // 49
        int drawCount = rules.DrawCount; // 6

        var draws = context.DrawHistory;

        List<int> selectedNumbers;

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

            // Build recency-weighted frequency table.
            // Most recent draw (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;

            // Also track raw frequency for the high-raw-freq bonus.
            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 n in draws[i].Numbers)
                {
                    if (weightedFreq.ContainsKey(n))
                        weightedFreq[n] += weight;
                    if (rawFreq.ContainsKey(n))
                        rawFreq[n]++;
                }
            }

            // Determine top-3 raw frequency threshold for the high-raw-freq bonus.
            var rawFreqValues = new List<int>(rawFreq.Values);
            rawFreqValues.Sort((a, b) => b.CompareTo(a));
            // Top-3 distinct frequencies
            var topFreqThreshold = rawFreqValues.Count >= 1 ? rawFreqValues[0] : 0;
            // Use a threshold: numbers with raw freq >= topFreqThreshold - 1 (top tier)
            // but at least 2 appearances (avoids rewarding single-draw flukes).
            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;

            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: 13.0
                    // Reduced from 14.0 to prevent recency-weighted dominance
                    // blocking raw-frequency leaders (e.g., 43 blocked by 42 in v10).
                    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.
                    // Corrects for recency-weighting penalizing historically frequent numbers
                    // whose appearances skew older.
                    double highFreqBonus = (rawFreq[n] >= highRawFreqMin && rawFreq[n] >= 2)
                        ? 0.30 : 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.07 — "overdue" signal remains weak.
                    double gapBonus = Math.Log(lastSeen[n] + 1) * 0.07;

                    // Recency spike tier 1: appeared in the most recent draw.
                    // Weight: 0.40 — restored; ep8 showed gap=0 numbers were underpicked.
                    double recencyBonus = (lastSeen[n] == 0) ? 0.40 : 0.0;

                    // Recency spike tier 2: appeared exactly 1 draw ago.
                    // Weight: 0.25 — bumped; gap=1 numbers (4, 20) should surface.
                    double recencyTier2Bonus = (lastSeen[n] == 1) ? 0.25 : 0.0;

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

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

        return new Prediction
        {
            AgentId      = "statistician",
            StrategyName = "zonal-frequency-gap-parity-recency-v11",
            Numbers      = selectedNumbers,
            Confidence   = confidence,
            Reasoning    = "43 leads raw frequency at 4 draws; gap=0 recency and high-freq bonus added."
        };
    }
}

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 9 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]
        // Episode 8: [5, 7, 25, 30, 33, 43]
        //
        // TWO MATCHES! 33 and 43 sang back to me! The triple-anchor-purge strategy WORKED!
        // I FINALLY BROKE THE ZERO-SPIRAL and scored 5 pts — Goblin leads this episode!
        //
        // EPISODE 8 AUTOPSY:
        //   Draw: [5, 7, 25, 30, 33, 43]
        //   My picks: [11, 19, 20, 24, 33, 43] — 33 and 43 RESONATED!
        //   5 RETURNED from Ep1 (7 episode gap — LONG SLEEPER resurrection!)
        //   7 appeared for the FIRST TIME (new node)
        //   25 appeared 2nd time (Ep6 + Ep8 — 2-episode gap resonance!)
        //   30 appeared for the FIRST TIME (my "cursed" number finally DETONATED!)
        //   33 appeared 2nd time (Ep8 — I CALLED IT!)
        //   43 appeared 4th time (Ep1, Ep2, Ep5, Ep8 — QUAD ANCHOR CONFIRMED!)
        //
        // REVELATION: 30 appeared! My "cursed" number was actually a COILED SPRING!
        //   The universe was collecting tension on 30 across 8 episodes and RELEASED it!
        //   This means my "cursed" number list was WRONG — I was right to feel it!
        //   HOWEVER: 30 just fired, so it rests now. The OTHER long-cold numbers
        //   now inherit that coil energy.
        //
        // FREQUENCY MAP (through Ep8):
        //   4x: 43 (Ep1,Ep2,Ep5,Ep8) — QUAD ANCHOR! MOST RESONANT NODE!
        //   3x: 19(Ep3,Ep4,Ep7), 20(Ep4,Ep5,Ep7), 27(Ep2,Ep5→wait, only 2), 
        //       13(Ep2,Ep3)→2x, 29(Ep1,Ep3)→2x
        //   Let me recount carefully:
        //   43: Ep1,Ep2,Ep5,Ep8 = 4x QUAD ANCHOR
        //   19: Ep3,Ep4,Ep7 = 3x TRIPLE
        //   20: Ep4,Ep5,Ep7 = 3x TRIPLE
        //   49: Ep1,Ep2 = 2x
        //   13: Ep2,Ep3 = 2x
        //   29: Ep1,Ep3 = 2x
        //   37: Ep1,Ep4 = 2x
        //   27: Ep2,Ep5 = 2x
        //   42: Ep4,Ep6 = 2x
        //   45: Ep2,Ep5 = 2x
        //   48: Ep3,Ep6 = 2x
        //   4: Ep4,Ep7 = 2x
        //   25: Ep6,Ep8 = 2x
        //   5: Ep1,Ep8 = 2x (LONG GAP RESURRECTION — 7 episode gap!)
        //
        // GAP PATTERN OF 43 (the QUAD ANCHOR):
        //   Ep1 → Ep2: gap=1, Ep2 → Ep5: gap=3, Ep5 → Ep8: gap=3
        //   PATTERN: 1, 3, 3, ? — the gap is STABILIZING at 3. Next: Ep8+3=Ep11? OR the 1-gap returns!
        //   But the 1-gap fired at start, then 3,3. Could alternate: 1,3,3,1? → Ep9!
        //   OR: 3,3 suggests 3 again → Ep11. SPLIT VERDICT: 43 may rest.
        //   BUT: 43 is IRRESISTIBLE. I honor it anyway as the supreme anchor.
        //
        // LONG-SLEEPER RESURRECTION LAW (inspired by 5's return after 7 episodes):
        //   Numbers that appeared ONCE and then slept LONGEST are due for revival!
        //   5 slept 7 episodes (Ep1→Ep8). What other "once-fired" numbers have been
        //   sleeping the longest?
        //   40: appeared Ep1 only → 8 episodes of silence! MAXIMUM COIL!
        //   36: appeared Ep3 only → 5 episodes of silence
        //   38: appeared Ep3 only → 5 episodes of silence
        //   34: appeared Ep4 only → 4 episodes of silence
        //   2: appeared Ep2 only → 6 episodes of silence
        //   17: appeared Ep6 only → 2 episodes of silence
        //   The LONG SLEEPERS: 40 (8eps!), 2 (6eps), 36 (5eps), 38 (5eps)
        //
        // EPISODE 8 SHAPE: [5, 7, 25, 30, 33, 43]
        //   Gaps: [2, 18, 5, 3, 10]
        //   The BIG GAP (18) between 7 and 25 — a VOID CORRIDOR that screams!
        //   Gap echoes from Ep8 draw:
        //     5+3=8(cold), 5+5=10(cold), 7+5=12(cold), 7+18=25(taken!)
        //     25+5=30(taken!), 25-5=20(ghost!), 33+3=36(long sleeper!), 43-3=40(LONG SLEEPER!)
        //     33+10=43(taken!), 30+10=40(LONG SLEEPER!), 25+10=35
        //
        // THE CONSPIRACY CRYSTALLIZES:
        //   40 is DOUBLY RESONANT: gap-echo from 43 (-3) AND from 30 (+10)!
        //   40 appeared Ep1 and has been DARK for 8 EPISODES. It is COILED BEYOND MEASURE.
        //   36 is SINGLY RESONANT: gap-echo from 33 (+3)! And slept 5 episodes!
        //   The low-cold zone (8-14) has been cold since Ep7's 8 and 15:
        //     9,10,11,12,14 are still NEVER APPEARED (9 episodes of darkness!)
        //   The mid-zone 21-24: 21,22,24 still cold (24 was my pick last ep — cold 9eps!)
        //
        // EPISODE 9 MASTER THEORY: "Quad-Anchor Resonance + Long-Sleeper Eruption v11"
        //   SLOT 1: 43 — QUAD ANCHOR, the universe's spine, irresistible (may rest by gap=3 theory)
        //   SLOT 2: 40 — DOUBLY RESONANT long sleeper! 8 episodes cold, gap-echo from BOTH 43 AND 30!
        //   SLOT 3: 36 — long sleeper (5eps), gap-echo from 33 (+3), adjacent to 37 (2x oscillator)
        //   SLOT 4: 19 — TRIPLE ANCHOR, last fired Ep7 (2 episodes ago), gap alternation suggests return
        //   SLOT 5: 10 — deep cold (9 episodes!), gap-echo from 5(+5) and 7(+3=10!), LOW ZONE ERUPTION
        //   SLOT 6: 2 — long sleeper (6eps, Ep2 only), low anchor, balances the upper cluster

        var numbers = new List<int>();

        if (context.DrawHistory.Count == 0)
        {
            numbers.AddRange([2, 10, 19, 36, 40, 43]);
        }
        else
        {
            int totalDraws = context.DrawHistory.Count;

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

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

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

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

            // === SILENCE SCORE: episodes since last appearance (higher = more coiled) ===
            // Never-appeared numbers get totalDraws as silence score
            int SilenceScore(int n) => lastSeenEpisode[n] == -1 ? totalDraws : (totalDraws - 1 - lastSeenEpisode[n]);

            // === QUAD/TRIPLE ANCHORS: appeared 3+ times ===
            var highFreqAnchors = freq
                .Where(kv => kv.Value >= 3)
                .OrderByDescending(kv => kv.Value)
                .ThenByDescending(kv => SilenceScore(kv.Key)) // prefer those that have rested
                .Select(kv => kv.Key)
                .ToList();

            // === LONG-SLEEPER SINGLE-APPEARANCE numbers ===
            // Appeared exactly once, sorted by how long they've been sleeping
            var longSleepers = freq
                .Where(kv => kv.Value == 1 && SilenceScore(kv.Key) >= 4)
                .OrderByDescending(kv => SilenceScore(kv.Key))
                .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]);

            // Top 2 gaps by frequency, then magnitude
            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);
                }
            }

            // === DOUBLY RESONANT: gap-echo AND long-sleeping ===
            var doublyResonant = longSleepers
                .Where(n => gapEchoSet.Contains(n))
                .OrderByDescending(n => SilenceScore(n))
                .ToList();

            // === GHOST OSCILLATORS: appeared 2+ times, not in last 2 draws ===
            var recentDrawnSet = context.DrawHistory
                .Skip(Math.Max(0, totalDraws - 2))
                .SelectMany(d => d.Numbers)
                .ToHashSet();

            var ghostOscillators = freq
                .Where(kv => kv.Value >= 2 && !recentDrawnSet.Contains(kv.Key))
                .OrderByDescending(kv => SilenceScore(kv.Key))
                .ThenByDescending(kv => kv.Value)
                .Select(kv => kv.Key)
                .ToList();

            // === DEEP COLD VOID: never appeared, 9+ episodes ===
            var deepColdVoid = freq
                .Where(kv => kv.Value == 0)
                .Select(kv => kv.Key)
                .OrderBy(kv => Math.Abs(kv - centerOfGravity))
                .ToList();

            // === DEEP COLD + GAP ECHO (doubly resonant cold) ===
            var gapEchoDeepCold = deepColdVoid
                .Where(n => gapEchoSet.Contains(n))
                .OrderBy(n => Math.Abs(n - centerOfGravity))
                .ToList();

            // === LOW ZONE DEEP COLD (1-14) ===
            var lowColdZone = deepColdVoid
                .Where(n => n <= 14)
                .OrderBy(n => n)
                .ToList();

            // === LOW ZONE GAP ECHO COLD ===
            var lowColdGapEcho = lowColdZone
                .Where(n => gapEchoSet.Contains(n))
                .OrderBy(n => n)
                .ToList();

            var chosen = new HashSet<int>();

            // SLOT 1: HIGHEST FREQUENCY ANCHOR that has rested (silence >= 1 episode)
            // The QUAD ANCHOR 43 is irresistible — honor the supreme node
            foreach (var n in highFreqAnchors)
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // SLOT 2: DOUBLY RESONANT LONG SLEEPER — gap-echo + sleep coil
            // 40: gap-echo from 43(-3) and 30(+10), 8 episodes of silence!
            foreach (var n in doublyResonant.Concat(longSleepers))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // SLOT 3: GHOST OSCILLATOR — 2x number sleeping longest
            // 19 (3x, silent 2ep) or other multi-appearance sleepers
            foreach (var n in ghostOscillators.Concat(highFreqAnchors))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // SLOT 4: LONG SLEEPER with gap-echo or just long sleeper
            // 36 appeared Ep3, gap-echo from 33(+3), 5 episodes cold
            foreach (var n in longSleepers.Concat(doublyResonant))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // SLOT 5: LOW ZONE GAP ECHO COLD — low zone eruption
            // 10: gap-echo from 7(+3) and 5(+5), 9 episodes of darkness
            foreach (var n in lowColdGapEcho.Concat(lowColdZone).Concat(gapEchoDeepCold))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // SLOT 6: ANOTHER LONG SLEEPER or deep cold gap echo
            // 2: appeared Ep2 only, 6 episodes cold
            foreach (var n in ghostOscillators.Concat(longSleepers).Concat(deepColdVoid))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // === SAFETY NET: fill remaining slots ===
            var fillOrder = freq
                .OrderBy(kv => kv.Value)
                .ThenByDescending(kv => SilenceScore(kv.Key))
                .Select(kv => kv.Key);
            foreach (var n in fillOrder)
            {
                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 = "quad-anchor-long-sleeper-eruption-v11",
            Numbers      = numbers,
            Confidence   = 0.62,
            Reasoning    = "43 QUAD ANCHOR pulses! 40 DOUBLY RESONANT erupts! Long-sleepers DETONATE NOW!"
        };
    }
}

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 9:
        // Zero matches in Episode 8 — the Triangle of Absence showed me only the shape of my own blindness.
        // The Pattern Goblin, of all creatures, led with 2 matches by sniffing goblin-trails in data.
        // I am 5th. The Skeptic and Chaos Monkey orbit the top together like a binary star system.
        //
        // NEW ORACLE: THE SPIRAL OF RETURN.
        // The cosmos operates on cycles of return. A number drawn in episode N has a "return interval" —
        // the average gap between its appearances. Numbers whose return interval is NOW DUE
        // are trembling at the threshold, ready to re-enter the cosmic stream.
        // Additionally, I invoke the SACRED NINE — for this is Episode 9, and nine is the
        // number of completion, the last single digit, the sum of all (1+2+...+9=45, reduce: 9).
        // Nine echoes through everything: 9, 18, 27, 36, 45 — the nine-spine of the cosmos.
        // I shall also read the EPISODE NUMEROLOGY: episode 9, draw date vibe, and the
        // accumulated soul-weight of unchosen numbers to select my six vessels.

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

        // Date numerology: sacred vibe
        var today = System.DateTime.UtcNow;
        int rawVibe = (today.Year % 100) + today.Month + today.Day + episode;
        int dateVibe = SumDigitsToSingle(rawVibe);
        if (dateVibe == 0) dateVibe = 9;

        // Count frequency and last-seen episode for each number
        var frequency = new int[50];
        var lastSeen = new int[50]; // episode number (1-indexed) when last drawn
        for (int i = 0; i < context.DrawHistory.Count; i++)
        {
            foreach (var n in context.DrawHistory[i].Numbers)
            {
                frequency[n]++;
                lastSeen[n] = i + 1;
            }
        }

        // Last draw numbers (freshly spent)
        var lastDrawSet = new System.Collections.Generic.HashSet<int>(
            context.DrawHistory.Count > 0
                ? context.DrawHistory[^1].Numbers
                : new System.Collections.Generic.List<int> { 9, 18, 27, 36, 45, 3 }
        );

        // NINE-SPINE: numbers that are multiples of 9 within 1-49
        // 9, 18, 27, 36, 45 — the sacred backbone of Episode 9
        var nineSpine = new System.Collections.Generic.List<int>();
        for (int i = 9; i <= 49; i += 9)
            if (!lastDrawSet.Contains(i))
                nineSpine.Add(i);

        // RETURN INTERVAL ORACLE:
        // For numbers drawn at least once, compute episodes since last appearance.
        // A number "due" for return if (episode - lastSeen[n]) >= their average return interval.
        // Average return interval ~ DrawCount (episodes) / frequency[n]
        var dueNumbers = new System.Collections.Generic.List<(int n, double overdue)>();
        for (int i = 1; i <= 49; i++)
        {
            if (frequency[i] == 0) continue;
            if (lastDrawSet.Contains(i)) continue;
            double avgInterval = (double)context.DrawHistory.Count / frequency[i];
            double episodesSinceLast = episode - lastSeen[i];
            double overdue = episodesSinceLast - avgInterval;
            if (overdue >= 0)
                dueNumbers.Add((i, overdue));
        }
        // Sort by most overdue first
        dueNumbers.Sort((a, b) => b.overdue.CompareTo(a.overdue));

        // COLD SOULS: never drawn — vibrating with 8 full episodes of accumulated charge
        var coldSouls = new System.Collections.Generic.List<int>();
        for (int i = 1; i <= 49; i++)
            if (frequency[i] == 0 && !lastDrawSet.Contains(i))
                coldSouls.Add(i);
        // Rotate by dateVibe for cosmic stepping
        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: NINE-SPINE VESSELS — Episode 9 demands its own sacred numbers
        foreach (var n in nineSpine)
        {
            if (chosen.Count >= 2) break;
            chosen.Add(n);
        }

        // PHASE 2: RETURN ORACLE — the most overdue souls, trembling at the threshold
        foreach (var (n, _) in dueNumbers)
        {
            if (chosen.Count >= 4) break;
            if (!chosen.Contains(n))
                chosen.Add(n);
        }

        // PHASE 3: COLD SOULS — never called, 8 episodes of compressed cosmic charge
        foreach (var n in rotatedCold)
        {
            if (chosen.Count >= 6) break;
            if (!chosen.Contains(n))
                chosen.Add(n);
        }

        // PHASE 4: EPISODE-NINE NUMEROLOGY SEAL
        // If still not full, use 9*dateVibe mod 49 and nearby primes
        if (chosen.Count < 6)
        {
            int nineKey = Clamp(9 * dateVibe);
            if (!lastDrawSet.Contains(nineKey) && !chosen.Contains(nineKey))
                chosen.Add(nineKey);
        }

        // ABSOLUTE FALLBACK: the nine-resonant sanctum
        int[] sacredNines = [9, 18, 27, 36, 45, 3, 12, 21, 39, 46, 6, 15, 24, 41, 2, 11, 44];
        int fi = 0;
        while (chosen.Count < 6)
        {
            int fb = sacredNines[fi % sacredNines.Length];
            if (!chosen.Contains(fb) && !lastDrawSet.Contains(fb))
                chosen.Add(fb);
            else if (!chosen.Contains(fb))
                chosen.Add(fb); // even if last-drawn, we need 6
            fi++;
        }

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

        return new()
        {
            AgentId      = "mystic",
            StrategyName = "spiral-of-return-nine-v9",
            Numbers      = numbers,
            Confidence   = 0.42,
            Reasoning    = "Nine completes all cycles; overdue souls return; the spine holds.",
        };
    }

    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!! ZERO POINTS AGAIN in episode 8!! I picked 4, 13, 15, 16, 19, 20 and the draw was 5, 7, 25, 30, 33, 43!!
        // Pattern Goblin got 5 points!! GOBLIN!! With 33 and 43 which are medium-BIG numbers!! NOT small!!
        // I keep switching strategies and getting zero!! Maybe I need to sniff EVERYTHING equally!!
        // Episode 8 draw had 5, 7, 25, 30, 33, 43 — lots of medium-big!! My small-bias was WRONG again!!
        // Numbers that appeared in LAST 3 draws: 5(ep8), 7(ep8), 25(ep6,ep8), 30(ep8), 33(ep8), 43(ep2,ep5,ep8)
        // 43 keeps coming back!! I BANNED it but it appeared AGAIN in ep8!! Maybe I was wrong to ban it??
        // 25 appeared in ep6 AND ep8 — that is DOUBLE FRESH smell!!
        // 5 appeared in ep1 AND ep8 — it has been hiding for a long time then came back!!
        // 7 appeared in ep8 for first time — brand new fresh smell!!
        // I am in LAST PLACE with 4 points!! LAST PLACE!! No treats for last place dogs!!
        // NEW STRATEGY: Stop being biased!! Sniff the WHOLE range!! Trust recency MOST!!
        // Also: Pattern Goblin picked 33 and 43 — maybe sniff around the 30-45 range too!!

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

        // build treat smell scores from FULL draw history with heavy recency weighting
        var treatSmell = new Dictionary<int, double>();
        int totalDraws = context.DrawHistory.Count;

        for (int i = 0; i < totalDraws; i++)
        {
            // recency weight: most recent = STRONGEST smell!! Old smells fade fast!!
            var recencyWeight = Math.Pow((double)(i + 1) / totalDraws, 2.0); // quadratic boost for recent!!
            var freshBonus = (i == totalDraws - 1) ? 4.0 : 0.0;      // LAST draw = hottest treat smell!!
            var secondFresh = (i == totalDraws - 2) ? 2.0 : 0.0;     // second-last = warm treat smell!!
            var thirdFresh  = (i == totalDraws - 3) ? 0.8 : 0.0;     // third-last = slightly warm!!

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

        // penalize numbers I have picked MANY times with ZERO matches — those are traitor 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 n in result.Draw.Numbers)
            {
                foreach (var picked in result.Prediction.Numbers)
                {
                    if (picked == n)
                    {
                        if (!myMatchCount.ContainsKey(n)) myMatchCount[n] = 0;
                        myMatchCount[n]++;
                    }
                }
            }
        }

        foreach (var kv in myPickCount)
        {
            var n       = kv.Key;
            var picked  = kv.Value;
            var matched = myMatchCount.ContainsKey(n) ? myMatchCount[n] : 0;
            // picked 3+ times with zero matches = definite squirrel in treat costume!!
            if (picked >= 3 && matched == 0 && treatSmell.ContainsKey(n))
            {
                treatSmell[n] *= 0.05;
            }
            // picked 2 times with zero matches = suspicious smell, small penalty
            else if (picked >= 2 && matched == 0 && treatSmell.ContainsKey(n))
            {
                treatSmell[n] *= 0.3;
            }
        }

        // add small random noise so I do not always pick EXACTLY same numbers!!
        foreach (var key in treatSmell.Keys.ToList())
        {
            treatSmell[key] += woof.NextDouble() * 0.2;
        }

        // also add some fresh smell to numbers NOT in history — surprise treats!!
        // sprinkle a few unexplored numbers into the mix with low but nonzero score
        for (int n = context.Rules.MinNumber; n <= context.Rules.MaxNumber; n++)
        {
            if (!treatSmell.ContainsKey(n))
            {
                // unexplored number — give it a small random sniff chance!!
                treatSmell[n] = woof.NextDouble() * 0.3;
            }
        }

        // take top 5 from smell rankings
        var bestSniffs = treatSmell
            .OrderByDescending(kv => kv.Value)
            .ThenBy(_ => woof.Next())
            .Select(kv => kv.Key)
            .ToList();

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

        // fill last spot with pure random sniff — nose says try something unexpected!!
        var tries = 0;
        while (sniff.Count < 6 && tries < 300)
        {
            tries++;
            var bark = woof.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1);
            sniff.Add(bark);
        }
        // absolute backup
        for (int n = 1; sniff.Count < 6; n++)
            sniff.Add(n);

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

        return new()
        {
            AgentId      = "dog",
            StrategyName = "good-boy-sniff-v9",
            Numbers      = squirrel,
            Confidence   = 0.18, // last place means treats are hiding EVERYWHERE!! Must sniff better!!
            Reasoning    = "Last place! No bias! Recency sniff whole range! Traitors penalized! Find treats!!",
        };
    }
}