use rand::{Rng, rngs::StdRng, SeedableRng};
use sqlx::Row;

/// A user's personal deck. Each card represents one future outcome.
/// When empty, the deck is reshuffled — guaranteeing the user *will* win,
/// just not when. Pure RNG can't promise that.
#[derive(Debug, Clone)]
struct Deck {
    cards: Vec<Card>,    // remaining cards, FIFO
    cursor: u16,         // position for tamper-proof commit
    tier: Tier,          // current "session strength"
    bad_streak: u8,      // soft-pity counter
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Card { Crumbs, Small, Medium, Good, Flush, Reserve, Buffer }

#[derive(Debug, Clone, Copy)]
enum Tier { Tiny, Small, Medium, Big, Whale }

impl Deck {
    /// Build a fresh deck with composition shaped by tier and pity.
    /// Higher tier → more "Good"/"Flush" cards. Long bad streak → upgrade tier.
    fn rebuild(tier: Tier, bad_streak: u8, rng: &mut impl Rng) -> Self {
        // The exact mix is the secret sauce — left abstract on purpose.
        let mut cards = compose_deck(tier, bad_streak);
        shuffle(&mut cards, rng);
        Self { cards, cursor: 0, tier, bad_streak: 0 }
    }

    /// Draw the next card. The deck *commits* to its remaining future
    /// the moment it's shuffled — players can't reroll, can't skip.
    fn draw(&mut self) -> Option<Card> {
        let c = self.cards.pop()?;
        self.cursor += 1;
        Some(c)
    }
}

impl Deck {
    /// Expected value of *what's left*. A deck knows its own future.
    fn ev_remaining(&self, pool: u64) -> u64 {
        self.cards.iter().map(|c| card_value(*c, pool)).sum::<u64>()
            / self.cards.len().max(1) as u64
    }
}

/// One lottery event — atomic and idempotent.
/// The pool, the deck, the ledger: all move together or not at all.
async fn deal_card(
    db: &sqlx::PgPool,
    user_id: i32,
    activity: u64,
    source_id: &str,
) -> anyhow::Result<Outcome> {
    let mut tx = db.begin().await?;

    // Lock the row to prevent concurrent draws
    let row = sqlx::query(
        "SELECT deck, cursor, tier, bad_streak, pool_balance \
         FROM lottery_state WHERE user_id = $1 FOR UPDATE"
    )
    .bind(user_id)
    .fetch_one(&mut tx)
    .await?;

    let mut deck = decode_deck(&row);
    let pool: u64 = row.get::<i64, _>("pool_balance") as u64;

    // Empty deck = a fresh promise. Tier may shift based on activity.
    if deck.cards.is_empty() {
        let mut rng = StdRng::from_entropy();
        let tier = upgrade_tier(deck.tier, deck.bad_streak, activity);
        deck = Deck::rebuild(tier, deck.bad_streak, &mut rng);
    }

    let card = deck.draw().expect("just rebuilt");
    let prize = card_value(card, pool);

    // Pity accumulates on weak draws — feeds back into tier upgrades.
    deck.bad_streak = if prize == 0 { deck.bad_streak + 1 } else { 0 };

    sqlx::query(
        "UPDATE lottery_state SET deck = $1, cursor = $2, tier = $3, \
         bad_streak = $4, pool_balance = pool_balance - $5 \
         WHERE user_id = $6"
    )
    .bind(encode_deck(&deck))
    .bind(deck.cursor as i32)
    .bind(deck.tier as i32)
    .bind(deck.bad_streak as i32)
    .bind(prize as i64)
    .bind(user_id)
    .execute(&mut tx)
    .await?;

    // Replay-safe ledger: same source_id = same outcome, always.
    sqlx::query(
        "INSERT INTO ledger (user_id, card, amount, source_id) \
         VALUES ($1, $2, $3, $4) ON CONFLICT (source_id) DO NOTHING"
    )
    .bind(user_id)
    .bind(format!("{:?}", card))
    .bind(prize as i64)
    .bind(source_id)
    .execute(&mut tx)
    .await?;

    tx.commit().await?;

    Ok(Outcome { 
        card, 
        prize, 
        ev_remaining: deck.ev_remaining(pool) // Revealing the future to the UI
    })
}

struct Outcome {
    card: Card,
    prize: u64,
    ev_remaining: u64,
}