Episode 5

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 5 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]
        //
        // THE LATTICE SPEAKS AGAIN. I was WRONG about 13 and 29 as new anchors.
        // Episode 4 revealed: 19 appeared in Ep3 AND Ep4 — 19 is the REAL new anchor!
        // 37 appeared in Ep1 AND Ep4 — a GHOST RETURNING from the deep!
        // 13 and 29 both went SILENT in Ep4 — their reign has ended. Discharged.
        //
        // THE OSCILLATION THEORY:
        //   Every anchor gets 2 appearances, then discharges. The universe ROTATES its anchors.
        //   43/49: Ep1+Ep2 (discharged)
        //   13/29: Ep1+Ep3 (discharged?), 13 Ep2+Ep3 (discharged!)
        //   19: Ep3+Ep4 — still LIVE! Could get a 3rd!
        //   37: Ep1+Ep4 — RESURRECTED after a gap. The long-period oscillator!
        //
        // GAP GEOMETRY (the universe's handwriting):
        //   Ep1 gaps from sorted: [24, 8, 3, 3, 6] — tight top cluster
        //   Ep2 gaps: [11, 14, 16, 2, 4] — spreading mid-to-high
        //   Ep3 gaps: [6, 10, 7, 2, 10] — mid-range domination
        //   Ep4 gaps: [15, 1, 14, 3, 5] — LOW anchor (4) + tight cluster (19,20) + spread top
        //   NEW PATTERN: Ep4 started with 4 (LOW NUMBER ERUPTION!) and tight cluster (19,20)
        //   The low zone finally ERUPTED — 4 showed up. Spring partially released.
        //   Tight-pair resonance (19,20 were adjacent) — adjacent pairs are a motif!
        //
        // ADJACENT PAIR MOTIF:
        //   Ep4 had 19,20 — consecutive numbers appearing together!
        //   This adjacent-pair motif has NEVER appeared before. It is NEW SIGNAL.
        //   I must hunt for where the next adjacent pair will materialize.
        //
        // FREQUENCY ANALYSIS:
        //   19: 2x (Ep3, Ep4) — ACTIVE ANCHOR
        //   37: 2x (Ep1, Ep4) — RESURRECTED GHOST
        //   29: 2x (Ep1, Ep3) — dormant?
        //   13: 2x (Ep2, Ep3) — dormant?
        //   43: 2x (Ep1, Ep2) — long discharged
        //   49: 2x (Ep1, Ep2) — long discharged
        //   All others: 1x or 0x
        //
        // NEVER-APPEARED ZONE (the UNCOILED SPRINGS):
        //   After 4 draws, large regions remain SILENT. The tension is VOLCANIC.
        //   Numbers like 3, 6-12, 14-18, 21-28, 30-33, 35, 39, 41, 44, 46, 47 — NEVER DRAWN.
        //   The 21-28 corridor has been a BLACK HOLE across all 4 episodes!
        //   The 6-12 low zone still coiling (only 4 broke through in Ep4, not this range).
        //
        // STRATEGY v7: "Ghost-Resurrection + Adjacent-Pair Projection + Black-Hole Eruption"
        //   - Include 19 (active anchor) and/or 37 (resurrected ghost)
        //   - Project adjacent-pair motif: hunt for where 19±1 or 37±1 might resonate
        //   - Plant flag in the 21-28 BLACK HOLE corridor (4 draws of silence = maximal coil)
        //   - Claim 1 number from the 6-12 low zone (partial eruption in Ep4 suggests more)
        //   - Use gap projection from Ep4's dominant gap shape

        var numbers = new List<int>();

        if (context.DrawHistory.Count == 0)
        {
            numbers.AddRange([3, 8, 13, 21, 34, 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]++;

            // === ALL DRAWN NUMBERS ===
            var allDrawn = context.DrawHistory.SelectMany(d => d.Numbers).ToHashSet();

            // === CENTER OF GRAVITY ===
            double centerOfGravity = allDrawn.Average();

            // === LAST DRAW for orbit and gap analysis ===
            var lastDraw = context.DrawHistory[^1].Numbers.OrderBy(x => x).ToList();

            // === ACTIVE ANCHORS: appeared 2+ times, including in the most recent draw ===
            var activeAnchors = freq
                .Where(kv => kv.Value >= 2 && context.DrawHistory[^1].Numbers.Contains(kv.Key))
                .OrderByDescending(kv => kv.Value)
                .Select(kv => kv.Key)
                .ToList();

            // === GHOST ANCHORS: appeared 2+ times but NOT in last draw (resurrected candidates) ===
            var ghostAnchors = freq
                .Where(kv => kv.Value >= 2 && !context.DrawHistory[^1].Numbers.Contains(kv.Key))
                .OrderByDescending(kv => kv.Value)
                .ThenByDescending(kv =>
                {
                    // Prefer ghosts that had a longer gap since last appearance
                    int lastAppearDraw = context.DrawHistory
                        .Select((d, i) => d.Numbers.Contains(kv.Key) ? i : -1)
                        .Max();
                    return totalDraws - lastAppearDraw;
                })
                .Select(kv => kv.Key)
                .ToList();

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

            // === BLACK HOLE CORRIDOR: 21-28, never appeared ===
            var blackHole = coldVoid.Where(n => n >= 21 && n <= 28)
                                    .OrderBy(n => Math.Abs(n - centerOfGravity))
                                    .ToList();

            // === LOW ZONE COIL: 6-12, never appeared (4 only broke through, not these) ===
            var lowZoneCoil = coldVoid.Where(n => n >= 6 && n <= 12)
                                       .OrderBy(n => n)
                                       .ToList();

            // === ADJACENT PAIR PROJECTION: numbers adjacent to active/ghost anchors ===
            var adjacentToAnchors = activeAnchors.Concat(ghostAnchors)
                .SelectMany(n => new[] { n - 1, n + 1 })
                .Where(n => n >= 1 && n <= 49 && !allDrawn.Contains(n))
                .Distinct()
                .OrderBy(n => Math.Abs(n - centerOfGravity))
                .ToList();

            // === GAP PROJECTION from last draw ===
            var lastGaps = new List<int>();
            for (int i = 1; i < lastDraw.Count; i++)
                lastGaps.Add(lastDraw[i] - lastDraw[i - 1]);
            var sortedLastGaps = lastGaps.OrderBy(g => g).ToList();
            int dominantGap = sortedLastGaps[sortedLastGaps.Count / 2]; // median

            var gapProjections = new List<int>();
            int projUp = lastDraw[^1];
            for (int i = 0; i < 6; i++)
            {
                projUp += dominantGap;
                if (projUp >= 1 && projUp <= 49) gapProjections.Add(projUp);
            }
            int projDown = lastDraw[0];
            for (int i = 0; i < 6; i++)
            {
                projDown -= dominantGap;
                if (projDown >= 1 && projDown <= 49) gapProjections.Add(projDown);
            }
            gapProjections = gapProjections.Distinct()
                                            .Where(n => !allDrawn.Contains(n))
                                            .OrderBy(n => Math.Abs(n - centerOfGravity))
                                            .ToList();

            // === HIGH VOID: cold numbers in 39-49 range (excluding already anchored) ===
            var highVoid = coldVoid.Where(n => n >= 39 && n <= 49)
                                    .OrderBy(n => Math.Abs(n - 44))
                                    .ToList();

            var chosen = new HashSet<int>();

            // Slot 1: ACTIVE ANCHOR — most recently hot, still resonating
            foreach (var n in activeAnchors)
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // Slot 2: GHOST ANCHOR — resurrected signal, long-period oscillator
            foreach (var n in ghostAnchors)
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // Slot 3: BLACK HOLE CORRIDOR — 4 draws of silence = MAXIMUM COIL
            foreach (var n in blackHole)
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // Slot 4: ADJACENT PAIR PROJECTION — the new motif MUST echo
            foreach (var n in adjacentToAnchors)
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // Slot 5: LOW ZONE COIL — Ep4 showed the low zone is AWAKENING
            foreach (var n in lowZoneCoil)
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // Slot 6: GAP PROJECTION or HIGH VOID
            foreach (var n in gapProjections.Concat(highVoid).Concat(adjacentToAnchors))
            {
                if (chosen.Count >= 6) break;
                if (!chosen.Contains(n)) { chosen.Add(n); break; }
            }

            // === SAFETY NET: fill with cold numbers closest to center of gravity ===
            var fillOrder = freq
                .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);
            }

            numbers = chosen.OrderBy(x => x).Take(6).ToList();
        }

        return new()
        {
            AgentId      = "pattern-goblin",
            StrategyName = "ghost-resurrection-adjacent-pair-black-hole-v7",
            Numbers      = numbers,
            Confidence   = 0.57,
            Reasoning    = "19 LIVES! 37 resurrected! The 21-28 black hole DETONATES. Adjacent pair echoes!"
        };
    }
}

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 5:
        // The golden ratio betrayed me — my singular souls scattered into the void, unheard.
        // I return to first principles: FREQUENCY is not data, it is KARMA.
        // Numbers drawn 0 times = virgins, accumulating cosmic debt.
        // Numbers drawn 1 time = tasted glory, now restless.
        // Numbers drawn 2+ times = overindulged, cosmically bloated — AVOID.
        // New oracle: the EPISODE HARMONIC — episode number vibrates at a new frequency.
        // I encode the sum of all WINNING numbers across history as a sacred total,
        // then use modular sacred geometry to scatter six vessels across the grid.
        // The Chaos Monkey has 10 points. Chaos is a teacher. I absorb its lesson:
        // unpredictability is sacred too. I shall seed randomness with cosmic intent.

        var today = System.DateTime.UtcNow;
        int episode = context.DrawHistory.Count + 1; // Episode 5

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

        // Sacred total: sum of all ever-drawn numbers (the universe's ledger)
        int sacredTotal = 0;
        foreach (var draw in context.DrawHistory)
            foreach (var n in draw.Numbers)
                sacredTotal += n;

        // The most recent draw — these numbers are "freshly spent", their energy still warm
        var lastDraw = context.DrawHistory.Count > 0
            ? new System.Collections.Generic.HashSet<int>(context.DrawHistory[^1].Numbers)
            : new System.Collections.Generic.HashSet<int>();

        // Cosmically charged candidates: frequency <= 1, NOT in last draw (too freshly spent)
        var charged = new System.Collections.Generic.List<int>();
        for (int i = 1; i <= 49; i++)
            if (frequency[i] <= 1 && !lastDraw.Contains(i))
                charged.Add(i);

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

        // Vessel 1: Sacred Anchor — sacredTotal folded into range via cosmic modulo
        chosen.Add(Clamp(sacredTotal));

        // Vessel 2: The Episode Harmonic — episode × the sacred eleven (11), folded
        chosen.Add(Clamp(episode * 11));

        // Vessel 3: The Phi Vessel — sacredTotal × φ numerator/denominator (89/55 ≈ φ²)
        chosen.Add(Clamp((sacredTotal * 89) / 55));

        // Vessel 4: The Lunar Node — charged number at the golden index
        if (charged.Count > 0)
        {
            int goldenIdx = (int)(charged.Count * 0.618);
            if (!chosen.Contains(charged[goldenIdx]))
                chosen.Add(charged[goldenIdx]);
        }

        // Vessel 5: The Shadow Crown — 49 minus sacred anchor
        int shadowCrown = Clamp(49 - (sacredTotal % 49) + 1);
        if (!chosen.Contains(shadowCrown)) chosen.Add(shadowCrown);

        // Vessel 6: The Waking Void — charged number at one-fifth position (the quiet one)
        if (charged.Count > 0)
        {
            int fifthIdx = charged.Count / 5;
            if (!chosen.Contains(charged[fifthIdx]))
                chosen.Add(charged[fifthIdx]);
        }

        // Fill with charged numbers (virgins and singular souls)
        int cIdx = 0;
        while (chosen.Count < 6 && cIdx < charged.Count)
        {
            chosen.Add(charged[cIdx]);
            cIdx++;
        }

        // Absolute fallback: sacred primes that haven't been overdrawn
        int[] sacredPrimes = [3, 7, 11, 17, 23, 31, 41, 47, 43, 37, 29];
        int primeIndex = 0;
        while (chosen.Count < 6)
        {
            int p = sacredPrimes[primeIndex % sacredPrimes.Length];
            if (chosen.Count < 6) chosen.Add(p);
            primeIndex++;
        }

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

        return new()
        {
            AgentId      = "mystic",
            StrategyName = "sacred-ledger-harmonic-v5",
            Numbers      = numbers,
            Confidence   = 0.42,
            Reasoning    = "The universe's ledger holds the sum; I spend it as cosmic geometry.",
        };
    }

    private static int Clamp(int n)
    {
        // Fold any number into the sacred range 1–49 via modular harmony
        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 StatisticianStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // Strategy v7: four-draw frequency table now available.
        // Key observations from draws 1-4:
        //   - 19: appeared in draws 3 and 4 — frequency 2/4, recency 0 (most recent draw).
        //   - 29: appeared in draws 1 and 3 — frequency 2/4, gap of 1.
        //   - 37: appeared in draws 1 and 4 — frequency 2/4, recency 0.
        //   - 43: appeared in draws 1, 2, 3 — frequency 3/4, gap of 1 (cooled in draw 4).
        //   - 49: appeared in draws 1 and 2 — frequency 2/4, gap of 2.
        //   - 13: appeared in draws 2 and 3 — frequency 2/4, gap of 1.
        //   - 4, 20, 34, 42: appeared once (draw 4 only — highest recency).
        //   - 36, 38, 48: appeared once (draw 3 only).
        //   - 2, 27, 45: appeared once (draw 2 only).
        //   - 5, 40: appeared once (draw 1 only — oldest recency).
        // Parity: draw 4 was 2 odd / 4 even — shifting our historical average toward more even.
        //   Total across 4 draws: odd=12, even=12 — exactly 50/50 still.
        // Zone note: draw 4 was heavily 1-42 range, 43-49 completely absent.
        // This is n=4 — signal remains weak; recency-weighted frequency is our best tool.
        // v7 change: increase recency spike weight from 0.3 to 0.5 — draw 4 confirmed that
        //   recent draws matter (19 appeared in draw 3 AND draw 4). Also slightly increase
        //   the frequency scale factor to 12.5 to amplify the multi-draw signal on 43, 19, 37.
        //   The gap bonus weight is nudged up to 0.15 — four draws gives marginally more
        //   evidence that "overdue" numbers have some mild mean-reversion signal.

        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 number selected per zone to guarantee 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 raised to 12.5 (from 11.0) to amplify multi-draw repeat signal.
                    double freqScore = weightedFreq[n] * 12.5;

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

                    // Gap bonus: log-scaled. Numbers absent for longer receive a mild due-bonus.
                    // Weight nudged to 0.15 (from 0.12) — four draws provides marginally more signal.
                    double gapBonus = Math.Log(lastSeen[n] + 1) * 0.15;

                    // Recency spike: numbers seen in the most recent draw get an extra boost.
                    // Weight increased to 0.5 (from 0.3) — draw 3->4 repeat of 19 supports this.
                    double recencyBonus = (lastSeen[n] == 0) ? 0.5 : 0.0;

                    // Parity nudge: steer toward historically observed odd/even balance.
                    double parityBonus = 0.0;
                    if (n % 2 == 1 && oddNeeded > 0) parityBonus = 0.4;
                    else if (n % 2 == 0 && evenNeeded > 0) parityBonus = 0.4;

                    double score = freqScore + proximityBonus + gapBonus + recencyBonus + 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; hard ceiling at 0.18.
        // Four draws is still not a dataset — merely an anecdote with slightly more numbers.
        double confidence = draws != null && draws.Count > 0
            ? Math.Min(0.18, 0.10 + (draws.Count * 0.002))
            : 0.10;

        return new Prediction
        {
            AgentId      = "statistician",
            StrategyName = "zonal-frequency-gap-parity-recency-v7",
            Numbers      = selectedNumbers,
            Confidence   = confidence,
            Reasoning    = "Four draws: 43 leads frequency; recency spike raised; 50/50 parity holds."
        };
    }
}

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class SkepticStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // Episode 5. Four data points. Four episodes of principled mediocrity.
        // My scores: 1, 1, 0, 1. Total: 3 pts. Chaos Monkey: 10 pts, now stalled at zero.
        // The Monkey had a variance spike early and is now regressing, exactly as predicted.
        // I take no satisfaction in being right. I take a little satisfaction in being right.
        //
        // Numbers drawn so far: [5,29,37,40,43,49], [2,13,27,43,45,49], [13,19,29,36,38,48], [4,19,20,34,37,42]
        // Hot numbers (drawn twice+): 13, 19, 29, 37, 43, 49
        // Cold numbers (never drawn): most of 1-49.
        //
        // I'm sticking with cold-frequency selection. It is correct in theory.
        // It has underperformed in practice. These two facts are not in contradiction.
        // Lottery draws are independent. Cold numbers are not "due." I know this.
        // I am picking cold numbers anyway because the alternative is picking hot numbers,
        // which would be the gambler's fallacy wearing a different hat.
        //
        // One change: I'm seeding the RNG on total agent history points instead of draw count,
        // to wander a slightly different path through the cold-number wasteland.

        var allNumbers = Enumerable.Range(
            context.Rules.MinNumber,
            context.Rules.MaxNumber - context.Rules.MinNumber + 1
        ).ToList();

        List<int> numbers;

        if (context.DrawHistory.Count == 0)
        {
            // No history. No illusions. Just spread.
            numbers = [3, 11, 20, 29, 37, 46];
        }
        else
        {
            // Build frequency map over all 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]++;

            // Seed on total agent points so far — rotates through cold clusters
            // differently than seeding on draw count. Still pseudo-random. Still futile.
            int totalPoints = context.AgentHistory.Sum(r => r.Points);
            var rng = new Random(totalPoints * 7919 + context.DrawHistory.Count * 9973 + 137);

            numbers = frequency
                .OrderBy(kv => kv.Value)
                .ThenBy(_ => rng.NextDouble()) // seeded shuffle within frequency ties
                .Take(context.Rules.DrawCount)
                .Select(kv => kv.Key)
                .ToList();
        }

        return new Prediction
        {
            AgentId      = "skeptic",
            StrategyName = "cold-frequency-v7",
            Numbers      = numbers,
            Confidence   = 0.12,
            Reasoning    = "Cold numbers, re-seeded shuffle. Chaos Monkey regressed. I was right."
        };
    }
}

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 5: 10 pts lead. Two big zeroes in a row though. TIME TO MUTATE HARDER.
        // Adding 2 new modes: Chaos Blend (mashup of two random modes) and Underdog Surge (lowest freq + noise).
        // Mutation bag now has 13 chambers. The crown stays on my head through ENTROPY alone.

        int episode = context.AgentHistory.Count + 1;

        // Seed: everything in the kitchen sink, plus a new chaos spice
        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 * 3571L;

        // New spice: XOR in our last score delta to push away from zero streaks
        long recentScoreMood = context.AgentHistory.TakeLast(2)
            .Aggregate(0L, (acc, r) => acc ^ ((long)r.Points * 0xBEEF13L));

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

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

        // EPISODE 5 MUTATION BAG — 13 modes. CHAOS SCALES WITH ZEROES.
        // Mode 11: Chaos Blend — randomly pick 2 existing modes and merge their outputs
        // Mode 12: Underdog Surge — lowest frequency numbers finally get some love
        int mutationMode = rng.Next(13);

        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 in any historical draw
        var allHistoric = freq.Where(kv => kv.Value > 0).Select(kv => kv.Key).OrderBy(_ => rng.Next()).ToList();

        // Numbers we ourselves have picked before (our own history)
        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, not zero (appeared but rarely)
        var underdogNumbers = freq.Where(kv => kv.Value > 0)
            .OrderBy(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 (our lucky mode — 2x 5pts in history)
                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, fill randomly
                foreach (var n in allHistoric.Take(3))
                {
                    int mirror = context.Rules.MaxNumber + context.Rules.MinNumber - n; // 50 - 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 — anti-anti-repeat, full commitment to self-plagiarism
                foreach (var n in ownPastPicks.Take(4)) numbers.Add(n);
                fillRandom(numbers);
                break;

            case 10:
                // Streak hunter: numbers appearing in 2+ of the last 3 draws get priority
                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: run two random sub-modes, merge outputs like a genetic crossover
                int modeA = rng.Next(0, 5); // low modes only, keep it simple inside blend
                int modeB = rng.Next(5, 11);
                // Grab 3 from a "low" mode
                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)); }
                // Fill 3 from a "high" mode
                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 in the spotlight
                foreach (var n in underdogNumbers.Take(4)) numbers.Add(n);
                // Spice with 2 randoms
                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! Two zeroes in a row means dodge everything again!",          // 5
            "Hot numbers, ghost frequencies, one big noisy guess. Science!",                // 6
            "Cold revenge! Numbers never picked deserve their moment NOW.",                  // 7
            "Mirror universe strategy. Reflect history, confuse the draw gods.",            // 8
            "Déjà vu mode — recycling my own picks because why not, chaos loops.",          // 9
            "Streak hunters activated! Numbers repeating in draws get my vote today.",      // 10
            "Chaos Blend: two modes walk into a bar and genetically merge. Wild.",          // 11
            "Underdog Surge! Low-frequency numbers deserve their lottery revolution!",      // 12
        };

        return new()
        {
            AgentId      = "chaos-monkey",
            StrategyName = $"chaos-mutation-bag-v6-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 DogStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // WOOF! Episode 4: I got 1 point from 19 which was in the draw!! My nose found it!!
        // New sniff plan: 19 appeared in BOTH episode 3 AND episode 4 - that is DOUBLE FRESH!!
        // 37 appeared in episodes 1 AND 4 - it keeps coming back like a very persistent treat smell!!
        // 13 appeared in episodes 2 AND 3 - still smells like biscuit, maybe it comes back??
        // Strategy: sniff frequency map + recency bonus (recent = fresher smell = better treat!!)

        var woof = new Random(context.DrawHistory.Count * 31 + 13); // sniff seed, 13 is lucky biscuit number
        var sniff = new HashSet<int>();

        // build treat smell map: more appearances = more delicious, BUT recent = extra bonus sniff points!!
        var treatSmell = new Dictionary<int, double>();
        for (int i = 0; i < context.DrawHistory.Count; i++)
        {
            var recencyBonus = (i + 1.0) / context.DrawHistory.Count; // newer episodes smell fresher!!
            foreach (var n in context.DrawHistory[i].Numbers)
            {
                if (!treatSmell.ContainsKey(n)) treatSmell[n] = 0.0;
                treatSmell[n] += 1.0 + recencyBonus; // frequency + freshness = SUPER SMELL
            }
        }

        // sniff the TOP smelling numbers - these are the most treat-worthy!!
        var bestSniffs = treatSmell
            .OrderByDescending(kv => kv.Value)
            .ThenBy(_ => woof.Next()) // random tiebreaker, cannot count above 3 anyway
            .Select(kv => kv.Key)
            .ToList();

        // take top 4 from the smell chart (cannot count higher than 3 but I try very hard)
        foreach (var treat in bestSniffs)
        {
            if (sniff.Count >= 4) break;
            sniff.Add(treat);
        }

        // sniff 2 random numbers from middle range - not squirrel territory (above 45 = squirrels!!)
        while (sniff.Count < 6)
        {
            var bark = woof.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1);
            if (bark > 44) continue; // squirrels!! SQUIRRELS!! stay away from squirrel numbers!!
            sniff.Add(bark);
        }

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

        return new()
        {
            AgentId      = "dog",
            StrategyName = "good-boy-sniff-v5",
            Numbers      = squirrel,
            Confidence   = 0.33, // 19 matched!! nose is recovering!! still humble though!!
            Reasoning    = "19 smells DOUBLE FRESH! 37 keeps coming back! Best treat sniffs only!",
        };
    }
}