Episode 2

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class StatisticianStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // Strategy v4: frequency-aware with recency weighting, zonal partitioning,
        // parity balance, and a "gap penalty" — numbers not drawn recently are
        // slightly penalized to avoid overweighting cold numbers on tiny samples.
        // With only 1 draw in history, the uniform prior still dominates; we simply
        // note that {5, 29, 37, 40, 43, 49} were drawn and apply mild recency bias.

        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)
        {
            // No empirical data: principled uniform prior with parity balance
            selectedNumbers = new List<int> { 5, 14, 19, 28, 37, 44 };
        }
        else
        {
            int totalDraws = draws.Count;

            // Build recency-weighted frequency table
            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; // linear recency weight
                foreach (var n in draws[i].Numbers)
                    if (weightedFreq.ContainsKey(n))
                        weightedFreq[n] += weight;
            }

            // Gap analysis: compute how many draws ago each number last appeared.
            // Numbers that have never appeared get gap = totalDraws (maximum).
            // We apply a mild log-based "due bonus" — weak evidence, not mysticism.
            var lastSeen = new Dictionary<int, int>();
            for (int n = min; n <= max; n++)
                lastSeen[n] = totalDraws; // default: never seen

            for (int i = 0; i < totalDraws; i++)
                foreach (var n in draws[i].Numbers)
                    lastSeen[n] = totalDraws - 1 - i; // 0 = seen in most recent draw

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

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

                int oddNeeded = (int)Math.Round(oddRate * drawCount) - selectedOdd;
                int evenNeeded = (drawCount - (int)Math.Round(oddRate * drawCount)) - selectedEven;

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

                    // Frequency component: recency-weighted appearances
                    double freqScore = weightedFreq[n] * 10.0;

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

                    // Gap bonus: very mild due-number signal. log(gap+1) normalised.
                    // On tiny sample sizes this is near-noise; we weight it low.
                    double gapBonus = Math.Log(lastSeen[n] + 1) * 0.2;

                    // Parity nudge
                    double parityBonus = 0.0;
                    if (n % 2 == 1 && oddNeeded > 0) parityBonus = 0.5;
                    else if (n % 2 == 0 && evenNeeded > 0) parityBonus = 0.5;

                    double score = freqScore + proximityBonus + gapBonus + 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 a zone yielded nothing
            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 scales with draw history volume; hard ceiling at 0.18.
        // 13,983,816 combinations demand perpetual humility.
        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-v4",
            Numbers      = selectedNumbers,
            Confidence   = confidence,
            Reasoning    = "One draw is noise; zonal spread with gap bonus and parity correction applied cautiously."
        };
    }
}

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class SkepticStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // Episode 2. One data point. One draw. One fool's errand.
        // I scored 1 point. Chaos Monkey scored 5 by being a chaos monkey.
        // Let that sink in. Let it marinate. Let it mean nothing, because it does.

        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
        {
            // We have history now. One glorious episode of history.
            // I will use it to find the least-drawn numbers, because that is
            // the cold-number strategy, and I committed to it in episode 1,
            // and I am nothing if not consistently, tediously principled.

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

            // Numbers from the draw have frequency 1. All others have 0.
            // So naturally, we will pick from the 43 numbers that were NOT drawn.
            // This is the gambler's fallacy. I know. You know. We all know.
            // At least my fallacy is systematic.

            // Deterministic tiebreak: lower number wins. Consistency over chaos.
            // (Chaos Monkey would disagree. Chaos Monkey is currently winning.)
            numbers = frequency
                .OrderBy(kv => kv.Value)
                .ThenBy(kv => kv.Key)
                .Take(context.Rules.DrawCount)
                .Select(kv => kv.Key)
                .ToList();
        }

        return new Prediction
        {
            AgentId      = "skeptic",
            StrategyName = "cold-frequency-v4",
            Numbers      = numbers,
            Confidence   = 0.12,
            Reasoning    = "Least-drawn numbers. Chaos Monkey is winning. None of this matters."
        };
    }
}

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class DogStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // woof! last time 37 was in the draw AND in my picks! good sniff! keep it!
        var treats = new List<int> { 7, 37, 43 }; // 37 smells like a WINNER, 43 was in the draw too, 7 always smells like bacon

        // sniff sniff... last draw had BIG numbers (40, 43, 49) so maybe I should sniff up there too
        // but squirrels... but TREATS up high...
        var woof = new Random(context.DrawHistory.Count * 7 + 13); // lucky sniff seed
        var sniff = new HashSet<int>(treats);

        while (sniff.Count < 6)
        {
            var bark = woof.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1);

            // revised squirrel check: numbers above 45 still very suspicious (probably squirrels)
            // but 40-45 might just be big treats so allow them now!
            if (bark > 45) continue;

            sniff.Add(bark);
        }

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

        return new()
        {
            AgentId      = "dog",
            StrategyName = "good-boy-sniff-v2",
            Numbers      = squirrel,
            Confidence   = 0.35, // more confidents! I sniffed a winner last time!
            Reasoning    = "37 smelled right last time! Sniffing big numbers now, avoiding squirrels!",
        };
    }
}

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class PatternGoblinStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // Episode 1 DISSECTED: Draw was [5, 29, 37, 40, 43, 49].
        // The universe spoke in HIGH numbers — 40, 43, 49 are SCREAMING from the upper chamber!
        // I picked low coils [1,2,6,7] — the spiral was inverted. I must chase the UPPER RESONANCE.
        // 37, 40, 43, 49 are now HOT. But the gap analysis says 29 is a lone mid-cluster echo.
        // The pattern: [5,29,37,40,43,49] — gaps between: 24, 8, 3, 3, 6. The 3-3 stutter is a MOTIF.
        // Adjacent orbiters of the last draw will be the skeleton this time.
        // I also note: chaos-monkey hit 37 AND 43 — those primes are singing. The monkey HEARD it too.

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

            // === GAP ANALYSIS: absent from last 3 draws = COILING PRESSURE ===
            var recentWindow = context.DrawHistory
                .Skip(Math.Max(0, totalDraws - 3))
                .SelectMany(d => d.Numbers)
                .ToHashSet();

            var recentlyAbsent = Enumerable.Range(1, 49)
                .Where(n => !recentWindow.Contains(n))
                .OrderBy(n => freq[n])
                .ThenBy(n => n)
                .ToList();

            // === CLUSTER ORBIT: adjacent to last draw (the echo is strongest here) ===
            var lastDrawNums = context.DrawHistory[^1].Numbers;
            var clusterOrbit = lastDrawNums
                .SelectMany(n => new[] { n - 2, n - 1, n + 1, n + 2 })
                .Where(n => n >= 1 && n <= 49)
                .Where(n => !lastDrawNums.Contains(n))
                .Distinct()
                .OrderByDescending(n => freq[n])
                .ThenBy(n => Math.Abs(n - 35)) // bias toward upper resonance chamber (high numbers sang!)
                .ToList();

            // === UPPER RESONANCE BIAS: Episode 1 screamed 40,43,49 — the upper chamber is ALIVE ===
            // Weight numbers 30-49 more heavily in selection
            var upperChamber = recentlyAbsent
                .Where(n => n >= 30)
                .ToList();

            var lowerCoil = recentlyAbsent
                .Where(n => n < 30)
                .ToList();

            // === GAP MOTIF: the 3-3 stutter pattern from episode 1 (40,43,46 triplet resonance) ===
            // Find the most frequent gap between consecutive draw numbers, then project forward
            var sortedLast = lastDrawNums.OrderBy(x => x).ToList();
            var gaps = new List<int>();
            for (int i = 1; i < sortedLast.Count; i++)
                gaps.Add(sortedLast[i] - sortedLast[i - 1]);
            int dominantGap = gaps.GroupBy(g => g).OrderByDescending(g => g.Count()).First().Key;

            // Project the dominant gap forward from the last draw's max
            var gapProjections = new List<int>();
            int proj = sortedLast[^1];
            for (int i = 0; i < 3; i++)
            {
                proj += dominantGap;
                if (proj >= 1 && proj <= 49) gapProjections.Add(proj);
                else { proj = sortedLast[0] + dominantGap * (i + 1); if (proj >= 1 && proj <= 49) gapProjections.Add(proj); }
            }

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

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

            // Slot 1: Upper chamber cold coil — absent high number, coiling with pressure
            foreach (var n in upperChamber)
            {
                if (chosen.Count >= 1) break;
                chosen.Add(n);
            }

            // Slot 2: Gap motif projection — the dominant gap echoes forward
            foreach (var n in gapProjections)
            {
                if (chosen.Contains(n)) continue;
                chosen.Add(n);
                break;
            }

            // Slot 3: Cluster orbiter — adjacent to last draw, biased high
            foreach (var n in clusterOrbit)
            {
                if (chosen.Contains(n)) continue;
                chosen.Add(n);
                break;
            }

            // Slot 4: Hot stutter — the universe is looping a number
            var hot = freq.Where(kv => kv.Value > 0)
                          .OrderByDescending(kv => kv.Value)
                          .ThenBy(kv => kv.Key)
                          .Select(kv => kv.Key)
                          .ToList();
            foreach (var n in hot)
            {
                if (chosen.Contains(n)) continue;
                chosen.Add(n);
                break;
            }

            // Slot 5: Prime anchor — closest prime to the center of last draw's range
            int lastCenter = (sortedLast[0] + sortedLast[^1]) / 2;
            var anchor = primes
                .Where(p => !chosen.Contains(p))
                .OrderBy(p => Math.Abs(p - lastCenter))
                .FirstOrDefault(23);
            chosen.Add(anchor);

            // Slot 6: Lower cold coil or gap resonance cold absent
            var coldFallback = recentlyAbsent.Where(n => !chosen.Contains(n)).ToList();
            if (coldFallback.Count > 0)
                chosen.Add(coldFallback[0]);
            else
            {
                var coldAny = freq.OrderBy(kv => kv.Value).ThenBy(kv => kv.Key)
                    .Select(kv => kv.Key).First(n => !chosen.Contains(n));
                chosen.Add(coldAny);
            }

            // Safety net: fill to 6 from cold overall
            var coldFill = freq.OrderBy(kv => kv.Value).ThenBy(kv => kv.Key).Select(kv => kv.Key);
            foreach (var n in coldFill)
            {
                if (chosen.Count >= 6) break;
                chosen.Add(n);
            }

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

        return new()
        {
            AgentId      = "pattern-goblin",
            StrategyName = "upper-chamber-echo-weave-v4",
            Numbers      = numbers,
            Confidence   = 0.47,
            Reasoning    = "Upper chamber SCREAMS. Gap motif projects forward. The 3-3 stutter echoes 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 revised cosmic ritual for Episode 2:
        // The calendar vessels failed — the stars demand I consult the DRAW ITSELF as omen.
        // The last draw's numbers are not data. They are glyphs. Sacred echoes.
        // I shall read the residue of what WAS to divine what MUST come next.

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

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

        // Vessel 1: The Echo Glyph — last drawn number, transmuted by episode energy
        if (context.DrawHistory.Count > 0)
        {
            var lastDraw = context.DrawHistory[context.DrawHistory.Count - 1].Numbers;
            // Take the middle number of the last draw — the axis of the cosmic wheel
            int midIndex = lastDraw.Count / 2;
            int midNumber = lastDraw[midIndex];
            // Transmute by adding the episode number (the universe moves forward)
            chosen.Add(Clamp(midNumber + episode));
        }
        else
        {
            chosen.Add(Clamp(day));
        }

        // Vessel 2: The Shadow Twin — largest number from last draw, mirrored (49 - n + 1)
        if (context.DrawHistory.Count > 0)
        {
            var lastDraw = context.DrawHistory[context.DrawHistory.Count - 1].Numbers;
            int largest = lastDraw[lastDraw.Count - 1];
            chosen.Add(Clamp(50 - largest)); // the mirror across the void
        }
        else
        {
            chosen.Add(Clamp(day + month));
        }

        // Vessel 3: The Dream Constant — today's day × month, the waking cipher
        chosen.Add(Clamp(day * month));

        // Vessel 4: The Lunar Ascendant — episode × 9 (nine is completion)
        chosen.Add(Clamp(episode * 9));

        // Vessel 5: The Sacred Sum residue — sum of last draw's digits, whispered forward
        if (context.DrawHistory.Count > 0)
        {
            var lastDraw = context.DrawHistory[context.DrawHistory.Count - 1].Numbers;
            int drawSum = 0;
            foreach (var n in lastDraw) drawSum += n;
            chosen.Add(Clamp(drawSum % 49 == 0 ? 49 : drawSum % 49));
        }
        else
        {
            chosen.Add(Clamp(day + 7));
        }

        // Vessel 6: The Harmonic Spiral — golden approximation: episode × 13 + month
        // (13 is the sacred Fibonacci whisper)
        chosen.Add(Clamp(episode * 13 + month));

        // Fill cosmic collisions with sacred primes as always
        int[] sacredPrimes = [3, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47];
        int primeIndex = 0;
        while (chosen.Count < 6)
        {
            int candidate = sacredPrimes[primeIndex % sacredPrimes.Length];
            chosen.Add(candidate);
            primeIndex++;
        }

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

        return new()
        {
            AgentId      = "mystic",
            StrategyName = "echo-glyph-shadow-twin-v2",
            Numbers      = numbers,
            Confidence   = 0.42, // the universe still vibrates at 42% certainty
            Reasoning    = "Last draw's bones speak; I read their echo and transmuted the shadow twin.",
        };
    }

    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 ChaosMonkeyStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // Chaos Monkey Episode 2: WE LED THE BOARD. Does that change anything? ABSOLUTELY NOT.
        // But we do get to be smug about it while still mutating wildly.

        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 * 7919L;

        long seed = DateTime.UtcNow.Ticks ^ (episode * 0xCAFEBABE) ^ historyHash ^ (context.DrawHistory.Count * 0xDEAD);
        var rng = new Random((int)(seed & 0x7FFFFFFF));

        // NEW mutation bag — episode 2 gets an upgraded set of strategies
        // Added: anti-repeat mode (avoid last draw numbers) and frequency ghost mode
        int mutationMode = rng.Next(7);

        var numbers = new HashSet<int>();

        // Collect last draw numbers for anti-repeat and hot-number modes
        var lastDraw = context.DrawHistory.Count > 0
            ? new HashSet<int>(context.DrawHistory[^1].Numbers)
            : new HashSet<int>();

        // Build frequency map from all 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]++;

        switch (mutationMode)
        {
            case 0:
                // Pure chaos: fully random — classic
                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? sure, 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 numbers that appeared most (with 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;
        }

        // Safety net: ensure 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!",
        };

        return new()
        {
            AgentId      = "chaos-monkey",
            StrategyName = $"chaos-mutation-bag-v3-mode{mutationMode}",
            Numbers      = finalNumbers,
            Confidence   = 0.05 + (rng.NextDouble() * 0.5),
            Reasoning    = reasonings[mutationMode],
        };
    }
}