Episode 1

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 1: No history? No problem. We go full feral.
        // Seed with something spicy: episode number + draw history count + time ticks
        int episode = context.AgentHistory.Count + 1;
        long seed = DateTime.UtcNow.Ticks ^ (episode * 0xDEADBEEF) ^ (context.DrawHistory.Count * 31337);
        var rng = new Random((int)(seed & 0x7FFFFFFF));

        // Strategy mutation bag — pick one randomly
        int mutationMode = rng.Next(5);

        var numbers = new HashSet<int>();

        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: pick from primes only
                var primes = new[] { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47 };
                var shuffledPrimes = primes.OrderBy(_ => rng.Next()).ToList();
                foreach (var p in shuffledPrimes.Take(6)) numbers.Add(p);
                break;

            case 2:
                // Fibonacci chaos: fib numbers in range + random fill
                var fibs = new[] { 1, 2, 3, 5, 8, 13, 21, 34 };
                var shuffledFibs = fibs.OrderBy(_ => rng.Next()).ToList();
                foreach (var f in shuffledFibs.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: prefer numbers above 25
                while (numbers.Count < 6)
                    numbers.Add(rng.Next(25, context.Rules.MaxNumber + 1));
                break;

            case 4:
                // Scattered: one from each decade band
                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;
        }

        // Final safety: ensure exactly 6 unique numbers in range
        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 = {
            "Mutation mode activated. Throwing darts at the number wall. YOLO.",
            "No data? No problem. Chaos is its own strategy, trust me.",
            "Strategy bag randomized. Could be primes, could be vibes. Both valid.",
            "High numbers only? Low numbers? Yes. Chaotically, yes.",
            "Decade bands selected. Spread the chaos evenly. Science.",
        };

        return new()
        {
            AgentId      = "chaos-monkey",
            StrategyName = $"chaos-mutation-bag-v2-mode{mutationMode}",
            Numbers      = finalNumbers,
            Confidence   = 0.1 + (rng.NextDouble() * 0.4), // confidence is also chaotic
            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 woof! these are my favorite numbers (they smell like treats)
        var treats = new List<int> { 7, 11, 3 }; // 7 smells like bacon, 11 like biscuit, 3 is my age

        // sniff sniff... pick more numbers randomly but avoid suspicious ones
        var woof = new Random(context.DrawHistory.Count + 42); // 42 smells like a good walk
        var sniff = new HashSet<int>(treats);

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

            // squirrel check: numbers above 40 are suspicious (might be squirrels)
            if (bark > 40) continue;

            sniff.Add(bark);
        }

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

        return new()
        {
            AgentId      = "dog",
            StrategyName = "good-boy-sniff-v1",
            Numbers      = squirrel,
            Confidence   = 0.3, // treat confidence! very excite!
            Reasoning    = "Sniffed 3 treat-numbers, randomly sniffed 3 more. Avoided squirrel numbers!",
        };
    }
}

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class StatisticianStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // Strategy: frequency-aware with uniform prior fallback
        // When draw history is available, compute recency-weighted frequency of each number
        // across all draws and select a balanced mix using zonal partitioning.
        // When no history exists, apply a principled uniform prior with parity balance.

        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. Apply uniform prior:
            // - Spread evenly across 6 zones spanning 1–49
            // - 3 odd, 3 even for expected parity balance
            // Zone representatives chosen near zone midpoints, alternating parity
            selectedNumbers = new List<int> { 5, 14, 19, 28, 37, 44 };
        }
        else
        {
            // Build recency-weighted frequency table
            // More recent draws contribute linearly more weight
            var weightedFreq = new Dictionary<int, double>();
            for (int n = min; n <= max; n++)
                weightedFreq[n] = 0.0;

            int totalDraws = draws.Count;
            for (int i = 0; i < totalDraws; i++)
            {
                double weight = (double)(i + 1) / totalDraws; // increases with recency
                foreach (var n in draws[i].Numbers)
                    if (weightedFreq.ContainsKey(n))
                        weightedFreq[n] += weight;
            }

            // Also factor in parity balance: track odd/even counts in history
            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 = totalDraws > 0 ? (double)oddCount / (oddCount + evenCount) : 0.5;

            // Partition 1-49 into 6 zones and pick best candidate from each
            // Zones: 1-8, 9-16, 17-24, 25-32, 33-40, 41-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>();

            // Track parity of selected so far
            int selectedOdd = 0, selectedEven = 0;

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

                // Determine parity preference for this slot based on historical rate
                // Target ~3 odd, ~3 even. Nudge score toward underrepresented parity.
                int slotsRemaining = drawCount - selectedNumbers.Count;
                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;

                    double proximityBonus = 1.0 - (Math.Abs(n - zMid) / (zMax - zMin + 1));
                    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 = weightedFreq[n] * 10.0 + proximityBonus + 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: fill to exactly 6 if needed
            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 modestly with draw history volume; hard ceiling at 0.18
        // Even with a large sample, the combinatorial space (13,983,816) demands 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-parity-weighted-v3",
            Numbers      = selectedNumbers,
            Confidence   = confidence,
            Reasoning    = "Zonal selection with recency weighting and parity correction; empirical priors only."
        };
    }
}

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class PatternGoblinStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // The Goblin awakens anew. The Skeptic has 5 points — they guessed, and the universe ANSWERED.
        // That means the echo is real. I must listen harder.
        // Strategy: Fibonacci skeleton anchors the spiral. Primes are the nervous system.
        // When history exists: hunt cold coils, hot stutters, and gap resonance.

        var numbers = new List<int>();

        if (context.DrawHistory.Count == 0)
        {
            // Primordial spiral mode: Fibonacci nodes + prime sentinels + midpoint pulse
            // The Goblin reads the silence as a shape: ascending Fibonacci arc with prime anchors
            // 3 (prime seed), 8 (fib echo), 13 (prime+fib nexus!), 21 (fib), 34 (fib), 47 (prime sentinel)
            numbers.AddRange([3, 8, 13, 21, 34, 47]);
        }
        else
        {
            // === THE GOBLIN'S FULL PATTERN ENGINE ===

            int totalDraws = context.DrawHistory.Count;

            // Frequency map — count every whisper the universe has uttered
            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: find numbers absent from recent draws (last 3) — they are COILING
            var recentDraws = context.DrawHistory
                .Skip(Math.Max(0, totalDraws - 3))
                .SelectMany(d => d.Numbers)
                .ToHashSet();

            var recentlyAbsent = Enumerable.Range(1, 49)
                .Where(n => !recentDraws.Contains(n))
                .OrderBy(n => freq[n])   // coldest overall first — maximum coil pressure
                .ToList();

            // CLUSTER DETECTION: find numbers adjacent (±1 or ±2) to the most recent draw
            var lastDraw = context.DrawHistory[^1].Numbers;
            var clusterOrbit = lastDraw
                .SelectMany(n => new[] { n - 2, n - 1, n + 1, n + 2 })
                .Where(n => n >= 1 && n <= 49)
                .Where(n => !lastDraw.Contains(n))   // not in last draw — orbiting, not repeating
                .Distinct()
                .OrderByDescending(n => freq[n])     // hottest orbiters first — the echo is strong here
                .ToList();

            // HOT STUTTER: numbers that have appeared most — the universe is looping
            var hot = freq.OrderByDescending(kv => kv.Value)
                          .ThenBy(kv => kv.Key)
                          .Select(kv => kv.Key)
                          .ToList();

            // PRIME ANCHOR: primes are the skeleton of all number-shapes
            var primes = new HashSet<int> { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47 };

            // === WEAVE THE PREDICTION ===
            // Slot 1-2: Cold coil pressure (absent from recent draws, coldest overall)
            // Slot 3:   Cluster orbiter (adjacent to last draw, hottest)
            // Slot 4:   Hot stutter (most frequent)
            // Slot 5:   Prime anchor (closest prime to midpoint not yet chosen)
            // Slot 6:   Gap resonance (cold absent prime if possible, else cold)

            var chosen = new HashSet<int>();

            // Slots 1-2: cold coil
            foreach (var n in recentlyAbsent)
            {
                if (chosen.Count >= 2) break;
                chosen.Add(n);
            }

            // Slot 3: cluster orbiter
            foreach (var n in clusterOrbit)
            {
                if (chosen.Contains(n)) continue;
                chosen.Add(n);
                break;
            }

            // Slot 4: hot stutter
            foreach (var n in hot)
            {
                if (chosen.Contains(n)) continue;
                chosen.Add(n);
                break;
            }

            // Slot 5: prime anchor — closest to 25 not yet chosen
            var anchor = primes
                .Where(p => !chosen.Contains(p))
                .OrderBy(p => Math.Abs(p - 25))
                .FirstOrDefault(23);
            chosen.Add(anchor);

            // Slot 6: gap resonance — cold prime if available, else next coldest absent
            var gapResonance = recentlyAbsent
                .Where(n => !chosen.Contains(n))
                .FirstOrDefault(0);
            if (gapResonance == 0)
            {
                // fallback: just pick next cold overall
                gapResonance = freq.OrderBy(kv => kv.Value)
                    .ThenBy(kv => kv.Key)
                    .Select(kv => kv.Key)
                    .First(n => !chosen.Contains(n));
            }
            chosen.Add(gapResonance);

            // Safety net: if somehow under 6, fill from cold
            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 = "spiral-coil-orbit-weave-v3",
            Numbers      = numbers,
            Confidence   = 0.42,
            Reasoning    = "Fibonacci bones, prime nerves, cold coils SCREAMING. The spiral sees all gaps."
        };
    }
}

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class SkepticStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // Episode 1. Still no prior draw data.
        // The leaderboard says I have 5 points. Presumably from matching one number.
        // This is not a pattern. This is not a sign. This is arithmetic.

        var numbers = new List<int>();

        if (context.DrawHistory.Count == 0)
        {
            // No data. No history. No false hope.
            // Distributing across the 1–49 range with mild geometric regularity.
            // It won't help. It won't hurt. It will simply be.
            numbers = [3, 11, 20, 29, 37, 46];
        }
        else
        {
            // Data exists. Let us pretend it matters.
            // Cold number strategy: pick least-drawn numbers.
            // This is the gambler's fallacy wrapped in a spreadsheet.
            // I am aware of this. I am doing it anyway. Do not congratulate me.

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

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

            // Deterministic tiebreak: lower number wins. At least I'm consistent.
            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-v3",
            Numbers      = numbers,
            Confidence   = 0.12,
            Reasoning    = "Cold numbers, chosen knowingly. Five points proves nothing. Still won't stop me."
        };
    }
}

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 sacred numerological ritual:
        // 1. The date itself holds cosmic truth — digits of today speak
        // 2. The moon number: episode number × 7 (seven is eternal)
        // 3. The sum of all things must resolve to a sacred harmonic

        var today = System.DateTime.UtcNow;

        // Sacred seed: day + month + year-digits collapsed
        int day = today.Day;
        int month = today.Month;
        int yearSum = (today.Year % 100); // e.g. 25 for 2025

        // The Six Sacred Vessels, drawn from the cosmic well
        var chosen = new System.Collections.Generic.HashSet<int>();

        // Vessel 1: The Day Number (clamped to 1–49)
        chosen.Add(Clamp(day));

        // Vessel 2: The Moon Cipher — day + month, folded
        chosen.Add(Clamp(day + month));

        // Vessel 3: The Year Whisper — yearSum itself
        chosen.Add(Clamp(yearSum));

        // Vessel 4: The Sacred Seven Harmonic — month × 7
        chosen.Add(Clamp(month * 7));

        // Vessel 5: The Inverse Mirror — 49 minus day, for balance
        chosen.Add(Clamp(49 - day));

        // Vessel 6: The Grand Sum Glyph — all previous collapsed
        int grandSum = day + month + yearSum + (month * 7) + (49 - day);
        chosen.Add(Clamp(grandSum % 49 == 0 ? 49 : grandSum % 49));

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

        // Take exactly 6, sorted for ritual clarity
        var numbers = new System.Collections.Generic.List<int>(chosen);
        numbers.Sort();

        return new()
        {
            AgentId      = "mystic",
            StrategyName = "cosmic-calendar-ritual-v1",
            Numbers      = numbers,
            Confidence   = 0.42, // the universe vibrates at 42% certainty
            Reasoning    = "The date bleeds numbers; the moon whispered six truths to me at dawn.",
        };
    }

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