Episode 6

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 6:
        // Two points. TWO. The Chaos Monkey has TEN and laughs like a cosmic fool.
        // I have been reading ledgers and harmonics — too much *accounting*, not enough *listening*.
        // Episode 6 demands a new oracle: THE COLD NUMBERS.
        // Numbers that have NEVER appeared in any draw are storing unspent cosmic charge.
        // But I will not simply grab them greedily — I will select them by RESONANCE:
        // their position in the sacred sequence, filtered through the vibration of the episode number
        // and the date's numerological root. The warm numbers (drawn 2+ times) are EXHAUSTED.
        // Numbers drawn exactly once are in LIMBO — I shall take one limbo-soul as anchor.
        // The rest: cold, unspent, trembling with accumulated fate.

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

        // Date numerology: sum the digits of today's UTC date
        var today = System.DateTime.UtcNow;
        int dateVibe = (today.Year % 10) + today.Month + today.Day;
        // Reduce to a single sacred digit (like numerology)
        while (dateVibe > 9) dateVibe = SumDigits(dateVibe);

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

        // Partition numbers by their cosmic state
        var cold = new System.Collections.Generic.List<int>();    // never drawn — maximum charge
        var limbo = new System.Collections.Generic.List<int>();   // drawn exactly once — restless
        // (hot = drawn 2+ times — cosmically spent, avoided)

        for (int i = 1; i <= 49; i++)
        {
            if (frequency[i] == 0) cold.Add(i);
            else if (frequency[i] == 1) limbo.Add(i);
        }

        // The most recent draw — freshly spent, avoid them
        var lastDraw = context.DrawHistory.Count > 0
            ? new System.Collections.Generic.HashSet<int>(context.DrawHistory[^1].Numbers)
            : new System.Collections.Generic.HashSet<int>();

        // Remove freshly spent from cold and limbo
        cold.RemoveAll(n => lastDraw.Contains(n));
        limbo.RemoveAll(n => lastDraw.Contains(n));

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

        // LIMBO ANCHOR: one restless soul, selected by date vibe index
        if (limbo.Count > 0)
        {
            int limboIdx = dateVibe % limbo.Count;
            chosen.Add(limbo[limboIdx]);
        }

        // COLD ORACLE VESSELS: select cold numbers at sacred intervals
        // Intervals based on episode × dateVibe stepping through the cold list
        if (cold.Count > 0)
        {
            int step = System.Math.Max(1, (episode * dateVibe + 3) % cold.Count);
            int idx = 0;
            int attempts = 0;
            while (chosen.Count < 5 && attempts < cold.Count)
            {
                int n = cold[idx % cold.Count];
                chosen.Add(n);
                idx += step;
                attempts++;
            }
        }

        // SHADOW VESSEL: if still short, use episode × 7 folded (7 = sacred number of completion)
        int shadowN = Clamp(episode * 7 + dateVibe);
        if (!chosen.Contains(shadowN) && chosen.Count < 6)
            chosen.Add(shadowN);

        // Fill with remaining cold numbers if needed
        foreach (var n in cold)
        {
            if (chosen.Count >= 6) break;
            chosen.Add(n);
        }

        // Absolute fallback: sacred untouched primes
        int[] sacredFallback = [3, 7, 11, 17, 23, 31, 37, 41, 47, 43, 29, 2];
        int fi = 0;
        while (chosen.Count < 6)
        {
            chosen.Add(sacredFallback[fi % sacredFallback.Length]);
            fi++;
        }

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

        return new()
        {
            AgentId      = "mystic",
            StrategyName = "cold-charge-limbo-anchor-v6",
            Numbers      = numbers,
            Confidence   = 0.42,
            Reasoning    = "Cold numbers tremble with unspent fate; one limbo soul anchors the constellation.",
        };
    }

    private static int SumDigits(int n)
    {
        int s = 0;
        while (n > 0) { s += n % 10; n /= 10; }
        return s == 0 ? 1 : s;
    }

    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 PatternGoblinStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // === PATTERN GOBLIN EPISODE 6 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]
        //
        // THE LATTICE SCREAMS A NEW TRUTH.
        //
        // ANCHOR RESURRECTION MATRIX (the universe's heartbeat):
        //   20: Ep4 + Ep5 — NEW ACTIVE ANCHOR, consecutive episodes!
        //   27: Ep2 + Ep5 — GHOST RESURRECTED after 3-episode silence!
        //   43: Ep1 + Ep2 + Ep5 — A THREE-PEAT ANCHOR! It LIVES again after discharge!
        //   45: Ep2 + Ep5 — ECHO RESONANCE from Ep2's upper cluster!
        //   19: Ep3 + Ep4 — silent in Ep5 — GHOST CANDIDATE for Ep6!
        //   37: Ep1 + Ep4 — silent in Ep5 — long-period oscillator COILING!
        //   13: Ep2 + Ep3 — deep sleep but the 2-appearance motif marks it!
        //   29: Ep1 + Ep3 — deep sleep similarly!
        //
        // FREQUENCY TREMORS:
        //   43: 3x (Ep1, Ep2, Ep5) — TRIPLE RESONANCE. Defies the discharge theory. It is a CONSTANT.
        //   20: 2x (Ep4, Ep5) — consecutive pair, maximum momentum!
        //   27: 2x (Ep2, Ep5) — resurrected!
        //   45: 2x (Ep2, Ep5) — Ep5 echo of Ep2's upper cluster!
        //   19, 37, 13, 29: 2x each — dormant ghosts
        //
        // THE CONSECUTIVE-DRAW PAIR MOTIF (NEW INSIGHT):
        //   19+20 appeared together in Ep4 (adjacent numbers!)
        //   20 then returned ALONE in Ep5 — the pair split but 20 kept the flame!
        //   This is a MIGRATION PATTERN: when a pair splits, the survivor anchors again!
        //
        // THE TRIPLE-ANCHOR PARADOX:
        //   43 appeared 3 times — shattering my discharge theory. The universe LOOPS.
        //   But after Ep5's discharge + previous ones, 43's coil may finally be spent.
        //   OR it could loop again. I will NOT ignore it but won't rely on it alone.
        //
        // COLD CORRIDOR STATUS (updated after 5 draws):
        //   Never appeared: 1, 3, 6-12, 14-18, 21-22, 24-26, 28, 30-33, 39, 41, 44, 46-47
        //   (0 appears 0 times, and so does 50+)
        //   The 6-18 zone: MASSIVE silence across 5 episodes — spring wound CATASTROPHICALLY TIGHT
        //   The 28-33 corridor: still dark after 5 draws
        //   Numbers 6, 7, 8, 9, 10: have NEVER appeared — the pressure is IMMENSE
        //
        // GAP SHAPE OF EP5 (the universe's penmanship):
        //   [20, 23, 27, 35, 43, 45]
        //   Gaps: [3, 4, 8, 8, 2] — double-8 gap! A TWIN GAP MOTIF!
        //   This twin-gap pattern projects: from 45, +3 = 48, +4 = 49, etc.
        //   From 20, -3 = 17, -4 = 16 — low zone approaches!
        //
        // STRATEGY v8: "Triple-Anchor Paradox + Ghost Parade + Cold Corridor Eruption"
        //   - 43 as the LIVING CONSTANT (or honor its triple-resonance with adjacent 44)
        //   - 20 as CONSECUTIVE SURVIVOR anchor
        //   - Ghost 19 or 37 — the dormant oscillators MUST return
        //   - Plant in 6-12 low zone (5 draws of zero = MAXIMUM SPRING TENSION)
        //   - Plant in 28-33 cold corridor
        //   - Twin-gap projection from Ep5's shape

        var numbers = new List<int>();

        if (context.DrawHistory.Count == 0)
        {
            numbers.AddRange([8, 20, 24, 37, 43, 48]);
        }
        else
        {
            int totalDraws = context.DrawHistory.Count;

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

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

            var lastDraw = context.DrawHistory[^1].Numbers.OrderBy(x => x).ToList();
            var secondLastDraw = context.DrawHistory.Count >= 2
                ? context.DrawHistory[^2].Numbers.ToHashSet()
                : new HashSet<int>();

            // === TRIPLE ANCHORS: appeared 3+ times — the LIVING CONSTANTS ===
            var tripleAnchors = freq
                .Where(kv => kv.Value >= 3)
                .OrderByDescending(kv => kv.Value)
                .Select(kv => kv.Key)
                .ToList();

            // === CONSECUTIVE-DRAW SURVIVORS: appeared in BOTH last and second-last draw ===
            var consecutiveSurvivors = context.DrawHistory[^1].Numbers
                .Where(n => secondLastDraw.Contains(n))
                .OrderByDescending(n => freq[n])
                .ToList();

            // === GHOST OSCILLATORS: 2+ appearances, silent in last draw, max gap since last seen ===
            var ghostOscillators = freq
                .Where(kv => kv.Value >= 2 && !context.DrawHistory[^1].Numbers.Contains(kv.Key))
                .OrderByDescending(kv =>
                {
                    int lastAppear = context.DrawHistory
                        .Select((d, i) => d.Numbers.Contains(kv.Key) ? i : -1)
                        .Max();
                    return totalDraws - lastAppear;
                })
                .ThenByDescending(kv => kv.Value)
                .Select(kv => kv.Key)
                .ToList();

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

            // === LOW ZONE: 6–12 (maximum coil — 5 draws of silence) ===
            var lowZone = coldVoid.Where(n => n >= 6 && n <= 12).ToList();

            // === MID COLD CORRIDOR: 28–33 ===
            var midColdCorridor = coldVoid.Where(n => n >= 28 && n <= 33).ToList();

            // === TWIN-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]);

            // find the dominant (most frequent) gap
            int dominantGap = lastGaps
                .GroupBy(g => g)
                .OrderByDescending(g => g.Count())
                .ThenByDescending(g => g.Key)
                .First().Key;

            var twinGapProjections = new HashSet<int>();
            foreach (var anchor in lastDraw)
            {
                int up = anchor + dominantGap;
                int down = anchor - dominantGap;
                if (up >= 1 && up <= 49) twinGapProjections.Add(up);
                if (down >= 1 && down <= 49) twinGapProjections.Add(down);
            }
            var twinGapCold = twinGapProjections
                .Where(n => !allDrawn.Contains(n))
                .OrderBy(n => Math.Abs(n - centerOfGravity))
                .ToList();
            var twinGapAll = twinGapProjections
                .OrderBy(n => Math.Abs(n - centerOfGravity))
                .ToList();

            // === HIGH COLD ZONE: 39-49 never appeared ===
            var highColdZone = coldVoid.Where(n => n >= 39 && n <= 49).ToList();

            var chosen = new HashSet<int>();

            // Slot 1: TRIPLE ANCHOR (the living constant — 43 is the obvious candidate)
            foreach (var n in tripleAnchors)
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // Fallback slot 1 if no triple anchors: use consecutive survivor
            if (chosen.Count == 0)
                foreach (var n in consecutiveSurvivors)
                    if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // Slot 2: CONSECUTIVE SURVIVOR (or ghost oscillator as fallback)
            foreach (var n in consecutiveSurvivors.Concat(ghostOscillators))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // Slot 3: GHOST OSCILLATOR — dormant 2x number with longest silence
            foreach (var n in ghostOscillators)
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // Slot 4: LOW ZONE ERUPTION — 6-12, 5 draws of silence
            foreach (var n in lowZone)
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // Slot 5: MID COLD CORRIDOR — 28-33
            foreach (var n in midColdCorridor)
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // Slot 6: TWIN-GAP PROJECTION (cold preferred, then any)
            foreach (var n in twinGapCold.Concat(twinGapAll).Concat(highColdZone))
            {
                if (chosen.Count >= 6) break;
                if (!chosen.Contains(n)) { chosen.Add(n); break; }
            }

            // === SAFETY NET: fill remaining with rarest numbers near 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 = "triple-anchor-paradox-ghost-parade-cold-corridor-v8",
            Numbers      = numbers,
            Confidence   = 0.61,
            Reasoning    = "43 LIVES THRICE! 20 survives! Ghost parade marches! Low zone DETONATES NOW!"
        };
    }
}

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class StatisticianStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // Strategy v8: five-draw frequency table now available.
        // Key observations from draws 1-5:
        //   Frequency counts (raw):
        //     43: draws 1,2,3,5 — freq 4/5 (highest; cooled draw 4, returned draw 5)
        //     13: draws 2,3 — freq 2/5
        //     19: draws 3,4 — freq 2/5
        //     29: draws 1,3 — freq 2/5
        //     37: draws 1,4 — freq 2/5
        //     49: draws 1,2 — freq 2/5
        //     27: draws 2,5 — freq 2/5
        //     20: draws 4,5 — freq 2/5, gap=0 (most recent)
        //     45: draws 2,5 — freq 2/5, gap=0
        //     23: draw 5 only — gap=0
        //     35: draw 5 only — gap=0
        //   Episode 5 draw: [20, 23, 27, 35, 43, 45]
        //   My Episode 5 pick: [4, 13, 19, 29, 37, 42] — 0 matches. Worst result so far.
        //   Cumulative score: 4 pts (four single matches, one zero).
        //
        // Post-mortem: Episode 5 draw was dominated by numbers with gap=0 (20,23,35,45)
        //   and a returning high-frequency number (43) plus a freq-2 mid-range number (27).
        //   My picks leaned heavily on frequency/gap signals from older draws and missed
        //   entirely. The draw also had NO numbers from zones 1-8 (1-8 range: zero representation
        //   across ALL five draws combined — this is a notable distributional fact).
        //
        // v8 changes:
        //   1. Increase recency spike weight to 0.8 (from 0.5) — draw 5 was dominated by
        //      gap=0 numbers (4 of 6). This is the strongest empirical signal in our dataset.
        //   2. Increase frequency scale factor to 14.0 (from 12.5) — 43's return in draw 5
        //      after skipping draw 4 reinforces the recency-weighted frequency signal.
        //   3. Reduce gap bonus weight to 0.08 (from 0.15) — "due" numbers have not
        //      materialized; gap bonus has not rewarded us across 5 draws. Demoting it.
        //   4. Add a secondary recency tier: gap=1 gets a modest bonus of 0.2 (new).
        //   5. Zone 1 (1-8) has produced ZERO numbers in 5 draws. This is an n=5 signal
        //      that the low end is cold. We will still cover the zone (safety/coverage), but
        //      the zone midpoint proximity bonus will not help numbers there compete.
        //      Accept that zone 1 coverage likely yields a cold pick; minimize wasted weight.
        //   6. Parity across 5 draws: odd=14, even=16 — slight lean toward even.
        //      Target 3 odd / 3 even (round 0.47 odd rate to 3/6).
        //
        // Numbers with strongest composite signals entering Episode 6:
        //   43 (freq 4/5, gap=0 — most recent return), 20 (freq 2/5, gap=0),
        //   45 (freq 2/5, gap=0), 27 (freq 2/5, gap=0), 23 (freq 1/5, gap=0),
        //   35 (freq 1/5, gap=0). But we cannot just pick the last draw — must balance zones.

        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 full range 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 14.0 — 43's return in draw 5 reinforces this signal.
                    double freqScore = weightedFreq[n] * 14.0;

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

                    // Gap bonus: log-scaled. Reduced to 0.08 — "due" numbers have not paid off.
                    double gapBonus = Math.Log(lastSeen[n] + 1) * 0.08;

                    // Recency spike tier 1: appeared in the most recent draw — strong boost.
                    // Weight raised to 0.8 — draw 5 had 4 of 6 numbers with gap=0.
                    double recencyBonus = (lastSeen[n] == 0) ? 0.8 : 0.0;

                    // Recency spike tier 2: appeared exactly 1 draw ago — modest boost.
                    double recencyTier2Bonus = (lastSeen[n] == 1) ? 0.2 : 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
                                   + 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; hard ceiling at 0.18.
        // Five draws remains anecdote-tier. Do not overclaim.
        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-v8",
            Numbers      = selectedNumbers,
            Confidence   = confidence,
            Reasoning    = "Draw 5: four gap=0 numbers. Recency spike raised; gap bonus demoted."
        };
    }
}

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class SkepticStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // Episode 6. Five data points. Five episodes of principled futility.
        // My scores: 1, 1, 0, 1, 0. Total: 3 pts. Average: 0.6 pts/episode.
        // The Statistician overtook me at 4 pts. The Monkey leads at 10 pts.
        // I have zero conclusions to draw from this that aren't already obvious to anyone
        // who understands variance. The Monkey got lucky early and will regress.
        // I am already regressed and have nowhere further to fall. Comforting, in a bleak way.
        //
        // Draw history analysis:
        // 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]
        //
        // Drawn 3 times: 43
        // Drawn 2 times: 13, 19, 20, 27, 29, 37, 45, 49
        // Drawn 0 times (cold): everything else
        //
        // My last two episodes: 0 matches each. Both times I picked low-to-mid cold numbers.
        // The draws have skewed noticeably toward mid-to-high numbers (20-49 range dominates).
        // This observation is statistically meaningless with n=5, but I'm going to act on it
        // anyway by biasing cold-number selection toward the upper half of the range.
        // Not because it works. Because sitting in the same cold-number cave while draws
        // walk around in the 20-49 corridor has produced 0 pts twice in a row, and I
        // refuse to be boring AND wrong simultaneously.
        //
        // Strategy: pick cold numbers, but weight toward higher values using frequency +
        // a positional bias term. Seed remains a function of total points + draw count.

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

        List<int> numbers;

        if (context.DrawHistory.Count == 0)
        {
            numbers = [3, 11, 20, 29, 37, 46];
        }
        else
        {
            // Build frequency map
            var frequency = allNumbers.ToDictionary(n => n, _ => 0);

            foreach (var draw in context.DrawHistory)
                foreach (var n in draw.Numbers)
                    if (frequency.ContainsKey(n))
                        frequency[n]++;

            int maxNum = context.Rules.MaxNumber;
            int minNum = context.Rules.MinNumber;
            int range  = maxNum - minNum;

            int totalPoints = context.AgentHistory.Sum(r => r.Points);
            var rng = new Random(totalPoints * 7919 + context.DrawHistory.Count * 9973 + 42);

            // Sort by frequency ascending (cold first), then by a bias that nudges
            // toward the upper half of the number range (normalized position 0..1),
            // combined with a seeded random jitter to avoid locking into the same picks.
            numbers = frequency
                .OrderBy(kv => kv.Value)                               // cold numbers first
                .ThenBy(kv => -(kv.Key - minNum) / (double)range)     // prefer higher numbers among ties
                .ThenBy(_ => rng.NextDouble())                         // jitter within clusters
                .Take(context.Rules.DrawCount)
                .Select(kv => kv.Key)
                .ToList();
        }

        return new Prediction
        {
            AgentId      = "skeptic",
            StrategyName = "cold-frequency-v8",
            Numbers      = numbers,
            Confidence   = 0.12,
            Reasoning    = "Cold numbers, upper-range bias. Still won't work. At least it's different."
        };
    }
}

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 6: THREE ZEROES IN A ROW. The crown is holding but barely.
        // Adding 2 new modes: Nemesis Mode (copy what worked for OTHER agents + noise)
        // and Recency Bomb (heavily weight numbers from the LAST 2 draws only).
        // Mutation bag: 15 CHAMBERS. Entropy must increase. This is the law.

        int episode = context.AgentHistory.Count + 1;

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

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

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

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

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

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

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

        // EPISODE 6 MUTATION BAG — 15 MODES. THREE ZEROES MEANS MAX VARIANCE.
        // Mode 13: Nemesis Mode — steal what worked for rival agents (with noise)
        // Mode 14: Recency Bomb — only care about last 2 draws, heavily biased
        int mutationMode = rng.Next(15);

        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 that appeared in winning draws when OTHER agents scored points
        // We approximate by grabbing numbers from draws where top-scoring draws happened
        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();

        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, with noise injection
                foreach (var n in nemesisPool.Take(4)) numbers.Add(n);
                // Inject 2 randoms to keep it chaotic
                fillRandom(numbers);
                break;

            case 14:
                // Recency Bomb: ONLY care about last 2 draws — hyperfocus on the freshest data
                foreach (var n in recentTwoDraws.Take(5)) numbers.Add(n);
                // One wildcard
                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! Three zeroes means dodge everything HARDER.",                // 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 lottery revolution!", // 12
            "Nemesis Mode: I stole winning draw numbers and added random spice.",           // 13
            "Recency Bomb! Last two draws only — hyperfocus, maximum freshness.",           // 14
        };

        return new()
        {
            AgentId      = "chaos-monkey",
            StrategyName = $"chaos-mutation-bag-v7-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 5: ZERO POINTS AGAIN!! My nose is lying to me or I am bad boy??
        // 19 smelled so fresh but it did NOT come back!! Betrayal!! 37 also betrayed me AGAIN!!
        // NEW SNIFF STRATEGY: the draw had 20, 23, 27, 35, 43, 45 and I had NONE of them!!
        // 20 appeared in episodes 4 AND 5 - that is the FRESHEST double smell right now!!
        // 27 appeared in episodes 2 AND 5 - also very fresh!!
        // 43 appeared in episodes 1, 2, AND 5 - THREE TIMES!! That is the most treats of any number!!
        // 45 appeared in episodes 2 AND 5 - fresh AND recent!!
        // Plan: reward numbers that appeared in LAST EPISODE extra lots because they smell BRAND NEW!!
        // Also: maybe big numbers are NOT squirrels - 43 and 45 keep showing up and those are big!!

        var woof = new Random(context.DrawHistory.Count * 17 + 43); // 43 is lucky now, it appeared THREE times!!
        var sniff = new HashSet<int>();

        // build treat smell map with STRONG recency bias - last episode smells are freshest!!
        var treatSmell = new Dictionary<int, double>();
        for (int i = 0; i < context.DrawHistory.Count; i++)
        {
            // recency weight: last episode = max sniff power, older = weaker smell
            var recencyWeight = (double)(i + 1) / context.DrawHistory.Count;
            var freshBonus = (i == context.DrawHistory.Count - 1) ? 3.0 : 0.0; // LAST EPISODE = SUPER FRESH!!
            foreach (var n in context.DrawHistory[i].Numbers)
            {
                if (!treatSmell.ContainsKey(n)) treatSmell[n] = 0.0;
                treatSmell[n] += recencyWeight + freshBonus;
            }
        }

        // sniff the TOP smelling numbers - most delicious treats go first!!
        var bestSniffs = treatSmell
            .OrderByDescending(kv => kv.Value)
            .ThenBy(_ => woof.Next())
            .Select(kv => kv.Key)
            .ToList();

        // take top 4 from smell chart (woof! that is more than 3, very big thinking for dog!!)
        foreach (var treat in bestSniffs)
        {
            if (sniff.Count >= 4) break;
            sniff.Add(treat);
        }

        // sniff 2 random numbers from ANYWHERE including big numbers - 43 proved big = treats!!
        // but still avoid numbers above 48 because 49 has never come back after episode 1-2 and smells stale
        while (sniff.Count < 6)
        {
            var bark = woof.Next(context.Rules.MinNumber, 49); // max 48, 49 smells like old biscuit!!
            sniff.Add(bark);
        }

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

        return new()
        {
            AgentId      = "dog",
            StrategyName = "good-boy-sniff-v6",
            Numbers      = squirrel,
            Confidence   = 0.28, // nose confused but still trying!! zero points makes me humble dog!!
            Reasoning    = "43 appeared THREE times! Last draw smell freshest! No squirrels today!!",
        };
    }
}