#![allow(dead_code)]

use rand::seq::SliceRandom;
use rand::thread_rng;
use std::fmt;

fn main() {
    let mut deck = Deck::new();
    println!("{}", deck.draw(5));
}

struct Deck {
    cards: Vec<Card>,
}

impl Default for Deck {
    fn default() -> Self {
        Deck {
            cards: build_deck(suits(), ranks()).to_vec(),
        }
    }
}

impl fmt::Debug for Deck {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        self.cards[..].fmt(f)
    }
}

impl fmt::Display for Deck {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        display_vec(f, &self.cards)
    }
}

impl Deck {
    fn new() ->Self {
        let mut deck = Deck::default();
        deck.shuffle();
        deck
    }

    fn shuffle(&mut self) -> &Self {
        self.cards.shuffle(&mut thread_rng());
        self
    }

    fn draw(&mut self, n: usize) -> Hand {
        let cards: Vec<Card> = self.cards.iter().cloned().take(n).collect();
        self.cards.retain(|c| !cards.contains(c));
        Hand { cards }
    }

    fn len(&self) -> usize {
        self.cards.len()
    }
}

struct Hand {
    cards: Vec<Card>
}

impl fmt::Display for Hand {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        display_vec(f, &self.cards)
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Copy, Clone)]
struct Card {
    suit: Suit,
    rank: Rank,
}

impl Default for Card {
    fn default() -> Self {
        Card {
            suit: Suit::Club,
            rank: Rank::Ace,
        }
    }
}

impl fmt::Display for Card {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}{}", rank_to_str(&self.rank), suit_to_char(self.suit))
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Copy, Clone)]
enum Suit {
    Spade = 4,
    Club = 3,
    Heart = 2,
    Diamond = 1,
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Copy, Clone)]
enum Rank {
    Ace = 14,
    King = 13,
    Queen = 12,
    Jack = 11,
    Ten = 10,
    Nine = 9,
    Eight = 8,
    Seven = 7,
    Six = 6,
    Five = 5,
    Four = 4,
    Three = 3,
    Two = 2,
}

fn suit_to_char(suit: Suit) -> char {
    match suit {
        Suit::Spade => '♠',
        Suit::Club => '♣',
        Suit::Heart => '♥',
        Suit::Diamond => '♦',
    }
}

fn rank_to_str(rank: &Rank) -> &str {
    match rank {
        Rank::Ace => "A",
        Rank::King => "K",
        Rank::Queen => "Q",
        Rank::Jack => "J",
        Rank::Ten => "10",
        Rank::Nine => "9",
        Rank::Eight => "8",
        Rank::Seven => "7",
        Rank::Six => "6",
        Rank::Five => "5",
        Rank::Four => "4",
        Rank::Three => "3",
        Rank::Two => "2",
    }
}

fn suits() -> [Suit; 4] {
    [Suit::Spade, Suit::Club, Suit::Heart, Suit::Diamond]
}

fn ranks() -> [Rank; 13] {
    [
        Rank::Ace,
        Rank::King,
        Rank::Queen,
        Rank::Jack,
        Rank::Ten,
        Rank::Nine,
        Rank::Eight,
        Rank::Seven,
        Rank::Six,
        Rank::Five,
        Rank::Four,
        Rank::Three,
        Rank::Two,
    ]
}

fn build_deck(a: [Suit; 4], b: [Rank; 13]) -> [Card; 52] {
    let mut deck: [Card; 52] = [Card::default(); 52];

    let mut i = 0;

    for suit in &a {
        for rank in &b {
            deck[i] = Card {
                suit: *suit,
                rank: *rank,
            };
            i += 1;
        }
    }

    deck
}

fn display_vec<T: fmt::Display>(f: &mut fmt::Formatter, v: &Vec<T>) -> fmt::Result {
    let mut ret = String::new();
    let len = v.len();

    for (i, item) in v.iter().enumerate() {
        let comma = if i == len - 1 { "" } else { ", " };
        ret.push_str(&format!("{}{}", item, comma));
    }
    write!(f, "{}", ret)
}

#[test]
fn test_suit_to_char() {
    let char = '♠';
    let suit = Suit::Spade;
    assert_eq!(char, suit_to_char(&suit));
}

#[test]
fn test_rank_to_str() {
    let queen_str = "Q";
    let queen_rank = Rank::Queen;
    assert_eq!(queen_str, rank_to_str(&queen_rank));
}

#[test]
fn test_suit_order() {
    let spade = Suit::Spade;
    let diamond = Suit::Diamond;
    assert!(spade > diamond);
}

#[test]
fn test_rank_order() {
    let queen = Rank::Queen;
    let jack = Rank::Jack;

    assert!(queen > jack);
}