use super::card::Card;
use rand::random_range;

pub struct Deck {
    deck_size: u64,
    current_card: u64,
    cards: Vec<Card>,
}

impl Deck {
    pub fn new(num_decks: u64) -> Self {
        let deck_size: u64 = num_decks * 52;
        let mut cards: Vec<Card> = Vec::with_capacity(deck_size as usize);

        for card in 0..deck_size {
            let value = (card % 13) as u8;
            let suit = ((card / 13) % 4) as u8;

            cards.push(Card {
                value: value,
                suit: suit,
            });
        }

        Deck {
            deck_size: deck_size,
            current_card: 0,
            cards: cards,
        }
    }

    pub fn get_next_card(&mut self) -> Card {
        let next_card = self.cards[self.current_card as usize];
        self.current_card += 1;

        next_card
    }

    pub fn deck_size(&self) -> usize {
        self.deck_size as usize
    }

    pub fn cur_card(&self) -> u64 {
        self.current_card
    }

    pub fn shuffle(&mut self) {
        for _ in 0..1000 {
            for card in 0..self.deck_size {
                let swap_card = random_range(0..self.deck_size);
                let save_card = self.cards[card as usize];
                self.cards[card as usize] = self.cards[swap_card as usize];
                self.cards[swap_card as usize] = save_card;
            }
        }
    }
}