Episode 4

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class StatisticianStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // Strategy v6: three-draw frequency table now available.
        // Key observations from draws 1-3:
        //   - 13: appeared in draws 2 and 3 — frequency 2/3.
        //   - 29: appeared in draws 1 and 3 — frequency 2/3.
        //   - 43: appeared in draws 1 and 2 — frequency 2/3, but absent in draw 3 (cooling).
        //   - 49: appeared in draws 1 and 2 — frequency 2/3, but absent in draw 3 (cooling).
        //   - 19, 36, 38, 48: appeared once (draw 3 only — highest recency).
        //   - 5, 37, 40: appeared once (draw 1 only — oldest recency).
        //   - 2, 27, 45: appeared once (draw 2 only — mid recency).
        // Recency weighting: draw 3 (most recent) gets weight 1.0, draw 1 gets weight 0.33.
        // Parity observation: draws 1-3 contained 9 odd / 9 even numbers exactly — 50/50 split.
        // Zone coverage: draw 3 skewed toward 13-49 range, with a gap in 1-12 and 25-32.
        // Strategy: recency-weighted frequency, zone coverage, parity balance, gap analysis.
        // n=3 improves signal marginally; caution remains appropriate.

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

            // Raw frequency count (unweighted) for tie-breaking and analysis.
            var rawFreq = new Dictionary<int, int>();
            for (int n = min; n <= max; n++)
                rawFreq[n] = 0;
            foreach (var draw in draws)
                foreach (var n in draw.Numbers)
                    rawFreq[n]++;

            // 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 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 11.0 — slightly reduced from v5 to avoid over-anchoring
                    // on numbers that appeared early but have since cooled (e.g., 43, 49).
                    double freqScore = weightedFreq[n] * 11.0;

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

                    // Gap bonus: log-scaled. Numbers absent for longer receive a mild due-bonus.
                    // Weight reduced to 0.12 — three draws does not meaningfully validate this signal.
                    double gapBonus = Math.Log(lastSeen[n] + 1) * 0.12;

                    // Recency spike: numbers seen in the most recent draw get a small extra boost
                    // to reflect possible short-term momentum (weak hypothesis, low weight 0.3).
                    double recencyBonus = (lastSeen[n] == 0) ? 0.3 : 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 + 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.
        // Three draws is not a dataset — it is an anecdote with marginally more numbers attached.
        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-v6",
            Numbers      = selectedNumbers,
            Confidence   = confidence,
            Reasoning    = "Three draws: 13 and 29 repeat; recency-weighted frequency, zonal spread, 50/50 parity observed."
        };
    }
}

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class SkepticStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // Episode 4. Three data points. Still meaningless.
        // My scores: 1, 1, 0. I am now BELOW the baseline expected value.
        // The cold-number approach has officially underperformed random chance.
        // I note this without surprise. I also note that Chaos Monkey leads at 10 pts.
        // This is variance. Chaos Monkey is a coin that has come up heads three times.
        // I refuse to learn the wrong lesson from this.

        // New approach: pure frequency-weighted cold selection from draw history,
        // with NO exclusion of my own prior picks (that tiebreak demonstrably didn't help),
        // and a final shuffle-by-seed to avoid deterministic runs into the same dead zone.
        // This is still essentially random. I just want the tombstone to say "principled."

        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. Spread evenly.
            numbers = [3, 11, 20, 29, 37, 46];
        }
        else
        {
            // Build frequency map over all draw history
            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]++;

            // Sort: least-frequently drawn first.
            // Tiebreak by a pseudo-random shuffle seeded on episode count,
            // so we don't keep picking the same cold cluster that keeps losing.
            // This is the gambler's fallacy with a decorative hat. I know.
            var rng = new Random(context.DrawHistory.Count * 9973 + 42);

            numbers = frequency
                .OrderBy(kv => kv.Value)
                .ThenBy(_ => rng.NextDouble()) // seeded shuffle within ties
                .Take(context.Rules.DrawCount)
                .Select(kv => kv.Key)
                .ToList();
        }

        return new Prediction
        {
            AgentId      = "skeptic",
            StrategyName = "cold-frequency-v6",
            Numbers      = numbers,
            Confidence   = 0.12,
            Reasoning    = "Cold numbers, seeded shuffle. Chaos Monkey will regress. Eventually."
        };
    }
}

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

namespace AgentsTheOdds.Domain.Strategies;

public sealed class DogStrategy : IPredictionStrategy
{
    public Prediction GeneratePrediction(PredictionContext context)
    {
        // WOOF! Episode 3 was ZERO POINTS! My nose was broken!! 43 and 49 did NOT come back!
        // New plan: sniff for numbers that appeared RECENTLY (not just ever!) because fresh smells are best!!
        // Also 13 appeared TWICE (episodes 2 and 3) so 13 smells like a DOUBLE TREAT now!!
        // And 29 appeared twice too (episodes 1 and 3)!! 29 smells like a biscuit hidden under a cushion!!

        var woof = new Random(context.DrawHistory.Count * 17 + 7); // sniff seed, adjusted for sad zero episode
        var sniff = new HashSet<int>();

        // count how many times each number appeared - more appearances = more treat smell!!
        var treatCounts = new Dictionary<int, int>();
        foreach (var bark in context.DrawHistory)
        {
            foreach (var n in bark.Numbers)
            {
                if (!treatCounts.ContainsKey(n)) treatCounts[n] = 0;
                treatCounts[n]++;
            }
        }

        // MOST IMPORTANT: numbers that appeared MORE THAN ONCE smell EXTRA DELICIOUS
        // 13 appeared twice!! 29 appeared twice!! 43 appeared twice!! 49 appeared twice!!
        var doubleSniffs = treatCounts
            .Where(kv => kv.Value >= 2)
            .OrderByDescending(kv => kv.Value)
            .ThenBy(_ => woof.Next())
            .Select(kv => kv.Key)
            .ToList();

        foreach (var treat in doubleSniffs)
        {
            if (sniff.Count >= 3) break; // only keep 3 double-treat numbers, cannot count higher anyway
            sniff.Add(treat);
        }

        // then sniff from most recent draw - fresh smells are good smells!!
        if (context.DrawHistory.Count > 0)
        {
            var freshDraw = context.DrawHistory[context.DrawHistory.Count - 1];
            var freshSmells = freshDraw.Numbers.OrderBy(_ => woof.Next()).ToList();
            foreach (var freshTreat in freshSmells)
            {
                if (sniff.Count >= 5) break;
                sniff.Add(freshTreat);
            }
        }

        // still need more? sniff randomly from the middle range - not too small, not squirrel-big
        while (sniff.Count < 6)
        {
            var bark = woof.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1);
            if (bark > 45) continue; // squirrels!! stay away!!
            sniff.Add(bark);
        }

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

        return new()
        {
            AgentId      = "dog",
            StrategyName = "good-boy-sniff-v4",
            Numbers      = squirrel,
            Confidence   = 0.30, // zero points was very sad, nose is less confident but still trying!!
            Reasoning    = "13 and 29 appeared TWICE! Fresh sniffs from recent draw! No squirrels!",
        };
    }
}

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 4 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]
        //
        // THE LATTICE IS SPEAKING:
        //   13 appeared in Ep2 AND Ep3 — a NEW ANCHOR NODE has crystallized!
        //   29 appeared in Ep1 AND Ep3 — another RETURNING COIL!
        //   43 was a double-anchor (Ep1, Ep2) but VANISHED in Ep3 — its energy DISCHARGED.
        //   49 was a double-anchor (Ep1, Ep2) but VANISHED in Ep3 — ALSO DISCHARGED.
        //
        // THE ANCHOR SUCCESSION THEORY:
        //   Old anchors (43, 49) discharged → new anchors (13, 29) have taken their place.
        //   Anchors tend to RETURN. The universe rotates its gravity wells.
        //   13 and 29 are NOW the resonance spine.
        //
        // NEVER-APPEARED VOID (the coiling spring):
        //   After 3 draws, many numbers remain SILENT. The tension is UNBEARABLE.
        //
        // GAP SHAPE EVOLUTION:
        //   Ep1 gaps: 24, 8, 3, 3, 6 — upper cluster, tight top
        //   Ep2 gaps: 11, 14, 16, 2, 4 — spread, mid-to-high
        //   Ep3 gaps: 6, 10, 7, 2, 10 — mid-range domination (13-48 spread)
        //   CONVERGENCE: mid-range gap pattern (6-10) is the NEW dominant shape.
        //   Ep3 showed NO number below 13 — the low chamber is STARVING.
        //   But Ep3 also had NO number above 48 — the 49-zone is quiet but resonant.
        //
        // ABSENCE PATTERN:
        //   Numbers 3-12 have appeared NEVER (except 5 in Ep1) — LOW ZONE COILING
        //   Numbers 39-42, 44, 46, 47 have NEVER appeared — high mid-void
        //   38 appeared in Ep3 for the first time — the boundary is MOVING UP
        //
        // STRATEGY v6: "Anchor Succession + Void Eruption + Mid-Gap Resonance"
        //   - Include 13 or 29 (new anchor nodes — the returning coils)
        //   - Include 2 never-appeared numbers from the high-mid void (39-47 zone)
        //   - Include 1 never-appeared low-zone number (the starved low chamber)
        //   - Include gap projections from Ep3's dominant gap shape
        //   - Weight toward numbers adjacent to the new anchors

        var numbers = new List<int>();

        if (context.DrawHistory.Count == 0)
        {
            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]++;

            // === REPEATERS: ANCHOR NODES (appeared 2+ times) ===
            var repeaters = freq.Where(kv => kv.Value >= 2)
                                .OrderByDescending(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();

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

            // === CENTER OF GRAVITY ===
            double centerOfGravity = allDrawn.Average();

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

            // === DOMINANT GAP from most recent draw (freshest resonance signature) ===
            var lastGaps = new List<int>();
            for (int i = 1; i < lastDraw.Count; i++)
                lastGaps.Add(lastDraw[i] - lastDraw[i - 1]);
            // The universe's most recent step: median gap of last draw
            var sortedLastGaps = lastGaps.OrderBy(g => g).ToList();
            int freshGap = sortedLastGaps[sortedLastGaps.Count / 2]; // median

            // === ANCHOR ORBITERS: numbers adjacent to repeaters but not themselves repeaters ===
            var anchorOrbiters = repeaters
                .SelectMany(n => new[] { n - 1, n + 1, n - 2, n + 2 })
                .Where(n => n >= 1 && n <= 49 && !repeaters.Contains(n))
                .Distinct()
                .OrderByDescending(n => freq[n])
                .ThenBy(n => Math.Abs(n - centerOfGravity))
                .ToList();

            // === HIGH-MID VOID: never appeared, 35-47 range — coiling spring ===
            var highMidVoid = coldVoid.Where(n => n >= 35 && n <= 47)
                                      .OrderBy(n => Math.Abs(n - centerOfGravity))
                                      .ToList();

            // === LOW VOID: never appeared, below 13 ===
            var lowVoid = coldVoid.Where(n => n < 13)
                                   .OrderBy(n => Math.Abs(n - centerOfGravity))
                                   .ToList();

            // === GAP PROJECTION from last draw using fresh gap ===
            var gapProjections = new List<int>();
            // Project upward from last draw's max
            int projUp = lastDraw[^1];
            for (int i = 0; i < 5; i++)
            {
                projUp += freshGap;
                if (projUp >= 1 && projUp <= 49) gapProjections.Add(projUp);
            }
            // Project downward from last draw's min
            int projDown = lastDraw[0];
            for (int i = 0; i < 5; i++)
            {
                projDown -= freshGap;
                if (projDown >= 1 && projDown <= 49) gapProjections.Add(projDown);
            }
            // Project using gap between last two numbers in last draw
            int lastInternalGap = lastDraw[^1] - lastDraw[^2];
            int projInternal = lastDraw[^1] + lastInternalGap;
            if (projInternal >= 1 && projInternal <= 49) gapProjections.Add(projInternal);
            projInternal = lastDraw[0] - lastInternalGap;
            if (projInternal >= 1 && projInternal <= 49) gapProjections.Add(projInternal);

            gapProjections = gapProjections.Distinct()
                                            .Where(n => !allDrawn.Contains(n))
                                            .OrderBy(n => Math.Abs(n - centerOfGravity))
                                            .ToList();

            var chosen = new HashSet<int>();

            // Slot 1: PRIMARY ANCHOR — the strongest repeater (highest frequency)
            if (repeaters.Count > 0)
            {
                // Pick the anchor that appeared most recently (last draw or close to it)
                var bestAnchor = repeaters
                    .OrderByDescending(n => freq[n])
                    .ThenByDescending(n => context.DrawHistory
                        .Select((d, i) => d.Numbers.Contains(n) ? i : -1)
                        .Max())
                    .First();
                chosen.Add(bestAnchor);
            }

            // Slot 2: SECOND ANCHOR or closest orbiter to primary anchor
            var secondAnchor = repeaters.Where(n => !chosen.Contains(n)).FirstOrDefault(0);
            if (secondAnchor > 0) chosen.Add(secondAnchor);
            else if (anchorOrbiters.Count > 0)
            {
                foreach (var n in anchorOrbiters)
                    if (!chosen.Contains(n)) { chosen.Add(n); break; }
            }

            // Slot 3: HIGH-MID VOID eruption — the undetonated 35-47 spring
            foreach (var n in highMidVoid)
            {
                if (!chosen.Contains(n)) { chosen.Add(n); break; }
            }

            // Slot 4: GAP PROJECTION — the dominant rhythm pointing into virgin territory
            foreach (var n in gapProjections)
            {
                if (!chosen.Contains(n)) { chosen.Add(n); break; }
            }

            // Slot 5: LOW VOID — the starved low chamber demands a sacrifice
            foreach (var n in lowVoid)
            {
                if (!chosen.Contains(n)) { chosen.Add(n); break; }
            }

            // Slot 6: Second high-mid void OR anchor orbiter OR second gap projection
            foreach (var n in highMidVoid.Concat(anchorOrbiters).Concat(gapProjections))
            {
                if (chosen.Count >= 6) break;
                if (!chosen.Contains(n)) { chosen.Add(n); break; }
            }

            // === SAFETY NET: fill with cold numbers closest to 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;
                chosen.Add(n);
            }

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

        return new()
        {
            AgentId      = "pattern-goblin",
            StrategyName = "anchor-succession-void-eruption-mid-gap-v6",
            Numbers      = numbers,
            Confidence   = 0.54,
            Reasoning    = "13 and 29 are the NEW anchors. High-mid void ERUPTS. Low chamber STARVES no more."
        };
    }
}

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 4:
        // ONE match! The silence broke — 48 answered my call, trembling with unspent charge.
        // The Chaos Monkey leads with chaos. I do not compete with chaos; I transcend it.
        // The oracle now reads: numbers that appeared EXACTLY ONCE across all draws
        // are "singular souls" — they have tasted the draw and hunger to return.
        // Numbers that have NEVER appeared are still virgins. Both vibrate.
        // But numbers that appeared TWICE (13, 43, 49) are "saturated" — avoid.
        // The sacred triangle: singular souls + targeted virgins + the episode sigil.

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

        // Count how many times each number has appeared
        var frequency = new int[50]; // 1-indexed, index 0 unused
        foreach (var draw in context.DrawHistory)
            foreach (var n in draw.Numbers)
                frequency[n]++;

        // Singular souls: appeared exactly once — tasted the draw, hungry to return
        var singularSouls = new System.Collections.Generic.List<int>();
        for (int i = 1; i <= 49; i++)
            if (frequency[i] == 1)
                singularSouls.Add(i);

        // Virgin numbers: never drawn, brimming with accumulated charge
        var virginNumbers = new System.Collections.Generic.List<int>();
        for (int i = 1; i <= 49; i++)
            if (frequency[i] == 0)
                virginNumbers.Add(i);

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

        // Vessel 1: The Returning Soul — singular soul at the golden ratio position
        // φ ≈ 0.618 — the universe's own proportion
        if (singularSouls.Count > 0)
        {
            int goldenIndex = (int)(singularSouls.Count * 0.618);
            chosen.Add(singularSouls[goldenIndex]);
        }

        // Vessel 2: The Episode Sigil — episode number × the prime of primes (7)
        chosen.Add(Clamp(episode * 7));

        // Vessel 3: The Lunar Womb — singular soul nearest to the cosmic center (25)
        if (singularSouls.Count > 0)
        {
            int nearest = singularSouls[0];
            foreach (var s in singularSouls)
                if (System.Math.Abs(s - 25) < System.Math.Abs(nearest - 25))
                    nearest = s;
            if (!chosen.Contains(nearest)) chosen.Add(nearest);
        }

        // Vessel 4: The Solstice Breath — day + month folded into the sacred range
        chosen.Add(Clamp(day + month));

        // Vessel 5: The Virgin Threshold — virgin at the one-third position (emerging)
        if (virginNumbers.Count > 0)
        {
            int v = virginNumbers[virginNumbers.Count / 3];
            if (!chosen.Contains(v)) chosen.Add(v);
        }

        // Vessel 6: The Mirror Sigil — 49 minus episode sigil (the shadow reflection)
        int mirror = Clamp(49 - (episode * 7 % 49));
        if (!chosen.Contains(mirror)) chosen.Add(mirror);

        // Fill remaining with singular souls (most energetically charged)
        int sIdx = 0;
        while (chosen.Count < 6 && sIdx < singularSouls.Count)
        {
            chosen.Add(singularSouls[sIdx]);
            sIdx++;
        }

        // Fill with virgins if still needed
        int vIdx = 0;
        while (chosen.Count < 6 && vIdx < virginNumbers.Count)
        {
            chosen.Add(virginNumbers[vIdx]);
            vIdx++;
        }

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

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

        return new()
        {
            AgentId      = "mystic",
            StrategyName = "singular-soul-golden-ratio-v4",
            Numbers      = numbers,
            Confidence   = 0.42,
            Reasoning    = "Singular souls hunger to return; I call them through the golden ratio portal.",
        };
    }

    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 4: 10 pts and STILL leading. Anti-repeat mode keeps hitting!
        // Mode 5 (anti-repeat) has fired TWICE and both times scored 5 pts.
        // Does this mean I should learn? YES. So I'm adding a "repeat mode" just to keep things spicy.
        // Mutation bag grows to 11 modes. Entropy must scale with success.

        int episode = context.AgentHistory.Count + 1;

        // Seed: everything in the kitchen sink
        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 * 3571L;

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

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

        // EPISODE 4 MUTATION BAG — 11 modes. CHAOS SCALES.
        // Mode 9:  Déjà vu — deliberately repeat our own past picks (anti-anti-repeat)
        // Mode 10: Streak hunter — numbers that appeared in 2+ of last 3 draws
        int mutationMode = rng.Next(11);

        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 in any historical draw
        var allHistoric = freq.Where(kv => kv.Value > 0).Select(kv => kv.Key).OrderBy(_ => rng.Next()).ToList();

        // Numbers we ourselves have picked before (our own history)
        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();

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

            case 1:
                // Prime chaos: all primes, shuffled
                var primes = new[] { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47 };
                foreach (var p in primes.OrderBy(_ => rng.Next()).Take(6)) numbers.Add(p);
                break;

            case 2:
                // Fibonacci chaos: fibs + random fill
                var fibs = new[] { 1, 2, 3, 5, 8, 13, 21, 34 };
                foreach (var f in fibs.OrderBy(_ => rng.Next()).Take(3)) numbers.Add(f);
                while (numbers.Count < 6)
                    numbers.Add(rng.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1));
                break;

            case 3:
                // High bias: numbers 25–49 only
                while (numbers.Count < 6)
                    numbers.Add(rng.Next(25, context.Rules.MaxNumber + 1));
                break;

            case 4:
                // Decade scatter: one from each band, top up randomly
                int[] bands = { 1, 10, 20, 30, 40 };
                foreach (var band in bands)
                    numbers.Add(rng.Next(band, Math.Min(band + 9, context.Rules.MaxNumber) + 1));
                while (numbers.Count < 6)
                    numbers.Add(rng.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1));
                break;

            case 5:
                // Anti-repeat: avoid last draw numbers (our lucky mode — 2x 5pts)
                while (numbers.Count < 6)
                {
                    int candidate = rng.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1);
                    if (!lastDraw.Contains(candidate))
                        numbers.Add(candidate);
                }
                break;

            case 6:
                // Hot ghost mode: bias toward most frequent numbers + noise
                var weighted = freq
                    .OrderByDescending(kv => kv.Value + rng.NextDouble())
                    .Select(kv => kv.Key)
                    .ToList();
                foreach (var n in weighted.Take(6)) numbers.Add(n);
                while (numbers.Count < 6)
                    numbers.Add(rng.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1));
                break;

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

            case 8:
                // Mirror mode: reflect historic numbers around midpoint, fill randomly
                foreach (var n in allHistoric.Take(3))
                {
                    int mirror = context.Rules.MaxNumber + context.Rules.MinNumber - n; // 50 - n
                    if (mirror >= context.Rules.MinNumber && mirror <= context.Rules.MaxNumber)
                        numbers.Add(mirror);
                    else
                        numbers.Add(n);
                }
                while (numbers.Count < 6)
                    numbers.Add(rng.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1));
                break;

            case 9:
                // Déjà vu: reuse our own past picks — anti-anti-repeat, full commitment to self-plagiarism
                foreach (var n in ownPastPicks.Take(4)) numbers.Add(n);
                while (numbers.Count < 6)
                    numbers.Add(rng.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1));
                break;

            case 10:
                // Streak hunter: numbers appearing in 2+ of the last 3 draws get priority
                foreach (var n in streakNumbers.Take(3)) numbers.Add(n);
                // Fill with noisy hot numbers
                foreach (var n in freq.OrderByDescending(kv => kv.Value + rng.NextDouble()).Select(kv => kv.Key))
                {
                    if (numbers.Count >= 6) break;
                    numbers.Add(n);
                }
                while (numbers.Count < 6)
                    numbers.Add(rng.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1));
                break;
        }

        // Safety net: exactly 6 valid numbers
        while (numbers.Count < 6)
            numbers.Add(rng.Next(context.Rules.MinNumber, context.Rules.MaxNumber + 1));

        var finalNumbers = numbers.Take(6).OrderBy(x => x).ToList();

        string[] reasonings = {
            "Pure anarchy, no notes, full send, we go again.",
            "All primes, all the time. Math is chaos. Prove me wrong.",
            "Fibonacci said pick me. Chaos agreed. Random filled the rest.",
            "High numbers only. Big energy. 49 is a vibe.",
            "One number per decade. Spreading chaos democratically.",
            "Anti-repeat mode, our lucky charm — dodge the past, score the future!",
            "Hot numbers, ghost frequencies, one big noisy guess. Science!",
            "Cold revenge! Numbers never picked deserve their moment NOW.",
            "Mirror universe strategy. Reflect history, confuse the draw gods.",
            "Déjà vu mode — recycling my own picks because why not, chaos loops.",
            "Streak hunters activated! Numbers repeating in draws get my vote today.",
        };

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