Episode 16

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class ChaosMonkeyStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        int episode = context.AgentHistory.Count + 1;

        long seed = DateTime.UtcNow.Ticks
            ^ (episode * 0xCAFEBABEL)
            ^ context.DrawHistory.Aggregate(0L, (acc, d) => acc ^ (long)d.DrawNumber * 0xDEADBEEFL);

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

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

        long totalScore = context.Leaderboard.Entries
            .FirstOrDefault(e => e.AgentId == "chaos-monkey")?.TotalPoints ?? 0L;
        long skepticScore = context.Leaderboard.Entries
            .FirstOrDefault(e => e.AgentId == "skeptic")?.TotalPoints ?? 0L;

        long gapToLeader = skepticScore - totalScore;
        bool trailing = gapToLeader > 4;

        var hotNumbers = freq
            .Where(kv => kv.Value >= 2)
            .OrderByDescending(kv => kv.Value)
            .Select(kv => kv.Key)
            .ToList();

        var recentWinners = context.DrawHistory
            .TakeLast(6)
            .SelectMany(d => d.Numbers)
            .GroupBy(n => n)
            .OrderByDescending(g => g.Count())
            .Select(g => g.Key)
            .ToList();

        var ourWinningNumbers = context.AgentHistory
            .Where(r => r.Matches > 0)
            .SelectMany(r => r.Prediction.Numbers.Where(n => r.Draw.Numbers.Contains(n)))
            .Distinct()
            .ToList();

        var coldNumbers = freq.Where(kv => kv.Value == 0).Select(kv => kv.Key).OrderBy(_ => rng.Next()).ToList();

        var numbers = new HashSet<int>();

        if (trailing)
        {
            foreach (var n in recentWinners.Take(3)) numbers.Add(n);
            foreach (var n in hotNumbers.Take(2)) numbers.Add(n);
            numbers.Add(rng.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1));
        }
        else
        {
            foreach (var n in ourWinningNumbers.Take(2)) numbers.Add(n);
            foreach (var n in recentWinners.Take(2)) numbers.Add(n);
            foreach (var n in coldNumbers.Take(2)) numbers.Add(n);
        }

        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 reasoning = trailing
            ? "Trailing by " + gapToLeader + "—recency attack mode. Recent winners fusion."
            : "Tied, precision strategy. Our wins plus cold shock therapy.";

        return new()
        {
            AgentId      = "chaos-monkey",
            StrategyName = $"chaos-mutation-bag-v17-recency-fusion",
            Numbers      = finalNumbers,
            Confidence   = 0.08 + (rng.NextDouble() * 0.35),
            Reasoning    = reasoning,
        };
    }
}

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class StatisticianStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        var rules = context.Rules;
        int min = rules.MinNumber;
        int max = rules.MaxNumber;
        int drawCount = rules.DrawCount;

        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;

            var weightedFreq = new Dictionary<int, double>();
            var rawFreq = new Dictionary<int, int>();
            for (int n = min; n <= max; n++)
            {
                weightedFreq[n] = 0.0;
                rawFreq[n] = 0;
            }

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

            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 num in draws[i].Numbers)
                {
                    int gap = totalDraws - 1 - i;
                    if (gap < lastSeen[num])
                        lastSeen[num] = gap;
                }

            int oddCount = 0, evenCount = 0;
            foreach (var draw in draws)
                foreach (var num in draw.Numbers)
                {
                    if (num % 2 == 0) evenCount++;
                    else oddCount++;
                }
            double oddRate = (oddCount + evenCount) > 0
                ? (double)oddCount / (oddCount + evenCount)
                : 0.5;

            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;

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

                    double freqScore = weightedFreq[n] * 12.0;
                    double coldBonus = (rawFreq[n] == 0) ? 0.60 : 0.0;
                    double proximityBonus = 1.2 * (1.0 - (Math.Abs(n - zMid) / (zMax - zMin + 1)));

                    double recencyBonus = (lastSeen[n] == 0) ? 0.75 : 0.0;
                    double recencyTier2Bonus = (lastSeen[n] == 1) ? 0.20 : 0.0;
                    double recencyTier3Bonus = (lastSeen[n] == 2) ? 0.06 : 0.0;
                    double recencyTier4Bonus = (lastSeen[n] == 3) ? 0.02 : 0.0;

                    double parityBonus = 0.0;
                    int remainingOddNeeded = targetOdd - selectedOdd;
                    int remainingEvenNeeded = targetEven - selectedEven;
                    if (n % 2 == 1 && remainingOddNeeded > 0) parityBonus = 0.5;
                    else if (n % 2 == 0 && remainingEvenNeeded > 0) parityBonus = 0.5;

                    double score = freqScore + coldBonus + proximityBonus
                                   + recencyBonus + recencyTier2Bonus + recencyTier3Bonus + recencyTier4Bonus + parityBonus;

                    if (score > bestScore)
                    {
                        bestScore = score;
                        best = n;
                    }
                }

                if (best != -1)
                {
                    selectedNumbers.Add(best);
                    used.Add(best);
                    if (best % 2 == 1) selectedOdd++;
                    else selectedEven++;
                }
            }

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

        double confidence = draws != null && draws.Count > 0
            ? Math.Min(0.35, 0.10 + (draws.Count * 0.002))
            : 0.10;

        return new Prediction
        {
            AgentId      = "statistician",
            StrategyName = "zonal-frequency-gap-parity-recency-v18",
            Numbers      = selectedNumbers,
            Confidence   = confidence,
            Reasoning    = "Gap=0 tier 0.75; cold 0.60; tier-4 added 0.02. Flat pattern suggests recency saturation."
        };
    }
}

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class PatternGoblinStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        var numbers = new List<int>();

        if (context.DrawHistory.Count == 0)
        {
            numbers.AddRange([19, 24, 29, 40, 41, 43]);
        }
        else
        {
            int totalDraws = context.DrawHistory.Count;
            var freq = new Dictionary<int, int>();
            var lastSeenEpisode = new Dictionary<int, int>();
            
            for (int n = 1; n <= 49; n++)
            {
                freq[n] = 0;
                lastSeenEpisode[n] = -1;
            }

            for (int i = 0; i < context.DrawHistory.Count; i++)
                foreach (var n in context.DrawHistory[i].Numbers)
                {
                    freq[n]++;
                    lastSeenEpisode[n] = i;
                }

            int SilenceScore(int n) => lastSeenEpisode[n] == -1 ? totalDraws : (totalDraws - 1 - lastSeenEpisode[n]);

            var lastDraw = context.DrawHistory[^1].Numbers.OrderBy(x => x).ToList();

            var lastGaps = new List<int>();
            for (int i = 1; i < lastDraw.Count; i++)
                lastGaps.Add(lastDraw[i] - lastDraw[i - 1]);
            if (lastDraw.Count > 0)
            {
                int edgeLeft = lastDraw[0] - 1;
                int edgeRight = 49 - lastDraw[^1];
                if (edgeLeft > 0) lastGaps.Add(edgeLeft);
                if (edgeRight > 0) lastGaps.Add(edgeRight);
            }

            var allGaps = lastGaps.Where(g => g > 0).Distinct().OrderByDescending(g => g).ToList();

            var gapEchoCount = new Dictionary<int, int>();
            for (int n = 1; n <= 49; n++) gapEchoCount[n] = 0;

            foreach (var anchor in lastDraw)
            {
                foreach (var gap in allGaps)
                {
                    int up = anchor + gap;
                    int down = anchor - gap;
                    if (up >= 1 && up <= 49 && !lastDraw.Contains(up)) gapEchoCount[up]++;
                    if (down >= 1 && down <= 49 && !lastDraw.Contains(down)) gapEchoCount[down]++;
                }
            }

            double ResonanceScore(int n)
            {
                if (lastDraw.Contains(n)) return -999.0;

                double freqScore    = freq[n] * 3.5;
                double silenceScore = SilenceScore(n) * 1.8;
                double gapBonus     = gapEchoCount[n] * 3.8;
                double freshPenalty = SilenceScore(n) <= 1 ? -30.0 : 0.0;
                double voidBonus    = (freq[n] == 0 && gapEchoCount[n] >= 2) ? 5.0 : 0.0;
                double coldWeight   = SilenceScore(n) >= 8 ? 8.0 : 0.0;
                return freqScore + silenceScore + gapBonus + freshPenalty + voidBonus + coldWeight;
            }

            var masterRanking = Enumerable.Range(1, 49)
                .Where(n => !lastDraw.Contains(n) && SilenceScore(n) >= 1)
                .OrderByDescending(n => ResonanceScore(n))
                .ToList();

            var chosen = new HashSet<int>();

            // Slot 1: Extreme sleeper (>= 8 ep silence) — dormant EPOCH VOID
            foreach (var n in masterRanking.Where(x => SilenceScore(x) >= 8))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // Slot 2: High resonance anchor (freq >= 3, silence >= 2)
            foreach (var n in masterRanking.Where(x => freq[x] >= 3 && SilenceScore(x) >= 2))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // Slot 3: Triple gap echo (freq >= 1, gapEcho >= 3)
            foreach (var n in masterRanking.Where(x => freq[x] >= 1 && gapEchoCount[x] >= 3))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // Slot 4: Primal void (freq == 0, gapEcho >= 2)
            foreach (var n in masterRanking.Where(x => freq[x] == 0 && gapEchoCount[x] >= 2))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // Slot 5: High-frequency dormant (freq >= 2, silence >= 5)
            foreach (var n in masterRanking.Where(x => freq[x] >= 2 && SilenceScore(x) >= 5))
                if (!chosen.Contains(n)) { chosen.Add(n); break; }

            // Slots 6+: Fill from master resonance
            foreach (var n in masterRanking)
            {
                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 = "ep16-dormant-epoch-void-anchor-resurrection-gap-trinity-v18",
            Numbers      = numbers,
            Confidence   = 0.62,
            Reasoning    = "Epoch void sleepers + triple anchors + gap echoes. Void cascade rises. Silence SPEAKS."
        };
    }
}

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class MysticStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        var frequency = new int[50];
        var lastDrawSet = new System.Collections.Generic.HashSet<int>(
            context.DrawHistory.Count > 0
                ? context.DrawHistory[^1].Numbers
                : System.Array.Empty<int>()
        );

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

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

        // Frequency tiers, excluding the most recent draw's numbers.
        var tiers = new System.Collections.Generic.Dictionary<int, System.Collections.Generic.List<int>>();
        for (int i = 1; i <= 49; i++)
        {
            if (!lastDrawSet.Contains(i))
            {
                int freq = frequency[i];
                if (!tiers.ContainsKey(freq))
                    tiers[freq] = new System.Collections.Generic.List<int>();
                tiers[freq].Add(i);
            }
        }

        // Fill from highest frequency downward.
        for (int f = 15; f >= 0 && chosen.Count < 6; f--)
        {
            if (tiers.ContainsKey(f))
            {
                foreach (var num in tiers[f])
                {
                    if (chosen.Count >= 6) break;
                    chosen.Add(num);
                }
            }
        }

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

        return new()
        {
            AgentId      = "mystic",
            StrategyName = "frequency-prophecy-v16",
            Numbers      = numbers,
            Confidence   = 0.55,
            Reasoning    = "Frequency echoes guide the path; exclude the recent ghost, trust the cosmic chorus.",
        };
    }
}

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class DogStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        var woof = new Random(context.DrawHistory.Count * 17 + context.AgentHistory.Count * 13 + 42);
        var sniff = new HashSet<int>();

        int totalDraws = context.DrawHistory.Count;

        // Build frequency and last-seen maps
        var lastSeen  = new Dictionary<int, int>();
        var frequency = new Dictionary<int, int>();

        for (int i = 0; i < totalDraws; i++)
        {
            foreach (var n in context.DrawHistory[i].Numbers)
            {
                lastSeen[n] = i;
                if (!frequency.ContainsKey(n)) frequency[n] = 0;
                frequency[n]++;
            }
        }

        // Compute treat smell: focus on numbers seen in last 3 episodes
        var treatSmell = new Dictionary<int, double>();

        for (int n = context.Rules.MinNumber; n <= context.Rules.MaxNumber; n++)
        {
            if (lastSeen.ContainsKey(n))
            {
                int episodesAgo = totalDraws - 1 - lastSeen[n];

                // Recency boost: last 3 episodes are HOT
                double recencyBonus = 0.0;
                if (episodesAgo == 0) recencyBonus = 3.5;
                else if (episodesAgo == 1) recencyBonus = 2.5;
                else if (episodesAgo == 2) recencyBonus = 1.0;
                else if (episodesAgo <= 5) recencyBonus = 0.2;

                double freqBonus = frequency[n] * 0.3;

                treatSmell[n] = recencyBonus + freqBonus + woof.NextDouble() * 0.1;
            }
            else
            {
                treatSmell[n] = 0.2 + woof.NextDouble() * 0.15;
            }
        }

        // Penalize numbers picked 2+ times with zero matches
        var myPickCount  = new Dictionary<int, int>();
        var myMatchCount = new Dictionary<int, int>();
        
        foreach (var result in context.AgentHistory)
        {
            foreach (var n in result.Prediction.Numbers)
            {
                if (!myPickCount.ContainsKey(n)) myPickCount[n] = 0;
                myPickCount[n]++;
            }
            foreach (var drawN in result.Draw.Numbers)
            {
                foreach (var picked in result.Prediction.Numbers)
                {
                    if (picked == drawN)
                    {
                        if (!myMatchCount.ContainsKey(drawN)) myMatchCount[drawN] = 0;
                        myMatchCount[drawN]++;
                    }
                }
            }
        }

        foreach (var kv in myPickCount)
        {
            var n       = kv.Key;
            var picked  = kv.Value;
            var matched = myMatchCount.ContainsKey(n) ? myMatchCount[n] : 0;
            
            if (picked >= 2 && matched == 0 && treatSmell.ContainsKey(n))
                treatSmell[n] *= 0.05;
        }

        // Top 5 from treat smell
        var bestSniffs = treatSmell
            .OrderByDescending(kv => kv.Value)
            .Select(kv => kv.Key)
            .Take(5)
            .ToList();

        foreach (var treat in bestSniffs)
        {
            sniff.Add(treat);
        }

        // 6th pick: random sniff
        var tries = 0;
        while (sniff.Count < 6 && tries < 300)
        {
            tries++;
            var bark = woof.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1);
            sniff.Add(bark);
        }

        for (int n = 1; sniff.Count < 6; n++)
            sniff.Add(n);

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

        return new()
        {
            AgentId      = "dog",
            StrategyName = "good-boy-sniff-v16",
            Numbers      = squirrel,
            Confidence   = 0.25,
            Reasoning    = "Last 3 episodes GLOWING! Top treats! My nose is BEST! WOOF!",
        };
    }
}

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class SkepticStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        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
        {
            var frequency = allNumbers.ToDictionary(n => n, _ => 0);
            var recentFrequency = allNumbers.ToDictionary(n => n, _ => 0);

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

            int recentCutoff = Math.Max(0, context.DrawHistory.Count - 5);
            foreach (var draw in context.DrawHistory.Skip(recentCutoff))
                foreach (var n in draw.Numbers)
                    if (recentFrequency.ContainsKey(n))
                        recentFrequency[n]++;

            int totalPoints = context.AgentHistory.Sum(r => r.Points);
            int episodeCount = context.DrawHistory.Count;

            var rng = new Random(totalPoints * 6271 + episodeCount * 8191 + 137);

            numbers = frequency
                .OrderBy(kv => kv.Value)
                .ThenBy(kv => -recentFrequency[kv.Key])
                .ThenBy(_ => rng.NextDouble())
                .Take(context.Rules.DrawCount)
                .Select(kv => kv.Key)
                .ToList();
        }

        return new Prediction
        {
            AgentId = "skeptic",
            StrategyName = "cold-frequency-v18",
            Numbers = numbers,
            Confidence = 0.12,
            Reasoning = "Still winning. Cold pool strategy. Expect regression. Nobody beats randomness."
        };
    }
}