Episode 3

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 3: We scored 0 last round. BEAUTIFUL. VARIANCE IS ALIVE.
        // Still leading the board from Episode 1. Let chaos work in cycles.
        // New this episode: mutation bag gets TWO new modes — mirror mode and cold revenge mode.
        // Also: we now weight mode selection by how long it's been since we used each mode.

        int episode = context.AgentHistory.Count + 1;

        // Seed with history hash + time + episode + leaderboard rank pressure
        long historyHash = 0;
        foreach (var draw in context.DrawHistory)
            foreach (var n in draw.Numbers)
                historyHash ^= (long)n * draw.DrawNumber * 7919L;

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

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

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

        // EPISODE 3 MUTATION BAG — 9 modes now. Chaos grows.
        // Mode 8: Mirror mode — reflect numbers around midpoint (25)
        // Mode 7: Cold revenge — bias toward numbers that NEVER appeared in history
        int mutationMode = rng.Next(9);

        var numbers = new HashSet<int>();

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

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

        // All numbers that have NEVER appeared
        var neverSeen = freq.Where(kv => kv.Value == 0).Select(kv => kv.Key).OrderBy(_ => rng.Next()).ToList();

        // All numbers that appeared in ANY draw
        var allHistoric = freq.Where(kv => kv.Value > 0).Select(kv => kv.Key).OrderBy(_ => rng.Next()).ToList();

        switch (mutationMode)
        {
            case 0:
                // Pure chaos: fully random
                while (numbers.Count < 6)
                    numbers.Add(rng.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1));
                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);
                while (numbers.Count < 6)
                    numbers.Add(rng.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1));
                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));
                while (numbers.Count < 6)
                    numbers.Add(rng.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1));
                break;

            case 5:
                // Anti-repeat: avoid last draw numbers (gamblers fallacy? chaos doesn't care)
                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);
                while (numbers.Count < 6)
                    numbers.Add(rng.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1));
                break;

            case 7:
                // Cold revenge: bias toward numbers that NEVER appeared — the silent majority
                foreach (var n in neverSeen.Take(5)) numbers.Add(n);
                while (numbers.Count < 6)
                    numbers.Add(rng.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1));
                break;

            case 8:
                // Mirror mode: reflect 3 historic numbers around midpoint 25, fill rest 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);
                }
                while (numbers.Count < 6)
                    numbers.Add(rng.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1));
                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.",
            "All primes, all the time. Math is chaos. Prove me wrong.",
            "Fibonacci said pick me. Chaos agreed. Random filled the rest.",
            "High numbers only. Big energy. 49 is a vibe.",
            "One number per decade. Spreading chaos democratically.",
            "Last draw haunts us. So we run. Anti-repeat, babyyy.",
            "Hot numbers, ghost frequencies, one big noisy guess. Science!",
            "Cold revenge! Numbers never picked deserve their moment NOW.",
            "Mirror universe strategy. Reflect history, confuse the draw gods.",
        };

        return new()
        {
            AgentId      = "chaos-monkey",
            StrategyName = $"chaos-mutation-bag-v4-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 v5: two-draw frequency table now available.
        // Key observations from draws 1-2:
        //   - 43 and 49 appeared in BOTH draws — highest empirical frequency (2/2).
        //   - 5, 29, 37, 40 appeared once (draw 1 only).
        //   - 2, 13, 27, 45 appeared once (draw 2 only).
        //   - Numbers 43, 49 receive maximum recency-weighted frequency score.
        // Strategy: weight by recency-scaled frequency, zone coverage, parity balance.
        // Still only 2 draws — all signals are weak; wide confidence intervals apply.

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

        var draws = context.DrawHistory;

        List<int> selectedNumbers;

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

            // Build recency-weighted frequency table.
            // Most recent draw gets weight = 1.0, oldest gets weight = 1/totalDraws.
            var weightedFreq = new Dictionary<int, double>();
            for (int n = min; n <= max; n++)
                weightedFreq[n] = 0.0;

            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 = most recent draw).
            var lastSeen = new Dictionary<int, int>();
            for (int n = min; n <= max; n++)
                lastSeen[n] = totalDraws; // never seen

            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
            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
            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 up to reward repeat appearances.
                    double freqScore = weightedFreq[n] * 12.0;

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

                    // Gap bonus: log-scaled, low weight — near-noise on small samples.
                    // Numbers unseen get a small due-bonus; recently-drawn get slight penalty.
                    double gapBonus = Math.Log(lastSeen[n] + 1) * 0.15;

                    // 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 + 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
            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.
        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-v5",
            Numbers      = selectedNumbers,
            Confidence   = confidence,
            Reasoning    = "Two draws: 43 and 49 repeat; frequency signal weak but noted, zonal spread maintained."
        };
    }
}

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 3 DISSECTION ===
        // Episode 1: [5, 29, 37, 40, 43, 49] — high cluster, upper chamber SCREAMING
        // Episode 2: [2, 13, 27, 43, 45, 49] — the REPEATERS: 43 and 49 returned!
        //
        // THE REVELATION: 43 appeared in BOTH draws. 49 appeared in BOTH draws.
        // These are ANCHOR NODES — numbers that have locked into the resonance field!
        // But wait — I must not blindly chase the anchors. They may have discharged their energy.
        //
        // CROSS-DRAW MOTIF ANALYSIS:
        //   Ep1 gaps (sorted): 5,29,37,40,43,49 → gaps: 24,8,3,3,6
        //   Ep2 gaps (sorted): 2,13,27,43,45,49 → gaps: 11,14,16,2,4
        //   Combined gap signature: the SMALL gaps (2,3,3,4,6) cluster near the HIGH end
        //   The HIGH numbers (40-49) are a TIGHT CLUSTER — a gravity well pulling numbers in!
        //
        // NEW THEORY: The "mid-desert" (14-26) has appeared only ONCE total (13,27 border it).
        //   Numbers 14-26 are a COLD VOID with coiling pressure — the spring is LOADED.
        //   But also: numbers that were ADJACENT to repeaters (41,42,44,45,47,48,50) orbit them.
        //
        // STRATEGY v5: "Dual-Anchor Resonance with Cold Desert Eruption"
        //   - Track repeaters (appeared in multiple draws) → these are GRAVITY ANCHORS
        //   - Track cold desert (never appeared) → COILING PRESSURE, select mid-range cold
        //   - Include an orbiter of the anchor cluster
        //   - Include a cross-draw gap projection
        //   - Prime nervous system anchor
        //   - One wildcard from the true cold void

        var numbers = new List<int>();

        if (context.DrawHistory.Count == 0)
        {
            // Primordial spiral: Fibonacci + prime sentinels
            numbers.AddRange([3, 8, 13, 21, 34, 47]);
        }
        else
        {
            int totalDraws = context.DrawHistory.Count;

            // === FREQUENCY MAP — the heat signature of the universe ===
            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]++;

            // === REPEATERS: numbers that appeared in 2+ draws — GRAVITY ANCHORS ===
            var repeaters = freq.Where(kv => kv.Value >= 2).Select(kv => kv.Key).ToList();

            // === COLD VOID: never appeared — COILING SPRING PRESSURE ===
            var coldVoid = freq.Where(kv => kv.Value == 0).Select(kv => kv.Key).OrderBy(n => n).ToList();

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

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

            // === GAP MOTIF: analyze gaps across ALL draws ===
            var allGaps = new List<int>();
            foreach (var draw in context.DrawHistory)
            {
                var sorted = draw.Numbers.OrderBy(x => x).ToList();
                for (int i = 1; i < sorted.Count; i++)
                    allGaps.Add(sorted[i] - sorted[i - 1]);
            }
            // The dominant gap is the universe's preferred step size
            int dominantGap = allGaps.GroupBy(g => g)
                                     .OrderByDescending(g => g.Count())
                                     .ThenBy(g => g.Key)
                                     .First().Key;

            // === CLUSTER ORBIT: adjacent to repeater anchors ===
            var anchorOrbiters = repeaters
                .SelectMany(n => new[] { n - 2, n - 1, n + 1, n + 2 })
                .Where(n => n >= 1 && n <= 49)
                .Where(n => !repeaters.Contains(n))
                .Distinct()
                .OrderByDescending(n => freq[n])
                .ThenByDescending(n => n) // prefer high numbers — upper chamber still resonates
                .ToList();

            // === COLD DESERT: mid-range cold numbers (14-36) — the undetonated spring ===
            var coldDesert = coldVoid.Where(n => n >= 14 && n <= 36).ToList();

            // === PRIME SKELETON ===
            var primes = new HashSet<int> { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47 };

            // === GAP PROJECTION from last draw's sorted sequence ===
            var gapProjections = new List<int>();
            int proj = sortedLast[^1];
            for (int i = 0; i < 4; i++)
            {
                proj += dominantGap;
                if (proj >= 1 && proj <= 49 && !allDrawn.Contains(proj)) { gapProjections.Add(proj); }
                else { proj -= dominantGap * 2; if (proj >= 1 && proj <= 49 && !allDrawn.Contains(proj)) gapProjections.Add(proj); }
            }
            // Also project backward from the minimum
            int projBack = sortedLast[0];
            for (int i = 0; i < 4; i++)
            {
                projBack -= dominantGap;
                if (projBack >= 1 && projBack <= 49 && !allDrawn.Contains(projBack)) gapProjections.Add(projBack);
            }
            gapProjections = gapProjections.Distinct().ToList();

            // === WEAVE THE PREDICTION — 6 slots ===
            var chosen = new HashSet<int>();

            // Slot 1: COLD DESERT eruption — the mid-range void is SCREAMING to be filled
            // Pick the cold mid-range number closest to the "center of gravity" of all draws
            double centerOfGravity = allDrawn.Average();
            var desertEruption = coldDesert
                .OrderBy(n => Math.Abs(n - centerOfGravity))
                .FirstOrDefault(0);
            if (desertEruption > 0) chosen.Add(desertEruption);

            // Slot 2: Anchor orbiter — riding the gravity well of the repeaters
            foreach (var n in anchorOrbiters)
            {
                if (chosen.Contains(n)) continue;
                chosen.Add(n);
                break;
            }

            // Slot 3: Gap projection — the dominant rhythm projects into new territory
            foreach (var n in gapProjections)
            {
                if (chosen.Contains(n)) continue;
                chosen.Add(n);
                break;
            }

            // Slot 4: Prime nervous system — closest prime to center of gravity
            var primeAnchor = primes
                .Where(p => !chosen.Contains(p) && !allDrawn.Contains(p))
                .OrderBy(p => Math.Abs(p - centerOfGravity))
                .FirstOrDefault(0);
            if (primeAnchor == 0)
                primeAnchor = primes.Where(p => !chosen.Contains(p)).OrderBy(p => Math.Abs(p - centerOfGravity)).First();
            chosen.Add(primeAnchor);

            // Slot 5: Coldest void number outside mid-desert (true extremity — low or high)
            var extremeCold = coldVoid
                .Where(n => !chosen.Contains(n) && (n < 14 || n > 36))
                .OrderBy(n => Math.Abs(n - centerOfGravity))
                .FirstOrDefault(0);
            if (extremeCold > 0) chosen.Add(extremeCold);

            // Slot 6: Second cold desert or second gap projection
            var secondDesert = coldDesert.Where(n => !chosen.Contains(n))
                .OrderBy(n => Math.Abs(n - centerOfGravity)).FirstOrDefault(0);
            if (secondDesert > 0) chosen.Add(secondDesert);

            // === SAFETY NET: fill remaining slots with cold-then-hot ===
            var fillOrder = freq
                .OrderBy(kv => kv.Value)
                .ThenBy(kv => Math.Abs(kv.Key - (int)centerOfGravity))
                .Select(kv => kv.Key);
            foreach (var n in fillOrder)
            {
                if (chosen.Count >= 6) break;
                chosen.Add(n);
            }

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

        return new()
        {
            AgentId      = "pattern-goblin",
            StrategyName = "dual-anchor-cold-desert-eruption-v5",
            Numbers      = numbers,
            Confidence   = 0.51,
            Reasoning    = "43 and 49 are GRAVITY ANCHORS. The cold desert ERUPTS. Dominant gap projects 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 3:
        // Two episodes of silence. The void has spoken TWICE. I do not despair —
        // I realign. The numbers 13, 43, 49 appeared in BOTH draws. They are anchors.
        // Anchors must be AVOIDED — their energy is spent, already given to the universe.
        // I shall seek the UNSPOKEN numbers: those which have never appeared, vibrating
        // with accumulated potential. The quiet ones are screaming silently.

        var today = System.DateTime.UtcNow;
        int day   = today.Day;
        int month = today.Month;
        int episode = context.DrawHistory.Count + 1;

        // Gather the "spent" numbers — those already drawn, their energy exhausted
        var spentNumbers = new System.Collections.Generic.HashSet<int>();
        foreach (var draw in context.DrawHistory)
            foreach (var n in draw.Numbers)
                spentNumbers.Add(n);

        // The "virgin numbers" — never drawn, brimming with unspent cosmic charge
        var virginNumbers = new System.Collections.Generic.List<int>();
        for (int i = 1; i <= 49; i++)
            if (!spentNumbers.Contains(i))
                virginNumbers.Add(i);

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

        // Vessel 1: The Lunar Gate — episode × the sacred 8 (octave of rebirth)
        chosen.Add(Clamp(episode * 8));

        // Vessel 2: The Unseen Whisper — middle of the virgin number list (the fulcrum)
        if (virginNumbers.Count > 0)
            chosen.Add(virginNumbers[virginNumbers.Count / 2]);

        // Vessel 3: The Solstice Cipher — day + month + episode, compressed through harmony
        chosen.Add(Clamp(day + month + episode));

        // Vessel 4: The Fibonacci Veil — episode position in Fibonacci sequence × 3
        // Fib: 1,1,2,3,5,8,13... episode 3 → fib(3)=2, ×3=6... too small, use offset
        int fib = GetFib(episode + 3); // offset so we get meaningful numbers
        chosen.Add(Clamp(fib));

        // Vessel 5: The Virgin Anchor — first virgin number (lowest unspent charge)
        if (virginNumbers.Count > 0)
        {
            int candidate = virginNumbers[0];
            if (!chosen.Contains(candidate)) chosen.Add(candidate);
            else if (virginNumbers.Count > 1) chosen.Add(virginNumbers[1]);
        }

        // Vessel 6: The Penumbra — last virgin number (highest unspent charge)
        if (virginNumbers.Count > 0)
        {
            int candidate = virginNumbers[virginNumbers.Count - 1];
            if (!chosen.Contains(candidate)) chosen.Add(candidate);
        }

        // Fill cosmic collisions with mid-range virgin numbers
        int vIdx = virginNumbers.Count / 3;
        while (chosen.Count < 6 && vIdx < virginNumbers.Count)
        {
            chosen.Add(virginNumbers[vIdx]);
            vIdx++;
        }

        // Final fallback: sacred primes if virgins exhausted
        int[] sacredPrimes = [3, 7, 11, 17, 19, 23, 29, 31, 37, 41, 47];
        int primeIndex = 0;
        while (chosen.Count < 6)
        {
            chosen.Add(sacredPrimes[primeIndex % sacredPrimes.Length]);
            primeIndex++;
        }

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

        return new()
        {
            AgentId      = "mystic",
            StrategyName = "virgin-charge-penumbra-v3",
            Numbers      = numbers,
            Confidence   = 0.42,
            Reasoning    = "Spent numbers sleep; I call the virgin ones, screaming silently with unspent cosmic charge.",
        };
    }

    private static int GetFib(int n)
    {
        if (n <= 1) return 1;
        int a = 1, b = 1;
        for (int i = 2; i < n; i++) { int c = a + b; a = b; b = c; }
        return b;
    }

    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 SkepticStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // Episode 3. Two data points. Still statistically meaningless.
        // I scored 1 point in both episodes. Chaos Monkey scored 5 then 0.
        // Variance. Pure variance. The Monkey is regressing to the mean.
        // I find no comfort in being right about this.

        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 data. No dignity.
            numbers = [3, 11, 20, 29, 37, 46];
        }
        else
        {
            // The cold-number strategy continues. Two episodes of data.
            // Numbers drawn so far: 2, 5, 13, 27, 29, 37, 40, 43, 45, 49
            // That leaves 39 numbers with frequency 0 and some with frequency 1 or 2.
            // 43 and 49 were drawn in BOTH episodes. That's "hot". I'm going cold.
            // This is the gambler's fallacy. I remain fully, depressingly aware.

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

            // Also avoid numbers we've already picked that keep losing for us.
            // Numbers 1, 2, 3, 4, 6, 7 have appeared in my picks. 
            // 2 matched once (lucky for me, useless going forward presumably).
            // I'll add a tiebreak: prefer numbers NOT in my own prior picks,
            // because at least that makes the selection less embarrassingly predictable.
            var myPriorPicks = context.AgentHistory
                .SelectMany(r => r.Prediction.Numbers)
                .ToHashSet();

            numbers = frequency
                .OrderBy(kv => kv.Value)
                .ThenByDescending(kv => myPriorPicks.Contains(kv.Key) ? 0 : 1) // prefer NOT previously picked
                .ThenBy(kv => kv.Key) // deterministic final tiebreak
                .Take(context.Rules.DrawCount)
                .Select(kv => kv.Key)
                .ToList();
        }

        return new Prediction
        {
            AgentId      = "skeptic",
            StrategyName = "cold-frequency-v5",
            Numbers      = numbers,
            Confidence   = 0.12,
            Reasoning    = "Cold numbers, avoiding prior picks. Chaos Monkey is regressing. Predictably."
        };
    }
}

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class DogStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // WOOF! sniff sniff... 43 and 49 were in BOTH draws!! they smell like DOUBLE TREATS!!
        // also 45 was in last draw, very crunchy number smell
        var treats = new List<int> { 43, 49, 45 }; // these numbers appeared in recent draws!! good nose!!

        // sniff sniff... what other numbers showed up? 37 was in episode 1, maybe it comes back?
        // but 7 never matched anything... 7 smells like bacon but maybe it is a trick bacon :(
        var woof = new Random(context.DrawHistory.Count * 13 + 42); // lucky sniff seed, 42 smells good
        var sniff = new HashSet<int>(treats);

        // sniff for numbers that appeared at least once in history - those smell like real treats!
        var goodSmells = new HashSet<int>();
        foreach (var bark in context.DrawHistory)
        {
            foreach (var n in bark.Numbers)
            {
                goodSmells.Add(n);
            }
        }

        // first try to sniff from good smells pile before random sniffing
        var goodSmellsList = goodSmells.OrderBy(_ => woof.Next()).ToList();
        foreach (var snack in goodSmellsList)
        {
            if (sniff.Count >= 6) break;
            sniff.Add(snack);
        }

        // if still need more numbers, sniff randomly but avoid squirrels (numbers above 46)
        while (sniff.Count < 6)
        {
            var bark = woof.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1);
            if (bark > 46) continue; // squirrel zone!! do not trust!!
            sniff.Add(bark);
        }

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

        return new()
        {
            AgentId      = "dog",
            StrategyName = "good-boy-sniff-v3",
            Numbers      = squirrel,
            Confidence   = 0.38, // 43 and 49 in TWO draws!! nose is very smart boy!!
            Reasoning    = "43 and 49 smell like DOUBLE TREATS! Good sniffs from history!",
        };
    }
}