/// This is the implementation of a Deck of cards.
/// There are two basic kinds:
/// 1. The Game Deck, automatically generated 104 cards.
/// 2. Any Deck-type pile, like the hand of a Player.
/// Descks can be shuffled, cards pushed to bottom and
/// pulled from top. Maybe others, too.
/// 

use std::collections::VecDeque;
use rand::Rng;

/// We reference [`Card`]s
use crate::card::Card;

#[derive(Debug)]
/// A Deck is an ordered two-ended vector (`VecDeque`) of [`Card`]s.
pub(crate) struct Deck {
    content: VecDeque<Card>,
}

impl Deck {
    /// Creates an empty [`Deck`] of undefined size
    pub(crate) fn new_empty() -> Self {
        debug!("Empty deck generated");
        Deck {
            content: VecDeque::new(),
        }
    }

    /// Creates a new full [`Deck`] with 104 cards.
    pub(crate) fn new() -> Self {
        debug!("Full deck generated");
        let content = (1..=104).into_iter().map( |n| Card::new(n) ).collect();
        Deck {
            content,
        }
    }

    /// Shuffles this [`Deck`] (using its default method)
    pub(crate) fn shuffle( &mut self ) {
        let mut rng = rand::thread_rng();
        
        trace!("Deck before shuffle: len {}, {:?}", self.content.len(), self);
        debug!("Deck shuffled");
        // shufflers:
        // * naive: swap cards n times
        // * kgb: half the deck, take 1..4 cards sequentially from each
        // * grin: take 1..6 from front and put at bottom

        // naive shuffle: exchange <n> random cards
        for _ in 1..=500 {
            // Generate two random positions of cards in Deck
            let c1 = rng.gen_range(0 .. self.content.len());
            let c2 = rng.gen_range(0 .. self.content.len());
            // If it's not the same card we swap them in the `content` vector.
            // The `swap()` funtion handles ownership and does not angry 
            // the borrow checker.
            if c1 != c2 {
                self.content.swap(c1, c2);
            }
        }
        trace!("Deck after shuffle: len {}, {:?}", self.content.len(), self);
    }

    /// Returns the top card of this [`Deck`].
    pub(crate) fn pop( &mut self ) -> Option<Card> {
        self.content.pop_front() 
    }

    /// Put a card into the bottom of the [`Deck`]
    pub(crate) fn push( &mut self, c: Card ) {
        self.content.push_back(c);
    }

    /// Push multiple cards to the bottom of the [`Deck`]
    pub(crate) fn push_cards( &mut self, cards: VecDeque<Card> ) {
        trace!("Collecting back, deck len is {}, cards {}", self.content.len(), cards.len());
        cards.into_iter().for_each( |card| self.push(card) );
        trace!("Deck len is {}", self.content.len());
    }

    /// Returns the length of this [`Deck`].
    pub(crate) fn len( &self ) -> usize {
        self.content.len()
    }

    /// Take a card from inside of the Deck.
    /// Using an illegal index will `panic!()`, so don't.
    fn _get_nth( &mut self, n: usize ) -> Card {
        if let Some(c) = self.content.remove(n) {
            c
        } else {
            panic!("get_nth: index {} out of bounds ({})!", n, self.content.len());
        }
    }
}